#include <sys/malloc.h>
#include <sys/namei.h>
#include <sys/unistd.h>
+#if __FreeBSD_version >= 1000030
+#include <sys/rwlock.h>
+#endif
#include <vm/vm_page.h>
#include <vm/vm_object.h>
#include <vm/vm_pager.h>
#include <vm/vnode_pager.h>
extern int afs_pbuf_freecnt;
-#ifdef AFS_FBSD60_ENV
-static vop_access_t afs_vop_access;
-static vop_advlock_t afs_vop_advlock;
-static vop_close_t afs_vop_close;
-static vop_create_t afs_vop_create;
-static vop_fsync_t afs_vop_fsync;
-static vop_getattr_t afs_vop_getattr;
-static vop_getpages_t afs_vop_getpages;
-static vop_inactive_t afs_vop_inactive;
-static vop_ioctl_t afs_vop_ioctl;
-static vop_link_t afs_vop_link;
-static vop_lookup_t afs_vop_lookup;
-static vop_mkdir_t afs_vop_mkdir;
-static vop_mknod_t afs_vop_mknod;
-static vop_open_t afs_vop_open;
-static vop_pathconf_t afs_vop_pathconf;
-static vop_poll_t afs_vop_poll;
-static vop_print_t afs_vop_print;
-static vop_putpages_t afs_vop_putpages;
-static vop_read_t afs_vop_read;
-static vop_readdir_t afs_vop_readdir;
-static vop_readlink_t afs_vop_readlink;
-static vop_reclaim_t afs_vop_reclaim;
-static vop_remove_t afs_vop_remove;
-static vop_rename_t afs_vop_rename;
-static vop_rmdir_t afs_vop_rmdir;
-static vop_setattr_t afs_vop_setattr;
-static vop_strategy_t afs_vop_strategy;
-static vop_symlink_t afs_vop_symlink;
-static vop_write_t afs_vop_write;
-#if defined(AFS_FBSD70_ENV) && !defined(AFS_FBSD80_ENV)
-static vop_lock1_t afs_vop_lock;
-static vop_unlock_t afs_vop_unlock;
-static vop_islocked_t afs_vop_islocked;
-#endif
-
-struct vop_vector afs_vnodeops = {
- .vop_default = &default_vnodeops,
- .vop_access = afs_vop_access,
- .vop_advlock = afs_vop_advlock,
- .vop_close = afs_vop_close,
- .vop_create = afs_vop_create,
- .vop_fsync = afs_vop_fsync,
- .vop_getattr = afs_vop_getattr,
- .vop_getpages = afs_vop_getpages,
- .vop_inactive = afs_vop_inactive,
- .vop_ioctl = afs_vop_ioctl,
-#if !defined(AFS_FBSD80_ENV)
- /* removed at least temporarily (NFSv4 flux) */
- .vop_lease = VOP_NULL,
-#endif
- .vop_link = afs_vop_link,
- .vop_lookup = afs_vop_lookup,
- .vop_mkdir = afs_vop_mkdir,
- .vop_mknod = afs_vop_mknod,
- .vop_open = afs_vop_open,
- .vop_pathconf = afs_vop_pathconf,
- .vop_poll = afs_vop_poll,
- .vop_print = afs_vop_print,
- .vop_putpages = afs_vop_putpages,
- .vop_read = afs_vop_read,
- .vop_readdir = afs_vop_readdir,
- .vop_readlink = afs_vop_readlink,
- .vop_reclaim = afs_vop_reclaim,
- .vop_remove = afs_vop_remove,
- .vop_rename = afs_vop_rename,
- .vop_rmdir = afs_vop_rmdir,
- .vop_setattr = afs_vop_setattr,
- .vop_strategy = afs_vop_strategy,
- .vop_symlink = afs_vop_symlink,
- .vop_write = afs_vop_write,
-#if defined(AFS_FBSD70_ENV) && !defined(AFS_FBSD80_ENV)
- .vop_lock1 = afs_vop_lock,
- .vop_unlock = afs_vop_unlock,
- .vop_islocked = afs_vop_islocked,
-#endif
-};
-
-#else /* AFS_FBSD60_ENV */
-
-int afs_vop_lookup(struct vop_lookup_args *);
-int afs_vop_create(struct vop_create_args *);
-int afs_vop_mknod(struct vop_mknod_args *);
-int afs_vop_open(struct vop_open_args *);
-int afs_vop_close(struct vop_close_args *);
-int afs_vop_access(struct vop_access_args *);
-int afs_vop_getattr(struct vop_getattr_args *);
-int afs_vop_setattr(struct vop_setattr_args *);
-int afs_vop_read(struct vop_read_args *);
-int afs_vop_write(struct vop_write_args *);
-int afs_vop_getpages(struct vop_getpages_args *);
-int afs_vop_putpages(struct vop_putpages_args *);
-int afs_vop_ioctl(struct vop_ioctl_args *);
-static int afs_vop_pathconf(struct vop_pathconf_args *);
-int afs_vop_poll(struct vop_poll_args *);
-int afs_vop_fsync(struct vop_fsync_args *);
-int afs_vop_remove(struct vop_remove_args *);
-int afs_vop_link(struct vop_link_args *);
-int afs_vop_rename(struct vop_rename_args *);
-int afs_vop_mkdir(struct vop_mkdir_args *);
-int afs_vop_rmdir(struct vop_rmdir_args *);
-int afs_vop_symlink(struct vop_symlink_args *);
-int afs_vop_readdir(struct vop_readdir_args *);
-int afs_vop_readlink(struct vop_readlink_args *);
-int afs_vop_inactive(struct vop_inactive_args *);
-int afs_vop_reclaim(struct vop_reclaim_args *);
-int afs_vop_bmap(struct vop_bmap_args *);
-int afs_vop_strategy(struct vop_strategy_args *);
-int afs_vop_print(struct vop_print_args *);
-int afs_vop_advlock(struct vop_advlock_args *);
-
-
-
-/* Global vfs data structures for AFS. */
-vop_t **afs_vnodeop_p;
-struct vnodeopv_entry_desc afs_vnodeop_entries[] = {
- {&vop_default_desc, (vop_t *) vop_defaultop},
- {&vop_access_desc, (vop_t *) afs_vop_access}, /* access */
- {&vop_advlock_desc, (vop_t *) afs_vop_advlock}, /* advlock */
- {&vop_bmap_desc, (vop_t *) afs_vop_bmap}, /* bmap */
- {&vop_close_desc, (vop_t *) afs_vop_close}, /* close */
- {&vop_createvobject_desc, (vop_t *) vop_stdcreatevobject},
- {&vop_destroyvobject_desc, (vop_t *) vop_stddestroyvobject},
- {&vop_create_desc, (vop_t *) afs_vop_create}, /* create */
- {&vop_fsync_desc, (vop_t *) afs_vop_fsync}, /* fsync */
- {&vop_getattr_desc, (vop_t *) afs_vop_getattr}, /* getattr */
- {&vop_getpages_desc, (vop_t *) afs_vop_getpages}, /* read */
- {&vop_getvobject_desc, (vop_t *) vop_stdgetvobject},
- {&vop_putpages_desc, (vop_t *) afs_vop_putpages}, /* write */
- {&vop_inactive_desc, (vop_t *) afs_vop_inactive}, /* inactive */
- {&vop_lease_desc, (vop_t *) vop_null},
- {&vop_link_desc, (vop_t *) afs_vop_link}, /* link */
- {&vop_lookup_desc, (vop_t *) afs_vop_lookup}, /* lookup */
- {&vop_mkdir_desc, (vop_t *) afs_vop_mkdir}, /* mkdir */
- {&vop_mknod_desc, (vop_t *) afs_vop_mknod}, /* mknod */
- {&vop_open_desc, (vop_t *) afs_vop_open}, /* open */
- {&vop_pathconf_desc, (vop_t *) afs_vop_pathconf}, /* pathconf */
- {&vop_poll_desc, (vop_t *) afs_vop_poll}, /* select */
- {&vop_print_desc, (vop_t *) afs_vop_print}, /* print */
- {&vop_read_desc, (vop_t *) afs_vop_read}, /* read */
- {&vop_readdir_desc, (vop_t *) afs_vop_readdir}, /* readdir */
- {&vop_readlink_desc, (vop_t *) afs_vop_readlink}, /* readlink */
- {&vop_reclaim_desc, (vop_t *) afs_vop_reclaim}, /* reclaim */
- {&vop_remove_desc, (vop_t *) afs_vop_remove}, /* remove */
- {&vop_rename_desc, (vop_t *) afs_vop_rename}, /* rename */
- {&vop_rmdir_desc, (vop_t *) afs_vop_rmdir}, /* rmdir */
- {&vop_setattr_desc, (vop_t *) afs_vop_setattr}, /* setattr */
- {&vop_strategy_desc, (vop_t *) afs_vop_strategy}, /* strategy */
- {&vop_symlink_desc, (vop_t *) afs_vop_symlink}, /* symlink */
- {&vop_write_desc, (vop_t *) afs_vop_write}, /* write */
- {&vop_ioctl_desc, (vop_t *) afs_vop_ioctl}, /* XXX ioctl */
- /*{ &vop_seek_desc, afs_vop_seek }, *//* seek */
-#if defined(AFS_FBSD70_ENV) && !defined(AFS_FBSD90_ENV)
- {&vop_lock1_desc, (vop_t *) afs_vop_lock}, /* lock */
- {&vop_unlock_desc, (vop_t *) afs_vop_unlock}, /* unlock */
- {&vop_islocked_desc, (vop_t *) afs_vop_islocked}, /* islocked */
-#endif
- {NULL, NULL}
-};
-struct vnodeopv_desc afs_vnodeop_opv_desc =
- { &afs_vnodeop_p, afs_vnodeop_entries };
-#endif /* AFS_FBSD60_ENV */
-
#define GETNAME() \
struct componentname *cnp = ap->a_cnp; \
char *name; \
* Here we define compatibility functions/macros for interfaces that
* have changed between different FreeBSD versions.
*/
-#if defined(AFS_FBSD90_ENV)
static __inline void ma_vm_page_lock_queues(void) {};
static __inline void ma_vm_page_unlock_queues(void) {};
static __inline void ma_vm_page_lock(vm_page_t m) { vm_page_lock(m); };
static __inline void ma_vm_page_unlock(vm_page_t m) { vm_page_unlock(m); };
-#else
-static __inline void ma_vm_page_lock_queues(void) { vm_page_lock_queues(); };
-static __inline void ma_vm_page_unlock_queues(void) { vm_page_unlock_queues(); };
-static __inline void ma_vm_page_lock(vm_page_t m) {};
-static __inline void ma_vm_page_unlock(vm_page_t m) {};
-#endif
-#if defined(AFS_FBSD80_ENV)
#define ma_vn_lock(vp, flags, p) (vn_lock(vp, flags))
#define MA_VOP_LOCK(vp, flags, p) (VOP_LOCK(vp, flags))
#define MA_VOP_UNLOCK(vp, flags, p) (VOP_UNLOCK(vp, flags))
-#else
-#define ma_vn_lock(vp, flags, p) (vn_lock(vp, flags, p))
-#define MA_VOP_LOCK(vp, flags, p) (VOP_LOCK(vp, flags, p))
-#define MA_VOP_UNLOCK(vp, flags, p) (VOP_UNLOCK(vp, flags, p))
-#endif
-#if defined(AFS_FBSD70_ENV)
#define MA_PCPU_INC(c) PCPU_INC(c)
#define MA_PCPU_ADD(c, n) PCPU_ADD(c, n)
-#else
-#define MA_PCPU_INC(c) PCPU_LAZY_INC(c)
-#define MA_PCPU_ADD(c, n) (c) += (n)
-#endif
-
-#ifdef AFS_FBSD70_ENV
-#ifndef AFS_FBSD80_ENV
-/* From kern_lock.c */
-#define COUNT(td, x) if ((td)) (td)->td_locks += (x)
-#define LK_ALL (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE | \
- LK_SHARE_NONZERO | LK_WAIT_NONZERO)
-
-static __inline void
-sharelock(struct thread *td, struct lock *lkp, int incr) {
- lkp->lk_flags |= LK_SHARE_NONZERO;
- lkp->lk_sharecount += incr;
- COUNT(td, incr);
-}
-#endif
-
-/*
- * Standard lock, unlock and islocked functions.
- */
-int
-afs_vop_lock(ap)
- struct vop_lock1_args /* {
- struct vnode *a_vp;
- int a_flags;
- struct thread *a_td;
- char *file;
- int line;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct lock *lkp = vp->v_vnlock;
-
-#if 0 && defined(AFS_FBSD80_ENV) && !defined(UKERNEL)
- afs_warn("afs_vop_lock: tid %d pid %d \"%s\"\n", curthread->td_tid,
- curthread->td_proc->p_pid, curthread->td_name);
- kdb_backtrace();
-#endif
-
-#ifdef AFS_FBSD80_ENV
- return (_lockmgr_args(lkp, ap->a_flags, VI_MTX(vp),
- LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT,
- ap->a_file, ap->a_line));
-#else
- return (_lockmgr(lkp, ap->a_flags, VI_MTX(vp), ap->a_td, ap->a_file, ap->a_line));
-#endif
-}
-/* See above. */
-int
-afs_vop_unlock(ap)
- struct vop_unlock_args /* {
- struct vnode *a_vp;
- int a_flags;
- struct thread *a_td;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct lock *lkp = vp->v_vnlock;
-
-#ifdef AFS_FBSD80_ENV
- int code = 0;
- u_int op;
- op = ((ap->a_flags) | LK_RELEASE) & LK_TYPE_MASK;
- int glocked = ISAFS_GLOCK();
- if (glocked)
- AFS_GUNLOCK();
- if ((op & (op - 1)) != 0) {
- afs_warn("afs_vop_unlock: Shit.\n");
- goto done;
- }
- code = lockmgr(lkp, ap->a_flags | LK_RELEASE, VI_MTX(vp));
- done:
- if (glocked)
- AFS_GLOCK();
- return(code);
+#if __FreeBSD_version >= 1000030
+#define AFS_VM_OBJECT_WLOCK(o) VM_OBJECT_WLOCK(o)
+#define AFS_VM_OBJECT_WUNLOCK(o) VM_OBJECT_WUNLOCK(o)
#else
- /* possibly in current code path where this
- * forces trace, we should have had a (shared? not
- * necessarily, see _lockmgr in kern_lock.c) lock
- * and that's the real bug. but.
- */
- critical_enter();
- if ((lkp->lk_exclusivecount == 0) &&
- (!(lkp->lk_flags & LK_SHARE_NONZERO))) {
- sharelock(ap->a_td, lkp, 1);
- }
- critical_exit();
- return (lockmgr(lkp, ap->a_flags | LK_RELEASE, VI_MTX(vp),
- ap->a_td));
+#define AFS_VM_OBJECT_WLOCK(o) VM_OBJECT_LOCK(o)
+#define AFS_VM_OBJECT_WUNLOCK(o) VM_OBJECT_UNLOCK(o)
#endif
-}
-
-/* See above. */
-int
-afs_vop_islocked(ap)
- struct vop_islocked_args /* {
- struct vnode *a_vp;
- struct thread *a_td; (not in 80)
- } */ *ap;
-{
-#ifdef AFS_FBSD80_ENV
- return (lockstatus(ap->a_vp->v_vnlock));
-#else
- return (lockstatus(ap->a_vp->v_vnlock, ap->a_td));
-#endif
-}
-#endif /* 70 */
/*
* Mosty copied from sys/ufs/ufs/ufs_vnops.c:ufs_pathconf().
return (error);
}
-int
+static int
afs_vop_lookup(ap)
struct vop_lookup_args /* {
* struct vnodeop_desc * a_desc;
struct vcache *vcp;
struct vnode *vp, *dvp;
int flags = ap->a_cnp->cn_flags;
- int lockparent; /* 1 => lockparent flag is set */
- int wantparent; /* 1 => wantparent or lockparent flag */
-#ifndef AFS_FBSD80_ENV
- struct thread *p = ap->a_cnp->cn_thread;
-#endif
dvp = ap->a_dvp;
if (dvp->v_type != VDIR) {
-#ifndef AFS_FBSD70_ENV
- *ap->a_vpp = 0;
-#endif
return ENOTDIR;
}
GETNAME();
- lockparent = flags & LOCKPARENT;
- wantparent = flags & (LOCKPARENT | WANTPARENT);
-
-#ifdef AFS_FBSD80_ENV
+#if __FreeBSD_version < 1000021
cnp->cn_flags |= MPSAFE; /* steel */
#endif
-#ifndef AFS_FBSD70_ENV
+ /*
+ * Locking rules:
+ *
+ * - 'dvp' is locked by our caller. We must return it locked, whether we
+ * return success or error.
+ *
+ * - If the lookup succeeds, 'vp' must be locked before we return.
+ *
+ * - If we lock multiple vnodes, parent vnodes must be locked before
+ * children vnodes.
+ *
+ * As a result, looking up the parent directory (if 'flags' has ISDOTDOT
+ * set) is a bit of a special case. In that case, we must unlock 'dvp'
+ * before performing the lookup, since the lookup operation may lock the
+ * target vnode, and the target vnode is the parent of 'dvp' (so we must
+ * lock 'dvp' after locking the target vnode).
+ */
+
if (flags & ISDOTDOT)
- VOP_UNLOCK(dvp, 0, p);
-#endif
+ MA_VOP_UNLOCK(dvp, 0, p);
AFS_GLOCK();
error = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
}
vp = AFSTOV(vcp); /* always get a node if no error */
- /* The parent directory comes in locked. We unlock it on return
- * unless the caller wants it left locked.
- * we also always return the vnode locked. */
-
if (flags & ISDOTDOT) {
- MA_VOP_UNLOCK(dvp, 0, p);
+ /* Must lock 'vp' before 'dvp', since 'vp' is the parent vnode. */
ma_vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
ma_vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
- /* always return the child locked */
- if (lockparent && (flags & ISLASTCN)
- && (error = ma_vn_lock(dvp, LK_EXCLUSIVE, p))) {
- vput(vp);
- DROPNAME();
- return (error);
- }
} else if (vp == dvp) {
/* they're the same; afs_lookup() already ref'ed the leaf.
* It came in locked, so we don't need to ref OR lock it */
} else {
- if (!lockparent || !(flags & ISLASTCN)) {
-#ifndef AFS_FBSD70_ENV /* 6 too? */
- MA_VOP_UNLOCK(dvp, 0, p); /* done with parent. */
-#endif
- }
ma_vn_lock(vp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, p);
- /* always return the child locked */
}
*ap->a_vpp = vp;
- if ((cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN))
- || (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN)))
+ if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
cnp->cn_flags |= SAVENAME;
DROPNAME();
return error;
}
-int
+static int
afs_vop_create(ap)
struct vop_create_args /* {
* struct vnode *a_dvp;
int error = 0;
struct vcache *vcp;
struct vnode *dvp = ap->a_dvp;
-#ifndef AFS_FBSD80_ENV
- struct thread *p = ap->a_cnp->cn_thread;
-#endif
GETNAME();
AFS_GLOCK();
return error;
}
-int
+static int
afs_vop_mknod(ap)
struct vop_mknod_args /* {
* struct vnode *a_dvp;
return (ENODEV);
}
-#if 0
static int
-validate_vops(struct vnode *vp, int after)
-{
- int ret = 0;
- struct vnodeopv_entry_desc *this;
- for (this = afs_vnodeop_entries; this->opve_op; this++) {
- if (vp->v_op[this->opve_op->vdesc_offset] != this->opve_impl) {
- if (!ret) {
- printf("v_op %d ", after);
- vprint("check", vp);
- }
- ret = 1;
- printf("For oper %d (%s), func is %p, not %p",
- this->opve_op->vdesc_offset, this->opve_op->vdesc_name,
- vp->v_op[this->opve_op->vdesc_offset], this->opve_impl);
- }
- }
- return ret;
-}
-#endif
-int
afs_vop_open(ap)
struct vop_open_args /* {
* struct vnode *a_vp;
panic("AFS open changed vnode!");
#endif
AFS_GUNLOCK();
-#ifdef AFS_FBSD60_ENV
vnode_create_vobject(ap->a_vp, vc->f.m.Length, ap->a_td);
-#endif
osi_FlushPages(vc, ap->a_cred);
return error;
}
-int
+static int
afs_vop_close(ap)
struct vop_close_args /* {
* struct vnode *a_vp;
struct vnode *vp = ap->a_vp;
struct vcache *avc = VTOAFS(vp);
-#if defined(AFS_FBSD80_ENV)
VI_LOCK(vp);
iflag = vp->v_iflag & VI_DOOMED;
VI_UNLOCK(vp);
vp, avc, avc->opens);
return 0;
}
-#endif
AFS_GLOCK();
if (ap->a_cred)
code = afs_close(avc, ap->a_fflag, ap->a_cred);
else
code = afs_close(avc, ap->a_fflag, afs_osi_credp);
- osi_FlushPages(avc, ap->a_cred); /* hold bozon lock, but not basic vnode lock */
+ osi_FlushPages(avc, ap->a_cred); /* hold GLOCK, but not basic vnode lock */
AFS_GUNLOCK();
return code;
}
-int
+static int
afs_vop_access(ap)
struct vop_access_args /* {
* struct vnode *a_vp;
{
int code;
AFS_GLOCK();
-#if defined(AFS_FBSD80_ENV)
code = afs_access(VTOAFS(ap->a_vp), ap->a_accmode, ap->a_cred);
-#else
- code = afs_access(VTOAFS(ap->a_vp), ap->a_mode, ap->a_cred);
-#endif
AFS_GUNLOCK();
return code;
}
-int
+static int
afs_vop_getattr(ap)
struct vop_getattr_args /* {
* struct vnode *a_vp;
return code;
}
-int
+static int
afs_vop_setattr(ap)
struct vop_setattr_args /* {
* struct vnode *a_vp;
return code;
}
-int
+static int
afs_vop_read(ap)
struct vop_read_args /* {
* struct vnode *a_vp;
int code;
struct vcache *avc = VTOAFS(ap->a_vp);
AFS_GLOCK();
- osi_FlushPages(avc, ap->a_cred); /* hold bozon lock, but not basic vnode lock */
- code = afs_read(avc, ap->a_uio, ap->a_cred, 0, 0, 0);
+ osi_FlushPages(avc, ap->a_cred); /* hold GLOCK, but not basic vnode lock */
+ code = afs_read(avc, ap->a_uio, ap->a_cred, 0);
AFS_GUNLOCK();
return code;
}
* struct vnode *a_vp;
* vm_page_t *a_m;
* int a_count;
- * int a_reqpage;
- * vm_oofset_t a_offset;
+ * int *a_rbehind;
+ * int *a_rahead;
* };
*/
-int
+static int
afs_vop_getpages(struct vop_getpages_args *ap)
{
int code;
- int i, nextoff, size, toff, npages;
+ int i, nextoff, size, toff, npages, count;
struct uio uio;
struct iovec iov;
struct buf *bp;
vm_offset_t kva;
vm_object_t object;
+ vm_page_t *pages;
struct vnode *vp;
struct vcache *avc;
+ memset(&uio, 0, sizeof(uio));
+ memset(&iov, 0, sizeof(iov));
+
vp = ap->a_vp;
avc = VTOAFS(vp);
+ pages = ap->a_m;
+#ifdef FBSD_VOP_GETPAGES_BUSIED
+ npages = ap->a_count;
+ if (ap->a_rbehind)
+ *ap->a_rbehind = 0;
+ if (ap->a_rahead)
+ *ap->a_rahead = 0;
+#else
+ npages = btoc(ap->a_count);
+#endif
+
if ((object = vp->v_object) == NULL) {
printf("afs_getpages: called with non-merged cache vnode??\n");
return VM_PAGER_ERROR;
}
- npages = btoc(ap->a_count);
+
/*
* If the requested page is partially valid, just return it and
* allow the pager to zero-out the blanks. Partially valid pages
* can only occur at the file EOF.
*/
-
{
- vm_page_t m = ap->a_m[ap->a_reqpage];
-
- VM_OBJECT_LOCK(object);
+#ifdef FBSD_VOP_GETPAGES_BUSIED
+ AFS_VM_OBJECT_WLOCK(object);
+ ma_vm_page_lock_queues();
+ if(pages[npages - 1]->valid != 0) {
+ if (--npages == 0) {
+ ma_vm_page_unlock_queues();
+ AFS_VM_OBJECT_WUNLOCK(object);
+ return (VM_PAGER_OK);
+ }
+ }
+#else
+ vm_page_t m = pages[ap->a_reqpage];
+ AFS_VM_OBJECT_WLOCK(object);
ma_vm_page_lock_queues();
if (m->valid != 0) {
/* handled by vm_fault now */
/* vm_page_zero_invalid(m, TRUE); */
for (i = 0; i < npages; ++i) {
if (i != ap->a_reqpage) {
- ma_vm_page_lock(ap->a_m[i]);
- vm_page_free(ap->a_m[i]);
- ma_vm_page_unlock(ap->a_m[i]);
+ ma_vm_page_lock(pages[i]);
+ vm_page_free(pages[i]);
+ ma_vm_page_unlock(pages[i]);
}
}
ma_vm_page_unlock_queues();
- VM_OBJECT_UNLOCK(object);
+ AFS_VM_OBJECT_WUNLOCK(object);
return (0);
}
+#endif
ma_vm_page_unlock_queues();
- VM_OBJECT_UNLOCK(object);
+ AFS_VM_OBJECT_WUNLOCK(object);
}
bp = getpbuf(&afs_pbuf_freecnt);
kva = (vm_offset_t) bp->b_data;
- pmap_qenter(kva, ap->a_m, npages);
+ pmap_qenter(kva, pages, npages);
MA_PCPU_INC(cnt.v_vnodein);
MA_PCPU_ADD(cnt.v_vnodepgsin, npages);
+#ifdef FBSD_VOP_GETPAGES_BUSIED
+ count = ctob(npages);
+#else
+ count = ap->a_count;
+#endif
iov.iov_base = (caddr_t) kva;
- iov.iov_len = ap->a_count;
+ iov.iov_len = count;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
- uio.uio_offset = IDX_TO_OFF(ap->a_m[0]->pindex);
- uio.uio_resid = ap->a_count;
+ uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
+ uio.uio_resid = count;
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = UIO_READ;
uio.uio_td = curthread;
AFS_GLOCK();
- osi_FlushPages(avc, osi_curcred()); /* hold bozon lock, but not basic vnode lock */
- code = afs_read(avc, &uio, osi_curcred(), 0, 0, 0);
+ osi_FlushPages(avc, osi_curcred()); /* hold GLOCK, but not basic vnode lock */
+ code = afs_read(avc, &uio, osi_curcred(), 0);
AFS_GUNLOCK();
pmap_qremove(kva, npages);
relpbuf(bp, &afs_pbuf_freecnt);
- if (code && (uio.uio_resid == ap->a_count)) {
- VM_OBJECT_LOCK(object);
+ if (code && (uio.uio_resid == count)) {
+#ifndef FBSD_VOP_GETPAGES_BUSIED
+ AFS_VM_OBJECT_WLOCK(object);
ma_vm_page_lock_queues();
for (i = 0; i < npages; ++i) {
if (i != ap->a_reqpage)
- vm_page_free(ap->a_m[i]);
+ vm_page_free(pages[i]);
}
ma_vm_page_unlock_queues();
- VM_OBJECT_UNLOCK(object);
+ AFS_VM_OBJECT_WUNLOCK(object);
+#endif
return VM_PAGER_ERROR;
}
- size = ap->a_count - uio.uio_resid;
- VM_OBJECT_LOCK(object);
+ size = count - uio.uio_resid;
+ AFS_VM_OBJECT_WLOCK(object);
ma_vm_page_lock_queues();
for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
vm_page_t m;
nextoff = toff + PAGE_SIZE;
- m = ap->a_m[i];
+ m = pages[i];
/* XXX not in nfsclient? */
m->flags &= ~PG_ZERO;
* Read operation filled an entire page
*/
m->valid = VM_PAGE_BITS_ALL;
-#ifndef AFS_FBSD80_ENV
- vm_page_undirty(m);
-#else
KASSERT(m->dirty == 0, ("afs_getpages: page %p is dirty", m));
-#endif
} else if (size > toff) {
/*
* Read operation filled a partial page.
KASSERT(m->dirty == 0, ("afs_getpages: page %p is dirty", m));
}
+#ifndef FBSD_VOP_GETPAGES_BUSIED
if (i != ap->a_reqpage) {
+#if __FreeBSD_version >= 1000042
+ vm_page_readahead_finish(m);
+#else
/*
* Whether or not to leave the page activated is up in
* the air, but we should put the page on a page queue
* now tell them that it is ok to use.
*/
if (!code) {
-#if defined(AFS_FBSD70_ENV)
if (m->oflags & VPO_WANTED) {
-#else
- if (m->flags & PG_WANTED) {
-#endif
ma_vm_page_lock(m);
vm_page_activate(m);
ma_vm_page_unlock(m);
vm_page_free(m);
ma_vm_page_unlock(m);
}
+#endif /* __FreeBSD_version 1000042 */
}
+#endif /* ndef FBSD_VOP_GETPAGES_BUSIED */
}
ma_vm_page_unlock_queues();
- VM_OBJECT_UNLOCK(object);
- return 0;
+ AFS_VM_OBJECT_WUNLOCK(object);
+ return VM_PAGER_OK;
}
-int
+static int
afs_vop_write(ap)
struct vop_write_args /* {
* struct vnode *a_vp;
int code;
struct vcache *avc = VTOAFS(ap->a_vp);
AFS_GLOCK();
- osi_FlushPages(avc, ap->a_cred); /* hold bozon lock, but not basic vnode lock */
+ osi_FlushPages(avc, ap->a_cred); /* hold GLOCK, but not basic vnode lock */
code =
afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred, 0);
AFS_GUNLOCK();
* All of the pages passed to us in ap->a_m[] are already marked as busy,
* so there is no additional locking required to set their flags. -GAW
*/
-int
+static int
afs_vop_putpages(struct vop_putpages_args *ap)
{
int code;
struct vnode *vp;
struct vcache *avc;
+ memset(&uio, 0, sizeof(uio));
+ memset(&iov, 0, sizeof(iov));
+
vp = ap->a_vp;
avc = VTOAFS(vp);
/* Perhaps these two checks should just be KASSERTs instead... */
return ap->a_rtvals[0];
}
-int
+static int
afs_vop_ioctl(ap)
struct vop_ioctl_args /* {
* struct vnode *a_vp;
}
}
-/* ARGSUSED */
-int
-afs_vop_poll(ap)
- struct vop_poll_args /* {
- * struct vnode *a_vp;
- * int a_events;
- * struct ucred *a_cred;
- * struct thread *td;
- * } */ *ap;
-{
- /*
- * We should really check to see if I/O is possible.
- */
- return (1);
-}
-
-/*
- * Mmap a file
- *
- * NB Currently unsupported.
- */
-/* ARGSUSED */
-int
-afs_vop_mmap(ap)
- struct vop_mmap_args /* {
- * struct vnode *a_vp;
- * int a_fflags;
- * struct ucred *a_cred;
- * struct thread *td;
- * } */ *ap;
-{
- return (EINVAL);
-}
-
-int
+static int
afs_vop_fsync(ap)
struct vop_fsync_args /* {
* struct vnode *a_vp;
AFS_GLOCK();
/*vflushbuf(vp, wait); */
-#ifdef AFS_FBSD60_ENV
error = afs_fsync(VTOAFS(vp), ap->a_td->td_ucred);
-#else
- if (ap->a_cred)
- error = afs_fsync(VTOAFS(vp), ap->a_cred);
- else
- error = afs_fsync(VTOAFS(vp), afs_osi_credp);
-#endif
AFS_GUNLOCK();
return error;
}
-int
+static int
afs_vop_remove(ap)
struct vop_remove_args /* {
* struct vnode *a_dvp;
return error;
}
-int
+static int
afs_vop_link(ap)
struct vop_link_args /* {
* struct vnode *a_vp;
int error = 0;
struct vnode *dvp = ap->a_tdvp;
struct vnode *vp = ap->a_vp;
-#ifndef AFS_FBSD80_ENV
- struct thread *p = ap->a_cnp->cn_thread;
-#endif
GETNAME();
if (dvp->v_mount != vp->v_mount) {
return error;
}
-int
+static int
afs_vop_rename(ap)
struct vop_rename_args /* {
* struct vnode *a_fdvp;
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
struct vnode *fdvp = ap->a_fdvp;
-#ifndef AFS_FBSD80_ENV
- struct thread *p = fcnp->cn_thread;
-#endif
/*
* Check for cross-device rename.
return error;
}
-int
+static int
afs_vop_mkdir(ap)
struct vop_mkdir_args /* {
* struct vnode *a_dvp;
struct vattr *vap = ap->a_vap;
int error = 0;
struct vcache *vcp;
-#ifndef AFS_FBSD80_ENV
- struct thread *p = ap->a_cnp->cn_thread;
-#endif
GETNAME();
#ifdef DIAGNOSTIC
return error;
}
-int
+static int
afs_vop_rmdir(ap)
struct vop_rmdir_args /* {
* struct vnode *a_dvp;
* char *a_target;
* };
*/
-int
+static int
afs_vop_symlink(struct vop_symlink_args *ap)
{
struct vnode *dvp;
newvp = NULL;
error =
- afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target, cnp->cn_cred);
+ afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target, NULL,
+ cnp->cn_cred);
if (error == 0) {
error = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
if (error == 0) {
return error;
}
-int
+static int
afs_vop_readdir(ap)
struct vop_readdir_args /* {
* struct vnode *a_vp;
return error;
}
-int
+static int
afs_vop_readlink(ap)
struct vop_readlink_args /* {
* struct vnode *a_vp;
return error;
}
-extern int prtactive;
-
-int
+static int
afs_vop_inactive(ap)
struct vop_inactive_args /* {
* struct vnode *a_vp;
{
struct vnode *vp = ap->a_vp;
- if (prtactive && vp->v_usecount != 0)
- vprint("afs_vop_inactive(): pushing active", vp);
-
AFS_GLOCK();
afs_InactiveVCache(VTOAFS(vp), 0); /* decrs ref counts */
AFS_GUNLOCK();
-#ifndef AFS_FBSD60_ENV
- MA_VOP_UNLOCK(vp, 0, ap->a_td);
-#endif
return 0;
}
* struct vnode *a_vp;
* };
*/
-int
+static int
afs_vop_reclaim(struct vop_reclaim_args *ap)
{
/* copied from ../OBSD/osi_vnodeops.c:afs_nbsd_reclaim() */
return 0;
}
-#ifndef AFS_FBSD60_ENV
-int
-afs_vop_bmap(ap)
- struct vop_bmap_args /* {
- * struct vnode *a_vp;
- * daddr_t a_bn;
- * struct vnode **a_vpp;
- * daddr_t *a_bnp;
- * int *a_runp;
- * int *a_runb;
- * } */ *ap;
-{
- if (ap->a_bnp) {
- *ap->a_bnp = ap->a_bn * (PAGE_SIZE / DEV_BSIZE);
- }
- if (ap->a_vpp) {
- *ap->a_vpp = ap->a_vp;
- }
- if (ap->a_runp != NULL)
- *ap->a_runp = 0;
- if (ap->a_runb != NULL)
- *ap->a_runb = 0;
-
- return 0;
-}
-#endif
-
-int
+static int
afs_vop_strategy(ap)
struct vop_strategy_args /* {
* struct buf *a_bp;
return error;
}
-int
+static int
afs_vop_print(ap)
struct vop_print_args /* {
* struct vnode *a_vp;
/*
* Advisory record locking support (fcntl() POSIX style)
*/
-int
+static int
afs_vop_advlock(ap)
struct vop_advlock_args /* {
* struct vnode *a_vp;
* int a_flags;
* } */ *ap;
{
- int error;
+ int error, a_op;
struct ucred cr = *osi_curcred();
+ a_op = ap->a_op;
+ if (a_op == F_UNLCK) {
+ /*
+ * When a_fl->type is F_UNLCK, FreeBSD passes in an a_op of F_UNLCK.
+ * This is (confusingly) different than how you actually release a lock
+ * with fcntl(), which is done with an a_op of F_SETLK and an l_type of
+ * F_UNLCK. Pretend we were given an a_op of F_SETLK in this case,
+ * since this is what afs_lockctl expects.
+ */
+ a_op = F_SETLK;
+ }
+
AFS_GLOCK();
error =
- afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, ap->a_op, &cr, (int)ap->a_id);
+ afs_lockctl(VTOAFS(ap->a_vp),
+ ap->a_fl,
+ a_op, &cr,
+ (int)(intptr_t)ap->a_id); /* XXX: no longer unique! */
AFS_GUNLOCK();
return error;
}
+
+struct vop_vector afs_vnodeops = {
+ .vop_default = &default_vnodeops,
+ .vop_access = afs_vop_access,
+ .vop_advlock = afs_vop_advlock,
+ .vop_close = afs_vop_close,
+ .vop_create = afs_vop_create,
+ .vop_fsync = afs_vop_fsync,
+ .vop_getattr = afs_vop_getattr,
+ .vop_getpages = afs_vop_getpages,
+ .vop_inactive = afs_vop_inactive,
+ .vop_ioctl = afs_vop_ioctl,
+ .vop_link = afs_vop_link,
+ .vop_lookup = afs_vop_lookup,
+ .vop_mkdir = afs_vop_mkdir,
+ .vop_mknod = afs_vop_mknod,
+ .vop_open = afs_vop_open,
+ .vop_pathconf = afs_vop_pathconf,
+ .vop_print = afs_vop_print,
+ .vop_putpages = afs_vop_putpages,
+ .vop_read = afs_vop_read,
+ .vop_readdir = afs_vop_readdir,
+ .vop_readlink = afs_vop_readlink,
+ .vop_reclaim = afs_vop_reclaim,
+ .vop_remove = afs_vop_remove,
+ .vop_rename = afs_vop_rename,
+ .vop_rmdir = afs_vop_rmdir,
+ .vop_setattr = afs_vop_setattr,
+ .vop_strategy = afs_vop_strategy,
+ .vop_symlink = afs_vop_symlink,
+ .vop_write = afs_vop_write,
+};
git://git.openafs.org / openafs.git / blobdiff