635 lines
20 KiB
C
635 lines
20 KiB
C
/* $NetBSD: lfs_vnops.c,v 1.26 1999/04/12 00:36:47 perseant Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 1999 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Konrad E. Schroder <perseant@hhhh.org>.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the NetBSD
|
|
* Foundation, Inc. and its contributors.
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/*
|
|
* Copyright (c) 1986, 1989, 1991, 1993, 1995
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/namei.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 <sys/pool.h>
|
|
#include <sys/signalvar.h>
|
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <miscfs/fifofs/fifo.h>
|
|
#include <miscfs/genfs/genfs.h>
|
|
#include <miscfs/specfs/specdev.h>
|
|
|
|
#include <ufs/ufs/quota.h>
|
|
#include <ufs/ufs/inode.h>
|
|
#include <ufs/ufs/dir.h>
|
|
#include <ufs/ufs/ufsmount.h>
|
|
#include <ufs/ufs/ufs_extern.h>
|
|
|
|
#include <ufs/lfs/lfs.h>
|
|
#include <ufs/lfs/lfs_extern.h>
|
|
|
|
/* Global vfs data structures for lfs. */
|
|
int (**lfs_vnodeop_p) __P((void *));
|
|
struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
|
|
{ &vop_default_desc, vn_default_error },
|
|
{ &vop_lookup_desc, ufs_lookup }, /* lookup */
|
|
{ &vop_create_desc, lfs_create }, /* create */
|
|
{ &vop_whiteout_desc, lfs_whiteout }, /* whiteout */
|
|
{ &vop_mknod_desc, lfs_mknod }, /* mknod */
|
|
{ &vop_open_desc, ufs_open }, /* open */
|
|
{ &vop_close_desc, lfs_close }, /* close */
|
|
{ &vop_access_desc, ufs_access }, /* access */
|
|
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
|
|
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
|
|
{ &vop_read_desc, lfs_read }, /* read */
|
|
{ &vop_write_desc, lfs_write }, /* write */
|
|
{ &vop_lease_desc, ufs_lease_check }, /* lease */
|
|
{ &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
|
|
{ &vop_poll_desc, ufs_poll }, /* poll */
|
|
{ &vop_revoke_desc, ufs_revoke }, /* revoke */
|
|
{ &vop_mmap_desc, ufs_mmap }, /* mmap */
|
|
{ &vop_fsync_desc, lfs_fsync }, /* fsync */
|
|
{ &vop_seek_desc, ufs_seek }, /* seek */
|
|
{ &vop_remove_desc, lfs_remove }, /* remove */
|
|
{ &vop_link_desc, lfs_link }, /* link */
|
|
{ &vop_rename_desc, lfs_rename }, /* rename */
|
|
{ &vop_mkdir_desc, lfs_mkdir }, /* mkdir */
|
|
{ &vop_rmdir_desc, lfs_rmdir }, /* rmdir */
|
|
{ &vop_symlink_desc, lfs_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, lfs_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, lfs_blkatoff }, /* blkatoff */
|
|
{ &vop_valloc_desc, lfs_valloc }, /* valloc */
|
|
{ &vop_vfree_desc, lfs_vfree }, /* vfree */
|
|
{ &vop_truncate_desc, lfs_truncate }, /* truncate */
|
|
{ &vop_update_desc, lfs_update }, /* update */
|
|
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
|
|
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
|
|
};
|
|
struct vnodeopv_desc lfs_vnodeop_opv_desc =
|
|
{ &lfs_vnodeop_p, lfs_vnodeop_entries };
|
|
|
|
int (**lfs_specop_p) __P((void *));
|
|
struct vnodeopv_entry_desc lfs_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, lfs_getattr }, /* getattr */
|
|
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
|
|
{ &vop_read_desc, ufsspec_read }, /* read */
|
|
{ &vop_write_desc, ufsspec_write }, /* write */
|
|
{ &vop_lease_desc, spec_lease_check }, /* lease */
|
|
{ &vop_ioctl_desc, spec_ioctl }, /* ioctl */
|
|
{ &vop_poll_desc, spec_poll }, /* poll */
|
|
{ &vop_revoke_desc, spec_revoke }, /* revoke */
|
|
{ &vop_mmap_desc, spec_mmap }, /* mmap */
|
|
{ &vop_fsync_desc, spec_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, lfs_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, lfs_vfree }, /* vfree */
|
|
{ &vop_truncate_desc, spec_truncate }, /* truncate */
|
|
{ &vop_update_desc, lfs_update }, /* update */
|
|
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
|
|
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
|
|
};
|
|
struct vnodeopv_desc lfs_specop_opv_desc =
|
|
{ &lfs_specop_p, lfs_specop_entries };
|
|
|
|
int (**lfs_fifoop_p) __P((void *));
|
|
struct vnodeopv_entry_desc lfs_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, lfs_getattr }, /* getattr */
|
|
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
|
|
{ &vop_read_desc, ufsfifo_read }, /* read */
|
|
{ &vop_write_desc, ufsfifo_write }, /* write */
|
|
{ &vop_lease_desc, fifo_lease_check }, /* lease */
|
|
{ &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
|
|
{ &vop_poll_desc, fifo_poll }, /* poll */
|
|
{ &vop_revoke_desc, fifo_revoke }, /* revoke */
|
|
{ &vop_mmap_desc, fifo_mmap }, /* mmap */
|
|
{ &vop_fsync_desc, fifo_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, lfs_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, lfs_vfree }, /* vfree */
|
|
{ &vop_truncate_desc, fifo_truncate }, /* truncate */
|
|
{ &vop_update_desc, lfs_update }, /* update */
|
|
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
|
|
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
|
|
};
|
|
struct vnodeopv_desc lfs_fifoop_opv_desc =
|
|
{ &lfs_fifoop_p, lfs_fifoop_entries };
|
|
|
|
#define LFS_READWRITE
|
|
#include <ufs/ufs/ufs_readwrite.c>
|
|
#undef LFS_READWRITE
|
|
|
|
/*
|
|
* Synch an open file.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
lfs_fsync(v)
|
|
void *v;
|
|
{
|
|
struct vop_fsync_args /* {
|
|
struct vnode *a_vp;
|
|
struct ucred *a_cred;
|
|
int a_flags;
|
|
struct proc *a_p;
|
|
} */ *ap = v;
|
|
|
|
return (VOP_UPDATE(ap->a_vp, NULL, NULL,
|
|
(ap->a_flags & FSYNC_WAIT) != 0 ? LFS_SYNC : 0)); /* XXX */
|
|
}
|
|
|
|
/*
|
|
* These macros are used to bracket UFS directory ops, so that we can
|
|
* identify all the pages touched during directory ops which need to
|
|
* be ordered and flushed atomically, so that they may be recovered.
|
|
*/
|
|
/*
|
|
* XXX KS - Because we have to mark nodes VDIROP in order to prevent
|
|
* the cache from reclaiming them while a dirop is in progress, we must
|
|
* also manage the number of nodes so marked (otherwise we can run out).
|
|
* We do this by setting lfs_dirvcount to the number of marked vnodes; it
|
|
* is decremented during segment write, when VDIROP is taken off.
|
|
*/
|
|
#define SET_DIROP(fs) lfs_set_dirop(fs)
|
|
static int lfs_set_dirop __P((struct lfs *));
|
|
|
|
static int lfs_set_dirop(fs)
|
|
struct lfs *fs;
|
|
{
|
|
int error;
|
|
|
|
while (fs->lfs_writer || fs->lfs_dirvcount>LFS_MAXDIROP) {
|
|
if(fs->lfs_writer)
|
|
tsleep(&fs->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);
|
|
if(fs->lfs_dirvcount > LFS_MAXDIROP) {
|
|
#ifdef DEBUG_LFS
|
|
printf("(dirvcount=%d)\n",fs->lfs_dirvcount);
|
|
#endif
|
|
if((error=tsleep(&fs->lfs_dirvcount, PCATCH|PUSER, "lfs_maxdirop", 0))!=0)
|
|
return error;
|
|
}
|
|
}
|
|
++fs->lfs_dirops;
|
|
fs->lfs_doifile = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define SET_ENDOP(fs,vp,str) { \
|
|
--(fs)->lfs_dirops; \
|
|
if (!(fs)->lfs_dirops) { \
|
|
wakeup(&(fs)->lfs_writer); \
|
|
lfs_check((vp),LFS_UNUSED_LBN,0); \
|
|
} \
|
|
}
|
|
|
|
#define MARK_VNODE(dvp) do { \
|
|
if(!((dvp)->v_flag & VDIROP)) { \
|
|
lfs_vref(dvp); \
|
|
++VTOI((dvp))->i_lfs->lfs_dirvcount; \
|
|
} \
|
|
(dvp)->v_flag |= VDIROP; \
|
|
} while(0)
|
|
|
|
#define MAYBE_INACTIVE(fs,vp) do { \
|
|
if((vp) && ((vp)->v_flag & VDIROP) && (vp)->v_usecount == 1 \
|
|
&& VTOI(vp) && VTOI(vp)->i_ffs_nlink == 0) \
|
|
{ \
|
|
if (VOP_LOCK((vp), LK_EXCLUSIVE) == 0) { \
|
|
VOP_INACTIVE((vp),curproc); \
|
|
} \
|
|
} \
|
|
} while(0)
|
|
|
|
int
|
|
lfs_symlink(v)
|
|
void *v;
|
|
{
|
|
struct vop_symlink_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode **a_vpp;
|
|
struct componentname *a_cnp;
|
|
struct vattr *a_vap;
|
|
char *a_target;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_symlink(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"symilnk");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_mknod(v)
|
|
void *v;
|
|
{
|
|
struct vop_mknod_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode **a_vpp;
|
|
struct componentname *a_cnp;
|
|
struct vattr *a_vap;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_mknod(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"mknod");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_create(v)
|
|
void *v;
|
|
{
|
|
struct vop_create_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode **a_vpp;
|
|
struct componentname *a_cnp;
|
|
struct vattr *a_vap;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_create(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"create");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_whiteout(v)
|
|
void *v;
|
|
{
|
|
struct vop_whiteout_args /* {
|
|
struct vnode *a_dvp;
|
|
struct componentname *a_cnp;
|
|
int a_flags;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_whiteout(ap);
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"whiteout");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_mkdir(v)
|
|
void *v;
|
|
{
|
|
struct vop_mkdir_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode **a_vpp;
|
|
struct componentname *a_cnp;
|
|
struct vattr *a_vap;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_mkdir(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"mkdir");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_remove(v)
|
|
void *v;
|
|
{
|
|
struct vop_remove_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode *a_vp;
|
|
struct componentname *a_cnp;
|
|
} */ *ap = v;
|
|
int ret;
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
MARK_VNODE(ap->a_vp);
|
|
ret = ufs_remove(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_vp);
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"remove");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_rmdir(v)
|
|
void *v;
|
|
{
|
|
struct vop_rmdir_args /* {
|
|
struct vnodeop_desc *a_desc;
|
|
struct vnode *a_dvp;
|
|
struct vnode *a_vp;
|
|
struct componentname *a_cnp;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
MARK_VNODE(ap->a_vp);
|
|
ret = ufs_rmdir(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_vp);
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"rmdir");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_link(v)
|
|
void *v;
|
|
{
|
|
struct vop_link_args /* {
|
|
struct vnode *a_dvp;
|
|
struct vnode *a_vp;
|
|
struct componentname *a_cnp;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_dvp);
|
|
ret = ufs_link(ap);
|
|
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,ap->a_dvp,"link");
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
lfs_rename(v)
|
|
void *v;
|
|
{
|
|
struct vop_rename_args /* {
|
|
struct vnode *a_fdvp;
|
|
struct vnode *a_fvp;
|
|
struct componentname *a_fcnp;
|
|
struct vnode *a_tdvp;
|
|
struct vnode *a_tvp;
|
|
struct componentname *a_tcnp;
|
|
} */ *ap = v;
|
|
int ret;
|
|
|
|
if((ret=SET_DIROP(VTOI(ap->a_fdvp)->i_lfs))!=0)
|
|
return ret;
|
|
MARK_VNODE(ap->a_fdvp);
|
|
MARK_VNODE(ap->a_tdvp);
|
|
ret = ufs_rename(ap);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_fvp);
|
|
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_tvp);
|
|
SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs,ap->a_fdvp,"rename");
|
|
return (ret);
|
|
}
|
|
|
|
/* XXX hack to avoid calling ITIMES in getattr */
|
|
int
|
|
lfs_getattr(v)
|
|
void *v;
|
|
{
|
|
struct vop_getattr_args /* {
|
|
struct vnode *a_vp;
|
|
struct vattr *a_vap;
|
|
struct ucred *a_cred;
|
|
struct proc *a_p;
|
|
} */ *ap = v;
|
|
register struct vnode *vp = ap->a_vp;
|
|
register struct inode *ip = VTOI(vp);
|
|
register struct vattr *vap = ap->a_vap;
|
|
/*
|
|
* Copy from inode table
|
|
*/
|
|
vap->va_fsid = ip->i_dev;
|
|
vap->va_fileid = ip->i_number;
|
|
vap->va_mode = ip->i_ffs_mode & ~IFMT;
|
|
vap->va_nlink = ip->i_ffs_nlink;
|
|
vap->va_uid = ip->i_ffs_uid;
|
|
vap->va_gid = ip->i_ffs_gid;
|
|
vap->va_rdev = (dev_t)ip->i_ffs_rdev;
|
|
vap->va_size = ip->i_ffs_size;
|
|
vap->va_atime.tv_sec = ip->i_ffs_atime;
|
|
vap->va_atime.tv_nsec = ip->i_ffs_atimensec;
|
|
vap->va_mtime.tv_sec = ip->i_ffs_mtime;
|
|
vap->va_mtime.tv_nsec = ip->i_ffs_mtimensec;
|
|
vap->va_ctime.tv_sec = ip->i_ffs_ctime;
|
|
vap->va_ctime.tv_nsec = ip->i_ffs_ctimensec;
|
|
vap->va_flags = ip->i_ffs_flags;
|
|
vap->va_gen = ip->i_ffs_gen;
|
|
/* this doesn't belong here */
|
|
if (vp->v_type == VBLK)
|
|
vap->va_blocksize = BLKDEV_IOSIZE;
|
|
else if (vp->v_type == VCHR)
|
|
vap->va_blocksize = MAXBSIZE;
|
|
else
|
|
vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
|
|
vap->va_bytes = dbtob((u_quad_t)ip->i_ffs_blocks);
|
|
vap->va_type = vp->v_type;
|
|
vap->va_filerev = ip->i_modrev;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Close called
|
|
*
|
|
* XXX -- we were using ufs_close, but since it updates the
|
|
* times on the inode, we might need to bump the uinodes
|
|
* count.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
lfs_close(v)
|
|
void *v;
|
|
{
|
|
struct vop_close_args /* {
|
|
struct vnode *a_vp;
|
|
int a_fflag;
|
|
struct ucred *a_cred;
|
|
struct proc *a_p;
|
|
} */ *ap = v;
|
|
register struct vnode *vp = ap->a_vp;
|
|
register struct inode *ip = VTOI(vp);
|
|
int mod;
|
|
struct timespec ts;
|
|
|
|
simple_lock(&vp->v_interlock);
|
|
if (vp->v_usecount > 1) {
|
|
mod = ip->i_flag & IN_MODIFIED;
|
|
TIMEVAL_TO_TIMESPEC(&time, &ts);
|
|
LFS_ITIMES(ip, &ts, &ts, &ts);
|
|
if (!mod && ip->i_flag & IN_MODIFIED)
|
|
ip->i_lfs->lfs_uinodes++;
|
|
}
|
|
simple_unlock(&vp->v_interlock);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Reclaim an inode so that it can be used for other purposes.
|
|
*/
|
|
int lfs_no_inactive = 0;
|
|
|
|
int
|
|
lfs_reclaim(v)
|
|
void *v;
|
|
{
|
|
struct vop_reclaim_args /* {
|
|
struct vnode *a_vp;
|
|
struct proc *a_p;
|
|
} */ *ap = v;
|
|
struct vnode *vp = ap->a_vp;
|
|
int error;
|
|
|
|
if ((error = ufs_reclaim(vp, ap->a_p)))
|
|
return (error);
|
|
pool_put(&lfs_inode_pool, vp->v_data);
|
|
vp->v_data = NULL;
|
|
return (0);
|
|
}
|