+/*
+ * A large chunk of this file appears to be copied directly from
+ * sys/nfsclient/nfs_bio.c, which has the following license:
+ */
+/*
+ * Copyright (c) 1989, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Rick Macklem at The University of Guelph.
+ *
+ * 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.
+ *
+ * @(#)nfs_bio.c 8.9 (Berkeley) 3/30/95
+ */
+/*
+ * Pursuant to a statement of U.C. Berkeley dated 1999-07-22, this license
+ * is amended to drop clause (3) above.
+ */
+
#include <afsconfig.h>
#include <afs/param.h>
#include <afs/afs_stats.h> /* statistics */
#include <sys/malloc.h>
#include <sys/namei.h>
+#include <sys/unistd.h>
#ifndef AFS_FBSD50_ENV
#include <vm/vm_zone.h>
#endif
#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;
+
+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_lease = VOP_NULL,
+ .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,
+};
+
+#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_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 *);
#ifndef AFS_FBSD50_ENV
int afs_vop_mmap(struct vop_mmap_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_lock(struct vop_lock_args *);
-int afs_vop_unlock(struct vop_unlock_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_islocked(struct vop_islocked_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_eopnotsupp},
+ {&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_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_islocked_desc, (vop_t *) afs_vop_islocked}, /* islocked */
{&vop_lease_desc, (vop_t *) vop_null},
{&vop_link_desc, (vop_t *) afs_vop_link}, /* link */
- {&vop_lock_desc, (vop_t *) afs_vop_lock}, /* lock */
{&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_mmap_desc, (vop_t *) afs_vop_mmap}, /* mmap */
#endif
{&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_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_unlock_desc, (vop_t *) afs_vop_unlock}, /* unlock */
{&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 */
};
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; \
#define a_p a_td
#endif
-
+/*
+ * Mosty copied from sys/ufs/ufs/ufs_vnops.c:ufs_pathconf().
+ * We should know the correct answers to these questions with
+ * respect to the AFS protocol (which may differ from the UFS
+ * values) but for the moment this will do.
+ */
+static int
+afs_vop_pathconf(struct vop_pathconf_args *ap)
+{
+ int error;
+
+ error = 0;
+ switch (ap->a_name) {
+ case _PC_LINK_MAX:
+ *ap->a_retval = LINK_MAX;
+ break;
+ case _PC_NAME_MAX:
+ *ap->a_retval = NAME_MAX;
+ break;
+ case _PC_PATH_MAX:
+ *ap->a_retval = PATH_MAX;
+ break;
+ case _PC_PIPE_BUF:
+ *ap->a_retval = PIPE_BUF;
+ break;
+ case _PC_CHOWN_RESTRICTED:
+ *ap->a_retval = 1;
+ break;
+ case _PC_NO_TRUNC:
+ *ap->a_retval = 1;
+ break;
+#ifdef _PC_ACL_EXTENDED
+ case _PC_ACL_EXTENDED:
+ *ap->a_retval = 0;
+ break;
+ case _PC_ACL_PATH_MAX:
+ *ap->a_retval = 3;
+ break;
+#endif
+#ifdef _PC_MAC_PRESENT
+ case _PC_MAC_PRESENT:
+ *ap->a_retval = 0;
+ break;
+#endif
+#ifdef _PC_ASYNC_IO
+ case _PC_ASYNC_IO:
+ /* _PC_ASYNC_IO should have been handled by upper layers. */
+ KASSERT(0, ("_PC_ASYNC_IO should not get here"));
+ error = EINVAL;
+ break;
+ case _PC_PRIO_IO:
+ *ap->a_retval = 0;
+ break;
+ case _PC_SYNC_IO:
+ *ap->a_retval = 0;
+ break;
+#endif
+#ifdef _PC_ALLOC_SIZE_MIN
+ case _PC_ALLOC_SIZE_MIN:
+ *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_bsize;
+ break;
+#endif
+#ifdef _PC_FILESIZEBITS
+ case _PC_FILESIZEBITS:
+ *ap->a_retval = 32; /* XXX */
+ break;
+#endif
+#ifdef _PC_REC_INCR_XFER_SIZE
+ case _PC_REC_INCR_XFER_SIZE:
+ *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
+ break;
+ case _PC_REC_MAX_XFER_SIZE:
+ *ap->a_retval = -1; /* means ``unlimited'' */
+ break;
+ case _PC_REC_MIN_XFER_SIZE:
+ *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
+ break;
+ case _PC_REC_XFER_ALIGN:
+ *ap->a_retval = PAGE_SIZE;
+ break;
+#endif
+#ifdef _PC_SYMLINK_MAX
+ case _PC_SYMLINK_MAX:
+ *ap->a_retval = MAXPATHLEN;
+ break;
+#endif
+ default:
+ error = EINVAL;
+ break;
+ }
+ return (error);
+}
int
afs_vop_lookup(ap)
* } */ *ap;
{
int error;
- int bad;
struct vcache *vc = VTOAFS(ap->a_vp);
- bad = 0;
+
AFS_GLOCK();
error = afs_open(&vc, ap->a_mode, ap->a_cred);
#ifdef DIAGNOSTIC
if (AFSTOV(vc) != ap->a_vp)
panic("AFS open changed vnode!");
#endif
- afs_BozonLock(&vc->pvnLock, vc);
- osi_FlushPages(vc, ap->a_cred);
- afs_BozonUnlock(&vc->pvnLock, vc);
AFS_GUNLOCK();
+#ifdef AFS_FBSD60_ENV
+ vnode_create_vobject(ap->a_vp, vc->m.Length, ap->a_td);
+#endif
+ osi_FlushPages(vc, ap->a_cred);
return error;
}
code = afs_close(avc, ap->a_fflag, ap->a_cred);
else
code = afs_close(avc, ap->a_fflag, afs_osi_credp);
- afs_BozonLock(&avc->pvnLock, avc);
osi_FlushPages(avc, ap->a_cred); /* hold bozon lock, but not basic vnode lock */
- afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
int code;
struct vcache *avc = VTOAFS(ap->a_vp);
AFS_GLOCK();
- afs_BozonLock(&avc->pvnLock, avc);
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);
- afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
+/* struct vop_getpages_args {
+ * struct vnode *a_vp;
+ * vm_page_t *a_m;
+ * int a_count;
+ * int a_reqpage;
+ * vm_oofset_t a_offset;
+ * };
+ */
int
-afs_vop_getpages(ap)
- struct vop_getpages_args /* {
- * struct vnode *a_vp;
- * vm_page_t *a_m;
- * int a_count;
- * int a_reqpage;
- * vm_oofset_t a_offset;
- * } */ *ap;
+afs_vop_getpages(struct vop_getpages_args *ap)
{
int code;
int i, nextoff, size, toff, npages;
struct iovec iov;
struct buf *bp;
vm_offset_t kva;
- struct vcache *avc = VTOAFS(ap->a_vp);
+ vm_object_t object;
+ struct vnode *vp;
+ struct vcache *avc;
- if (avc->v.v_object == NULL) {
+#ifdef AFS_FBSD50_ENV
+ GIANT_REQUIRED;
+#endif
+ vp = ap->a_vp;
+ avc = VTOAFS(vp);
+ if ((object = vp->v_object) == NULL) {
printf("afs_getpages: called with non-merged cache vnode??\n");
return VM_PAGER_ERROR;
}
{
vm_page_t m = ap->a_m[ap->a_reqpage];
+#ifdef AFS_FBSD50_ENV
+ VM_OBJECT_LOCK(object);
+ vm_page_lock_queues();
+#endif
if (m->valid != 0) {
/* handled by vm_fault now */
/* vm_page_zero_invalid(m, TRUE); */
if (i != ap->a_reqpage)
vm_page_free(ap->a_m[i]);
}
+#ifdef AFS_FBSD50_ENV
+ vm_page_unlock_queues();
+ VM_OBJECT_UNLOCK(object);
+#endif
return (0);
}
+#ifdef AFS_FBSD50_ENV
+ vm_page_unlock_queues();
+ VM_OBJECT_UNLOCK(object);
+#endif
}
bp = getpbuf(&afs_pbuf_freecnt);
+
kva = (vm_offset_t) bp->b_data;
pmap_qenter(kva, ap->a_m, npages);
+#ifdef AFS_FBSD50_ENV
+ cnt.v_vnodein++;
+ cnt.v_vnodepgsin += npages;
+#endif
+
iov.iov_base = (caddr_t) kva;
iov.iov_len = ap->a_count;
uio.uio_iov = &iov;
#else
uio.uio_procp = curproc;
#endif
+
AFS_GLOCK();
- afs_BozonLock(&avc->pvnLock, avc);
osi_FlushPages(avc, osi_curcred()); /* hold bozon lock, but not basic vnode lock */
code = afs_read(avc, &uio, osi_curcred(), 0, 0, 0);
- afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
pmap_qremove(kva, npages);
relpbuf(bp, &afs_pbuf_freecnt);
+
if (code && (uio.uio_resid == ap->a_count)) {
+#ifdef AFS_FBSD50_ENV
+ VM_OBJECT_LOCK(object);
+ vm_page_lock_queues();
+#endif
for (i = 0; i < npages; ++i) {
if (i != ap->a_reqpage)
vm_page_free(ap->a_m[i]);
}
+#ifdef AFS_FBSD50_ENV
+ vm_page_unlock_queues();
+ VM_OBJECT_UNLOCK(object);
+#endif
return VM_PAGER_ERROR;
}
+
size = ap->a_count - uio.uio_resid;
+#ifdef AFS_FBSD50_ENV
+ VM_OBJECT_LOCK(object);
+ vm_page_lock_queues();
+#endif
for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
vm_page_t m;
nextoff = toff + PAGE_SIZE;
* now tell them that it is ok to use.
*/
if (!code) {
+#if defined(AFS_FBSD70_ENV)
+ if(0) /* XXXX fixme for 7.0 */
+#else
if (m->flags & PG_WANTED)
+#endif
vm_page_activate(m);
else
vm_page_deactivate(m);
}
}
}
+#ifdef AFS_FBSD50_ENV
+ vm_page_unlock_queues();
+ VM_OBJECT_UNLOCK(object);
+#endif
return 0;
}
int code;
struct vcache *avc = VTOAFS(ap->a_vp);
AFS_GLOCK();
- afs_BozonLock(&avc->pvnLock, avc);
osi_FlushPages(avc, ap->a_cred); /* hold bozon lock, but not basic vnode lock */
code =
afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred, 0);
- afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
+/*-
+ * struct vop_putpages_args {
+ * struct vnode *a_vp;
+ * vm_page_t *a_m;
+ * int a_count;
+ * int a_sync;
+ * int *a_rtvals;
+ * vm_oofset_t a_offset;
+ * };
+ */
+/*
+ * 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
-afs_vop_putpages(ap)
- struct vop_putpages_args /* {
- * struct vnode *a_vp;
- * vm_page_t *a_m;
- * int a_count;
- * int a_sync;
- * int *a_rtvals;
- * vm_oofset_t a_offset;
- * } */ *ap;
+afs_vop_putpages(struct vop_putpages_args *ap)
{
int code;
int i, size, npages, sync;
struct iovec iov;
struct buf *bp;
vm_offset_t kva;
- struct vcache *avc = VTOAFS(ap->a_vp);
+ struct vnode *vp;
+ struct vcache *avc;
- if (avc->v.v_object == NULL) {
+#ifdef AFS_FBSD50_ENV
+ GIANT_REQUIRED;
+#endif
+
+ vp = ap->a_vp;
+ avc = VTOAFS(vp);
+ /* Perhaps these two checks should just be KASSERTs instead... */
+ if (vp->v_object == NULL) {
printf("afs_putpages: called with non-merged cache vnode??\n");
- return VM_PAGER_ERROR;
+ return VM_PAGER_ERROR; /* XXX I think this is insufficient */
}
if (vType(avc) != VREG) {
printf("afs_putpages: not VREG");
- return VM_PAGER_ERROR;
+ return VM_PAGER_ERROR; /* XXX I think this is insufficient */
}
npages = btoc(ap->a_count);
for (i = 0; i < npages; i++)
ap->a_rtvals[i] = VM_PAGER_AGAIN;
bp = getpbuf(&afs_pbuf_freecnt);
+
kva = (vm_offset_t) bp->b_data;
pmap_qenter(kva, ap->a_m, npages);
+#ifdef AFS_FBSD50_ENV
+ cnt.v_vnodeout++;
+ cnt.v_vnodepgsout += ap->a_count;
+#endif
+
iov.iov_base = (caddr_t) kva;
iov.iov_len = ap->a_count;
uio.uio_iov = &iov;
* sync |= IO_INVAL; */
AFS_GLOCK();
- afs_BozonLock(&avc->pvnLock, avc);
code = afs_write(avc, &uio, sync, osi_curcred(), 0);
- afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
- pmap_qremove(kva, npages);
+ pmap_qremove(kva, npages);
relpbuf(bp, &afs_pbuf_freecnt);
+
if (!code) {
size = ap->a_count - uio.uio_resid;
for (i = 0; i < round_page(size) / PAGE_SIZE; i++) {
ap->a_rtvals[i] = VM_PAGER_OK;
- ap->a_m[i]->dirty = 0;
+ vm_page_undirty(ap->a_m[i]);
}
- return VM_PAGER_ERROR;
}
return ap->a_rtvals[0];
}
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;
}
error = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, cnp->cn_cred);
AFS_GUNLOCK();
if (error) {
- vput(dvp);
DROPNAME();
return (error);
}
return error;
}
+/* struct vop_symlink_args {
+ * struct vnode *a_dvp;
+ * struct vnode **a_vpp;
+ * struct componentname *a_cnp;
+ * struct vattr *a_vap;
+ * char *a_target;
+ * };
+ */
int
-afs_vop_symlink(ap)
- struct vop_symlink_args /* {
- * struct vnode *a_dvp;
- * struct vnode **a_vpp;
- * struct componentname *a_cnp;
- * struct vattr *a_vap;
- * char *a_target;
- * } */ *ap;
+afs_vop_symlink(struct vop_symlink_args *ap)
{
- register struct vnode *dvp = ap->a_dvp;
- int error = 0;
- /* NFS ignores a_vpp; so do we. */
+ struct vnode *dvp;
+ struct vnode *newvp;
+ struct vcache *vcp;
+ int error;
GETNAME();
AFS_GLOCK();
+
+ dvp = ap->a_dvp;
+ newvp = NULL;
+
error =
afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target, cnp->cn_cred);
+ if (error == 0) {
+ error = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
+ if (error == 0) {
+ newvp = AFSTOV(vcp);
+#ifdef AFS_FBSD50_ENV
+ vn_lock(newvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_thread);
+#else
+ vn_lock(newvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc);
+#endif
+ }
+ }
AFS_GUNLOCK();
DROPNAME();
+ *(ap->a_vpp) = newvp;
return error;
}
return 0;
}
+/*
+ * struct vop_reclaim_args {
+ * struct vnode *a_vp;
+ * };
+ */
int
-afs_vop_reclaim(ap)
- struct vop_reclaim_args /* {
- * struct vnode *a_vp;
- * } */ *ap;
+afs_vop_reclaim(struct vop_reclaim_args *ap)
{
-#ifdef AFS_DO_FLUSH_IN_RECLAIM
- int error, sl;
-#endif
- register struct vnode *vp = ap->a_vp;
-
- cache_purge(vp); /* just in case... */
+ /* copied from ../OBSD/osi_vnodeops.c:afs_nbsd_reclaim() */
+ int code, slept;
+ struct vnode *vp = ap->a_vp;
+ struct vcache *avc = VTOAFS(vp);
+ int haveGlock = ISAFS_GLOCK();
+ int haveVlock = CheckLock(&afs_xvcache);
-#ifdef AFS_DO_FLUSH_IN_RECLAIM
- AFS_GLOCK();
- error = afs_FlushVCache(VTOAFS(vp), &sl); /* tosses our stuff from vnode */
- AFS_GUNLOCK();
- ubc_unlink(vp);
- if (!error && vp->v_data)
- panic("afs_reclaim: vnode not cleaned");
- return error;
+ if (!haveGlock)
+ AFS_GLOCK();
+ if (!haveVlock)
+ ObtainWriteLock(&afs_xvcache, 901);
+#ifndef AFS_DISCON_ENV
+ code = afs_FlushVCache(avc, &slept); /* tosses our stuff from vnode */
#else
- if (vp->v_usecount == 2) {
- vprint("reclaim count==2", vp);
- } else if (vp->v_usecount == 1) {
- vprint("reclaim count==1", vp);
- } else
- vprint("reclaim bad count", vp);
-
- return 0;
+ /* reclaim the vnode and the in-memory vcache, but keep the on-disk vcache */
+ code = afs_FlushVS(avc);
#endif
-}
-
-int
-afs_vop_lock(ap)
- struct vop_lock_args /* {
- * struct vnode *a_vp;
- * } */ *ap;
-{
- register struct vnode *vp = ap->a_vp;
- register struct vcache *avc = VTOAFS(vp);
+ if (!haveVlock)
+ ReleaseWriteLock(&afs_xvcache);
+ if (!haveGlock)
+ AFS_GUNLOCK();
-#ifdef AFS_FBSD50_ENV
- if (!strcmp(vp->v_tag, "none"))
-#else
- if (vp->v_tag == VT_NON)
+ /*
+ * XXX Pretend it worked, to prevent panic on shutdown
+ * Garrett, please fix - Jim Rees
+ */
+ if (code)
+ printf("afs_vop_reclaim: afs_FlushVCache failed code %d\n", code);
+#ifdef AFS_FBSD60_ENV
+ else
+ vnode_destroy_vobject(vp);
#endif
- return (ENOENT);
- return (lockmgr(&avc->rwlock, ap->a_flags, &vp->v_interlock, ap->a_p));
-}
-
-int
-afs_vop_unlock(ap)
- struct vop_unlock_args /* {
- * struct vnode *a_vp;
- * } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct vcache *avc = VTOAFS(vp);
- return (lockmgr
- (&avc->rwlock, ap->a_flags | LK_RELEASE, &vp->v_interlock,
- ap->a_p));
-
+ return 0;
}
+#ifndef AFS_FBSD60_ENV
int
afs_vop_bmap(ap)
struct vop_bmap_args /* {
return 0;
}
+#endif
int
afs_vop_strategy(ap)
return 0;
}
-int
-afs_vop_islocked(ap)
- struct vop_islocked_args /* {
- * struct vnode *a_vp;
- * } */ *ap;
-{
- struct vcache *vc = VTOAFS(ap->a_vp);
- return lockstatus(&vc->rwlock, ap->a_p);
-}
-
/*
* Advisory record locking support (fcntl() POSIX style)
*/