[unix-history] / usr / src / sys / ufs / ffs / ffs_vnops.c

/*
* Copyright (c) 1982, 1986, 1989 Regents of the University of California.
* All rights reserved.
*
* %sccs.include.redist.c%
*
*      @(#)ffs_vnops.c 7.102 (Berkeley) %G%
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>

#include <vm/vm.h>

#include <miscfs/specfs/specdev.h>
#include <miscfs/fifofs/fifo.h>

#include <ufs/ufs/lockf.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/dir.h>
#include <ufs/ufs/ufs_extern.h>

#include <ufs/ffs/fs.h>
#include <ufs/ffs/ffs_extern.h>

/* Global vfs data structures for ufs. */
int (**ffs_vnodeop_p)();
struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
       { &vop_default_desc, vn_default_error },
       { &vop_lookup_desc, ufs_lookup },               /* lookup */
       { &vop_create_desc, ufs_create },               /* create */
       { &vop_mknod_desc, ufs_mknod },                 /* mknod */
       { &vop_open_desc, ufs_open },                   /* open */
       { &vop_close_desc, ufs_close },                 /* close */
       { &vop_access_desc, ufs_access },               /* access */
       { &vop_getattr_desc, ufs_getattr },             /* getattr */
       { &vop_setattr_desc, ufs_setattr },             /* setattr */
       { &vop_read_desc, ffs_read },                   /* read */
       { &vop_write_desc, ffs_write },                 /* write */
       { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
       { &vop_select_desc, ufs_select },               /* select */
       { &vop_mmap_desc, ufs_mmap },                   /* mmap */
       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
       { &vop_seek_desc, ufs_seek },                   /* seek */
       { &vop_remove_desc, ufs_remove },               /* remove */
       { &vop_link_desc, ufs_link },                   /* link */
       { &vop_rename_desc, ufs_rename },               /* rename */
       { &vop_mkdir_desc, ufs_mkdir },                 /* mkdir */
       { &vop_rmdir_desc, ufs_rmdir },                 /* rmdir */
       { &vop_symlink_desc, ufs_symlink },             /* symlink */
       { &vop_readdir_desc, ufs_readdir },             /* readdir */
       { &vop_readlink_desc, ufs_readlink },           /* readlink */
       { &vop_abortop_desc, ufs_abortop },             /* abortop */
       { &vop_inactive_desc, ufs_inactive },           /* inactive */
       { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
       { &vop_lock_desc, ufs_lock },                   /* lock */
       { &vop_unlock_desc, ufs_unlock },               /* unlock */
       { &vop_bmap_desc, ufs_bmap },                   /* bmap */
       { &vop_strategy_desc, ufs_strategy },           /* strategy */
       { &vop_print_desc, ufs_print },                 /* print */
       { &vop_islocked_desc, ufs_islocked },           /* islocked */
       { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */
       { &vop_advlock_desc, ufs_advlock },             /* advlock */
       { &vop_blkatoff_desc, ffs_blkatoff },           /* blkatoff */
       { &vop_valloc_desc, ffs_valloc },               /* valloc */
       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
       { &vop_truncate_desc, ffs_truncate },           /* truncate */
       { &vop_update_desc, ffs_update },               /* update */
       { &vop_bwrite_desc, vn_bwrite },
       { (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_vnodeop_opv_desc =
       { &ffs_vnodeop_p, ffs_vnodeop_entries };

int (**ffs_specop_p)();
struct vnodeopv_entry_desc ffs_specop_entries[] = {
       { &vop_default_desc, vn_default_error },
       { &vop_lookup_desc, spec_lookup },              /* lookup */
       { &vop_create_desc, spec_create },              /* create */
       { &vop_mknod_desc, spec_mknod },                /* mknod */
       { &vop_open_desc, spec_open },                  /* open */
       { &vop_close_desc, ufsspec_close },             /* close */
       { &vop_access_desc, ufs_access },               /* access */
       { &vop_getattr_desc, ufs_getattr },             /* getattr */
       { &vop_setattr_desc, ufs_setattr },             /* setattr */
       { &vop_read_desc, ufsspec_read },               /* read */
       { &vop_write_desc, ufsspec_write },             /* write */
       { &vop_ioctl_desc, spec_ioctl },                /* ioctl */
       { &vop_select_desc, spec_select },              /* select */
       { &vop_mmap_desc, spec_mmap },                  /* mmap */
       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
       { &vop_seek_desc, spec_seek },                  /* seek */
       { &vop_remove_desc, spec_remove },              /* remove */
       { &vop_link_desc, spec_link },                  /* link */
       { &vop_rename_desc, spec_rename },              /* rename */
       { &vop_mkdir_desc, spec_mkdir },                /* mkdir */
       { &vop_rmdir_desc, spec_rmdir },                /* rmdir */
       { &vop_symlink_desc, spec_symlink },            /* symlink */
       { &vop_readdir_desc, spec_readdir },            /* readdir */
       { &vop_readlink_desc, spec_readlink },          /* readlink */
       { &vop_abortop_desc, spec_abortop },            /* abortop */
       { &vop_inactive_desc, ufs_inactive },           /* inactive */
       { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
       { &vop_lock_desc, ufs_lock },                   /* lock */
       { &vop_unlock_desc, ufs_unlock },               /* unlock */
       { &vop_bmap_desc, spec_bmap },                  /* bmap */
       { &vop_strategy_desc, spec_strategy },          /* strategy */
       { &vop_print_desc, ufs_print },                 /* print */
       { &vop_islocked_desc, ufs_islocked },           /* islocked */
       { &vop_pathconf_desc, spec_pathconf },          /* pathconf */
       { &vop_advlock_desc, spec_advlock },            /* advlock */
       { &vop_blkatoff_desc, spec_blkatoff },          /* blkatoff */
       { &vop_valloc_desc, spec_valloc },              /* valloc */
       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
       { &vop_truncate_desc, spec_truncate },          /* truncate */
       { &vop_update_desc, ffs_update },               /* update */
       { &vop_bwrite_desc, vn_bwrite },
       { (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_specop_opv_desc =
       { &ffs_specop_p, ffs_specop_entries };

#ifdef FIFO
int (**ffs_fifoop_p)();
struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
       { &vop_default_desc, vn_default_error },
       { &vop_lookup_desc, fifo_lookup },              /* lookup */
       { &vop_create_desc, fifo_create },              /* create */
       { &vop_mknod_desc, fifo_mknod },                /* mknod */
       { &vop_open_desc, fifo_open },                  /* open */
       { &vop_close_desc, ufsfifo_close },             /* close */
       { &vop_access_desc, ufs_access },               /* access */
       { &vop_getattr_desc, ufs_getattr },             /* getattr */
       { &vop_setattr_desc, ufs_setattr },             /* setattr */
       { &vop_read_desc, ufsfifo_read },               /* read */
       { &vop_write_desc, ufsfifo_write },             /* write */
       { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
       { &vop_select_desc, fifo_select },              /* select */
       { &vop_mmap_desc, fifo_mmap },                  /* mmap */
       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
       { &vop_seek_desc, fifo_seek },                  /* seek */
       { &vop_remove_desc, fifo_remove },              /* remove */
       { &vop_link_desc, fifo_link },                  /* link */
       { &vop_rename_desc, fifo_rename },              /* rename */
       { &vop_mkdir_desc, fifo_mkdir },                /* mkdir */
       { &vop_rmdir_desc, fifo_rmdir },                /* rmdir */
       { &vop_symlink_desc, fifo_symlink },            /* symlink */
       { &vop_readdir_desc, fifo_readdir },            /* readdir */
       { &vop_readlink_desc, fifo_readlink },          /* readlink */
       { &vop_abortop_desc, fifo_abortop },            /* abortop */
       { &vop_inactive_desc, ufs_inactive },           /* inactive */
       { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
       { &vop_lock_desc, ufs_lock },                   /* lock */
       { &vop_unlock_desc, ufs_unlock },               /* unlock */
       { &vop_bmap_desc, fifo_bmap },                  /* bmap */
       { &vop_strategy_desc, fifo_strategy },          /* strategy */
       { &vop_print_desc, ufs_print },                 /* print */
       { &vop_islocked_desc, ufs_islocked },           /* islocked */
       { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
       { &vop_advlock_desc, fifo_advlock },            /* advlock */
       { &vop_blkatoff_desc, fifo_blkatoff },          /* blkatoff */
       { &vop_valloc_desc, fifo_valloc },              /* valloc */
       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
       { &vop_truncate_desc, fifo_truncate },          /* truncate */
       { &vop_update_desc, ffs_update },               /* update */
       { &vop_bwrite_desc, vn_bwrite },
       { (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_fifoop_opv_desc =
       { &ffs_fifoop_p, ffs_fifoop_entries };
#endif /* FIFO */

/*
* Enabling cluster read/write operations.
*/
#include <sys/sysctl.h>
int doclusterread = 1;
struct ctldebug debug11 = { "doclusterread", &doclusterread };
int doclusterwrite = 1;
struct ctldebug debug12 = { "doclusterwrite", &doclusterwrite };

/*
* Vnode op for reading.
*/
/* ARGSUSED */
ffs_read(ap)
       struct vop_read_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int a_ioflag;
               struct ucred *a_cred;
       } */ *ap;
{
       register struct vnode *vp = ap->a_vp;
       register struct inode *ip = VTOI(vp);
       register struct uio *uio = ap->a_uio;
       register struct fs *fs;
       struct buf *bp;
       daddr_t lbn, bn, rablock;
       off_t diff;
       int type, rasize, error = 0;
       long size, n, on;

       type = ip->i_mode & IFMT;
#ifdef DIAGNOSTIC
       if (uio->uio_rw != UIO_READ)
               panic("ffs_read mode");
       if (type != IFDIR && type != IFREG && type != IFLNK)
               panic("ffs_read type");
       if (type == IFLNK && (int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
               panic("read short symlink");
#endif
       if (uio->uio_resid == 0)
               return (0);
       fs = ip->i_fs;
       if ((u_quad_t)uio->uio_offset > fs->fs_maxfilesize)
               return (EFBIG);
       ip->i_flag |= IACC;
       do {
               lbn = lblkno(fs, uio->uio_offset);
               on = blkoff(fs, uio->uio_offset);
               n = min((unsigned)(fs->fs_bsize - on), uio->uio_resid);
               diff = ip->i_size - uio->uio_offset;
               if (diff <= 0)
                       return (0);
               if (diff < n)
                       n = diff;
               size = blksize(fs, ip, lbn);
               rablock = lbn + 1;
               if (doclusterread && lblktosize(fs, rablock) <= ip->i_size) {
                       error = cluster_read(vp, ip->i_size, lbn, size,
                           NOCRED, &bp);
               } else if (vp->v_lastr + 1 == lbn &&
                   lblktosize(fs, rablock) < ip->i_size) {
                       rasize = blksize(fs, ip, rablock);
                       error = breadn(vp, lbn, size, &rablock,
                               &rasize, 1, NOCRED, &bp);
               } else
                       error = bread(vp, lbn, size, NOCRED, &bp);
               vp->v_lastr = lbn;
               n = min(n, size - bp->b_resid);
               if (error) {
                       brelse(bp);
                       return (error);
               }
               error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
               if (type == IFREG &&
                   (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size))
                       bp->b_flags |= B_AGE;
               brelse(bp);
       } while (error == 0 && uio->uio_resid > 0 && n != 0);
       return (error);
}

/*
* Vnode op for writing.
*/
ffs_write(ap)
       struct vop_write_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int a_ioflag;
               struct ucred *a_cred;
       } */ *ap;
{
       register struct vnode *vp = ap->a_vp;
       register struct uio *uio = ap->a_uio;
       register struct inode *ip = VTOI(vp);
       register struct fs *fs;
       struct proc *p = uio->uio_procp;
       int ioflag = ap->a_ioflag;
       struct timeval tv;
       struct buf *bp;
       daddr_t lbn, bn;
       off_t osize;
       int n, on, flags;
       int size, resid, error = 0;

#ifdef DIAGNOSTIC
       if (uio->uio_rw != UIO_WRITE)
               panic("ffs_write mode");
#endif
       switch (vp->v_type) {
       case VREG:
               if (ioflag & IO_APPEND)
                       uio->uio_offset = ip->i_size;
               if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
                       return (EPERM);
               /* fall through */
       case VLNK:
               break;

       case VDIR:
               if ((ioflag & IO_SYNC) == 0)
                       panic("ffs_write nonsync dir write");
               break;

       default:
               panic("ffs_write type");
       }
       if (uio->uio_resid == 0)
               return (0);
       fs = ip->i_fs;
       if (uio->uio_offset < 0 ||
           (u_quad_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
               return (EFBIG);
       /*
        * Maybe this should be above the vnode op call, but so long as
        * file servers have no limits, i don't think it matters
        */
       if (vp->v_type == VREG && p &&
           uio->uio_offset + uio->uio_resid >
             p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
               psignal(p, SIGXFSZ);
               return (EFBIG);
       }
       resid = uio->uio_resid;
       osize = ip->i_size;
       flags = 0;
       if (ioflag & IO_SYNC)
               flags = B_SYNC;
       do {
               lbn = lblkno(fs, uio->uio_offset);
               on = blkoff(fs, uio->uio_offset);
               n = min((unsigned)(fs->fs_bsize - on), uio->uio_resid);
               if (n < fs->fs_bsize)
                       flags |= B_CLRBUF;
               else
                       flags &= ~B_CLRBUF;
               if (error = ffs_balloc(ip, lbn, on + n, ap->a_cred, &bp, flags))
                       break;
               bn = bp->b_blkno;
               if (uio->uio_offset + n > ip->i_size) {
                       ip->i_size = uio->uio_offset + n;
                       vnode_pager_setsize(vp, (u_long)ip->i_size);
               }
               size = blksize(fs, ip, lbn);
               (void) vnode_pager_uncache(vp);
               n = min(n, size - bp->b_resid);
               error = uiomove(bp->b_un.b_addr + on, n, uio);
               if (ioflag & IO_SYNC)
                       (void) bwrite(bp);
               else if (n + on == fs->fs_bsize) {
                       if (doclusterwrite) {
                               cluster_write(bp, ip->i_size);
                       } else {
                               bp->b_flags |= B_AGE;
                               bawrite(bp);
                       }
               } else
                       bdwrite(bp);
               ip->i_flag |= IUPD|ICHG;
               if (ap->a_cred && ap->a_cred->cr_uid != 0)
                       ip->i_mode &= ~(ISUID|ISGID);
       } while (error == 0 && uio->uio_resid > 0 && n != 0);
       if (error && (ioflag & IO_UNIT)) {
               (void)VOP_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred,
                   uio->uio_procp);
               uio->uio_offset -= resid - uio->uio_resid;
               uio->uio_resid = resid;
       }
       if (!error && (ioflag & IO_SYNC)) {
               tv = time;
               error = VOP_UPDATE(vp, &tv, &tv, 1);
       }
       return (error);
}

/*
* Synch an open file.
*/
/* ARGSUSED */
int
ffs_fsync(ap)
       struct vop_fsync_args /* {
               struct vnode *a_vp;
               struct ucred *a_cred;
               int a_waitfor;
               struct proc *a_p;
       } */ *ap;
{
       register struct vnode *vp = ap->a_vp;
       struct inode *ip = VTOI(vp);
       register struct buf *bp;
       struct timeval tv;
       struct buf *nbp;
       int s;

       /*
        * Flush all dirty buffers associated with a vnode.
        */
loop:
       s = splbio();
       for (bp = vp->v_dirtyblkhd.le_next; bp; bp = nbp) {
               nbp = bp->b_vnbufs.qe_next;
               if ((bp->b_flags & B_BUSY))
                       continue;
               if ((bp->b_flags & B_DELWRI) == 0)
                       panic("ffs_fsync: not dirty");
               bremfree(bp);
               bp->b_flags |= B_BUSY;
               splx(s);
               /*
                * Wait for I/O associated with indirect blocks to complete,
                * since there is no way to quickly wait for them below.
                */
               if (bp->b_vp == vp || ap->a_waitfor == MNT_NOWAIT)
                       (void) bawrite(bp);
               else
                       (void) bwrite(bp);
               goto loop;
       }
       if (ap->a_waitfor == MNT_WAIT) {
               while (vp->v_numoutput) {
                       vp->v_flag |= VBWAIT;
                       sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1);
               }
#ifdef DIAGNOSTIC
               if (vp->v_dirtyblkhd.le_next) {
                       vprint("ffs_fsync: dirty", vp);
                       goto loop;
               }
#endif
       }
       splx(s);
       tv = time;
       return (VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT));
}