jimzah/openafs
1
0
Fork 0
mirror of https://git.openafs.org/openafs.git synced 2025-01-18 23:10:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

netbsd: remove old (non-original) NBSD port

Browse Source 
Prepare for rebase of NBSD port at the current OBSD port,
which is descended directly from the original NBSD port and
more closely resembles it.

Change-Id: I9ff67ebea04534ac5ddc11c0aa1d65028067806a
Reviewed-on: http://gerrit.openafs.org/1858
Reviewed-by: Derrick Brashear <shadow@dementia.org>
Tested-by: Derrick Brashear <shadow@dementia.org>
This commit is contained in:
Matt Benjmain 2010-04-27 12:06:48 -04:00 committed by Derrick Brashear
parent 14195f0f48
commit c598e34fc3
13 changed files with 0 additions and 2910 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/afs/NBSD/opt_posix.h
View File

@ -1,2 +0,0 @@
#define P1003_1B 1
#define _KPOSIX_PRIORITY_SCHEDULING 1

228
src/afs/NBSD/osi_file.c
View File

@ -1,228 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* afs statistics */
int afs_osicred_initialized = 0;
afs_ucred_t afs_osi_cred;
afs_lock_t afs_xosi; /* lock is for tvattr */
extern struct osi_dev cacheDev;
extern struct mount *afs_cacheVfsp;
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
osi_Panic("UFSOpen called for non-UFS cache\n");
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
code =
igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip,
&dummy);
AFS_GLOCK();
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
IN_UNLOCK(ip);
afile->vnode = ITOV(ip);
afile->size = VTOI(afile->vnode)->i_size;
afile->offset = 0;
afile->proc = (int (*)())0;
return (void *)afile;
}
int
afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
{
register afs_int32 code;
struct vattr tvattr;
AFS_STATCNT(osi_Stat);
ObtainWriteLock(&afs_xosi, 320);
AFS_GUNLOCK();
VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp, code);
AFS_GLOCK();
if (code == 0) {
astat->size = tvattr.va_size;
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSClose(register struct osi_file *afile)
{
AFS_STATCNT(osi_Close);
if (afile->vnode) {
AFS_RELE(afile->vnode);
}
osi_FreeSmallSpace(afile);
return 0;
}
int
osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
register afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
VATTR_NULL(&tvattr);
/* note that this credential swapping stuff is only necessary because
* of ufs's references directly to cred instead of to
* credentials parameter. Probably should fix ufs some day. */
oldCred = curproc->p_cred->pc_ucred; /* remember old credentials pointer */
curproc->p_cred->pc_ucred = afs_osi_credp;
/* temporarily use superuser credentials */
tvattr.va_size = asize;
AFS_GUNLOCK();
VOP_SETATTR(afile->vnode, &tvattr, afs_osi_credp, code);
AFS_GLOCK();
curproc->p_cred->pc_ucred = oldCred; /* restore */
ReleaseWriteLock(&afs_xosi);
return code;
}
void
osi_DisableAtimes(struct vnode *avp)
{
struct inode *ip = VTOI(avp);
ip->i_flag &= ~IACC;
}
/* Generic read interface */
int
afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
register afs_int32 code;
register afs_int32 cnt1 = 0;
AFS_STATCNT(osi_Read);
/**
* If the osi_file passed in is NULL, panic only if AFS is not shutting
* down. No point in crashing when we are already shutting down
*/
if (!afile) {
if (!afs_shuttingdown)
osi_Panic("osi_Read called with null param");
else
return EIO;
}
if (offset != -1)
afile->offset = offset;
AFS_GUNLOCK();
code =
gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
AFS_UIOSYS, IO_UNIT, afs_osi_credp, &resid);
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
afile->offset += code;
osi_DisableAtimes(afile->vnode);
} else {
afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
ICL_TYPE_INT32, code);
code = -1;
}
return code;
}
/* Generic write interface */
int
afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
afs_int32 asize)
{
afs_ucred_t *oldCred;
unsigned int resid;
register afs_int32 code;
AFS_STATCNT(osi_Write);
if (!afile)
osi_Panic("afs_osi_Write called with null param");
if (offset != -1)
afile->offset = offset;
{
struct ucred *tmpcred = curproc->p_cred->pc_ucred;
curproc->p_cred->pc_ucred = afs_osi_credp;
AFS_GUNLOCK();
code =
gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
afile->offset, AFS_UIOSYS, IO_UNIT, afs_osi_credp,
&resid);
AFS_GLOCK();
curproc->p_cred->pc_ucred = tmpcred;
}
if (code == 0) {
code = asize - resid;
afile->offset += code;
} else {
code = -1;
}
if (afile->proc) {
(*afile->proc) (afile, code);
}
return code;
}
/* This work should be handled by physstrat in ca/machdep.c.
This routine written from the RT NFS port strategy routine.
It has been generalized a bit, but should still be pretty clear. */
int
afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
{
afs_int32 returnCode;
AFS_STATCNT(osi_MapStrategy);
returnCode = (*aproc) (bp);
return returnCode;
}
void
shutdown_osifile(void)
{
AFS_STATCNT(shutdown_osifile);
if (afs_cold_shutdown) {
afs_osicred_initialized = 0;
}
}

38
src/afs/NBSD/osi_gcpags.c
View File

@ -1,38 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* afs statistics */
#if AFS_GCPAGS
/* return a pointer (sometimes a static copy ) to the cred for a
* given afs_proc_t.
* subsequent calls may overwrite the previously returned value.
*/
const afs_ucred_t *
afs_osi_proc2cred(afs_proc_t * pr)
{
afs_ucred_t *rv = NULL;
if (pr == NULL) {
return NULL;
}
rv = pr->p_cred;
return rv;
}
#endif /* AFS_GCPAGS */

150
src/afs/NBSD/osi_groups.c
View File

@ -1,150 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
* osi_groups.c
*
* Implements:
* Afs_xsetgroups (syscall)
* setpag
*
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h"
#include "afsincludes.h"
#include "afs/afs_stats.h" /* statistics */
#define NOCRED ((struct ucred *) -1)
#define NOUID ((uid_t) -1)
#define NOGID ((gid_t) -1)
static int
afs_getgroups(struct ucred *cred, int ngroups, gid_t * gidset);
static int
afs_setgroups(struct proc *proc, struct ucred **cred, int ngroups,
gid_t * gidset, int change_parent);
int
Afs_xsetgroups(p, args, retval)
struct proc *p;
void *args;
int *retval;
{
int code = 0;
struct vrequest treq;
AFS_STATCNT(afs_xsetgroups);
AFS_GLOCK();
/* code = afs_InitReq(&treq, u.u_cred); */
code = afs_InitReq(&treq, curproc->p_cred->pc_ucred);
AFS_GUNLOCK();
if (code)
return code;
code = setgroups(p, args, retval);
/* Note that if there is a pag already in the new groups we don't
* overwrite it with the old pag.
*/
if (PagInCred(curproc->p_cred->pc_ucred) == NOPAG) {
if (((treq.uid >> 24) & 0xff) == 'A') {
AFS_GLOCK();
/* we've already done a setpag, so now we redo it */
AddPag(p, treq.uid, &p->p_rcred);
AFS_GUNLOCK();
}
}
return code;
}
int
setpag(proc, cred, pagvalue, newpag, change_parent)
struct proc *proc;
struct ucred **cred;
afs_uint32 pagvalue;
afs_uint32 *newpag;
afs_uint32 change_parent;
{
gid_t gidset[NGROUPS];
int ngroups, code;
int j;
AFS_STATCNT(setpag);
ngroups = afs_getgroups(*cred, NGROUPS, gidset);
if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
/* We will have to shift grouplist to make room for pag */
if (ngroups + 2 > NGROUPS) {
return (E2BIG);
}
for (j = ngroups - 1; j >= 0; j--) {
gidset[j + 2] = gidset[j];
}
ngroups += 2;
}
*newpag = (pagvalue == -1 ? genpag() : pagvalue);
afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
code = afs_setgroups(proc, cred, ngroups, gidset, change_parent);
return code;
}
static int
afs_getgroups(struct ucred *cred, int ngroups, gid_t * gidset)
{
int ngrps, savengrps;
gid_t *gp;
AFS_STATCNT(afs_getgroups);
savengrps = ngrps = MIN(ngroups, cred->cr_ngroups);
gp = cred->cr_groups;
while (ngrps--)
*gidset++ = *gp++;
return savengrps;
}
static int
afs_setgroups(struct proc *proc, struct ucred **cred, int ngroups,
gid_t * gidset, int change_parent)
{
int ngrps;
int i;
gid_t *gp;
struct ucred *newcr, *cr;
AFS_STATCNT(afs_setgroups);
/*
* The real setgroups() call does this, so maybe we should too.
*
*/
if (ngroups > NGROUPS)
return EINVAL;
cr = *cred;
if (!change_parent) {
crhold(cr);
newcr = crcopy(cr);
} else
newcr = cr;
newcr->cr_ngroups = ngroups;
gp = newcr->cr_groups;
while (ngroups--)
*gp++ = *gidset++;
if (!change_parent) {
substitute_real_creds(proc, NOUID, NOUID, NOGID, NOGID, newcr);
}
*cred = newcr;
return (0);
}

283
src/afs/NBSD/osi_inode.c
View File

@ -1,283 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
* FreeBSD inode operations
*
* Implements:
*
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/osi_inode.h"
#include "afs/afs_stats.h" /* statistics stuff */
#include <sys/queue.h>
#include <sys/lock.h>
#include <ufs/ufsmount.h>
#include <ufs/ufs/dinode.h>
getinode(fs, dev, inode, ipp, perror)
struct mount *fs;
struct inode **ipp;
dev_t dev;
ino_t inode;
int *perror;
{
register struct vnode *vp;
char fake_vnode[FAKE_INODE_SIZE];
struct inode *ip;
int code;
*ipp = 0;
*perror = 0;
if (!fs) {
register struct ufsmount *ump;
register struct vnode *vp;
register struct mount *mp;
MOUNTLIST_LOCK();
if (mp = TAILQ_FIRST(&mountlist))
do {
/*
* XXX Also do the test for MFS
*/
#undef m_data
#undef m_next
if (mp->mnt_stat.f_type == MOUNT_UFS) {
MOUNTLIST_UNLOCK();
ump = VFSTOUFS(mp);
if (ump->um_fs == NULL)
break;
if (ump->um_dev == dev) {
fs = ump->um_mountp;
}
MOUNTLIST_LOCK();
}
mp = TAILQ_NEXT(mp, mnt_list);
} while (mp != TAILQ_FIRST(&mountlist));
MOUNTLIST_UNLOCK();
if (!fs)
return (ENXIO);
}
vp = (struct vnode *)fake_vnode;
fake_inode_init(vp, fs);
code = iget(VTOI(vp), inode, &ip, 0);
if (code != 0) {
*perror = BAD_IGET;
return code;
} else {
*ipp = ip;
return (0);
}
}
igetinode(vfsp, dev, inode, ipp, perror)
struct inode **ipp;
struct mount *vfsp;
dev_t dev;
ino_t inode;
int *perror;
{
struct inode *pip, *ip;
extern struct osi_dev cacheDev;
register int code = 0;
*perror = 0;
AFS_STATCNT(igetinode);
if ((code = getinode(vfsp, dev, inode, &ip, perror)) != 0) {
return (code);
}
if (ip->i_mode == 0) {
/* Not an allocated inode */
iforget(ip);
return (ENOENT);
}
if (ip->i_nlink == 0 || (ip->i_mode & IFMT) != IFREG) {
iput(ip);
return (ENOENT);
}
*ipp = ip;
return (0);
}
iforget(ip)
struct inode *ip;
{
struct vnode *vp = ITOV(ip);
AFS_STATCNT(iforget);
VN_LOCK(vp);
/* this whole thing is too wierd. Why??? XXX */
if (vp->v_usecount == 1) {
VN_UNLOCK(vp);
idrop(ip);
} else {
VN_UNLOCK(vp);
}
}
/*
* icreate system call -- create an inode
*/
afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
long *retval;
long dev, near_inode, param1, param2, param3, param4;
{
int dummy, err = 0;
struct inode *ip, *newip;
register int code;
struct vnode *vp;
AFS_STATCNT(afs_syscall_icreate);
if (!afs_suser(NULL))
return (EPERM);
code = getinode(0, (dev_t) dev, 2, &ip, &dummy);
if (code) {
return (ENOENT);
}
code = ialloc(ip, (ino_t) near_inode, 0, &newip);
iput(ip);
if (code) {
return (code);
}
IN_LOCK(newip);
newip->i_flag |= IACC | IUPD | ICHG;
newip->i_nlink = 1;
newip->i_mode = IFREG;
IN_UNLOCK(newip);
vp = ITOV(newip);
VN_LOCK(vp);
vp->v_type = VREG;
VN_UNLOCK(vp);
/*
* if ( !vp->v_object)
* {
* extern struct vfs_ubcops ufs_ubcops;
* extern struct vm_ubc_object* ubc_object_allocate();
* struct vm_ubc_object* vop;
* vop = ubc_object_allocate(&vp, &ufs_ubcops,
* vp->v_mount->m_funnel);
* VN_LOCK(vp);
* vp->v_object = vop;
* VN_UNLOCK(vp);
* }
*/
IN_LOCK(newip);
/* newip->i_flags |= IC_XUID|IC_XGID; */
/* newip->i_flags &= ~IC_PROPLIST; */
newip->i_vicep1 = param1;
if (param2 == 0x1fffffff /*INODESPECIAL*/) {
newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3));
newip->i_vicep3a = (u_short) (param3 >> 16);
newip->i_vicep3b = (u_short) param3;
} else {
newip->i_vicep2 =
(((param2 >> 16) & 0x1f) << 27) +
(((param4 >> 16) & 0x1f) << 22) + (param3 & 0x3fffff);
newip->i_vicep3a = (u_short) param4;
newip->i_vicep3b = (u_short) param2;
}
newip->i_vicemagic = VICEMAGIC;
*retval = newip->i_number;
IN_UNLOCK(newip);
iput(newip);
return (code);
}
afs_syscall_iopen(dev, inode, usrmod, retval)
long *retval;
int dev, inode, usrmod;
{
struct file *fp;
struct inode *ip;
struct vnode *vp = NULL;
int dummy;
int fd;
extern struct fileops vnops;
register int code;
AFS_STATCNT(afs_syscall_iopen);
if (!afs_suser(NULL))
return (EPERM);
code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
if (code) {
return (code);
}
if ((code = falloc(curproc, &fp, &fd)) != 0) {
iput(ip);
return (code);
}
IN_UNLOCK(ip);
/* FreeBSD doesn't do much mp stuff yet :( */
/* FP_LOCK(fp); */
fp->f_flag = (usrmod) & FMASK;
fp->f_type = DTYPE_VNODE;
fp->f_ops = &vnops;
fp->f_data = (caddr_t) ITOV(ip);
/* FP_UNLOCK(fp); */
return (0);
}
/*
* Support for iinc() and idec() system calls--increment or decrement
* count on inode.
* Restricted to super user.
* Only VICEMAGIC type inodes.
*/
afs_syscall_iincdec(dev, inode, inode_p1, amount)
int dev, inode, inode_p1, amount;
{
int dummy;
struct inode *ip;
register int code;
if (!afs_suser(NULL))
return (EPERM);
code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
if (code) {
return (code);
}
if (!IS_VICEMAGIC(ip)) {
return (EPERM);
} else if (ip->i_vicep1 != inode_p1) {
return (ENXIO);
}
ip->i_nlink += amount;
if (ip->i_nlink == 0) {
CLEAR_VICEMAGIC(ip);
}
ip->i_flag |= ICHG;
iput(ip);
return (0);
}

70
src/afs/NBSD/osi_inode.h
View File

@ -1,70 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
* osi_inode.h
*
* Inode information required for NetBSD servers and salvager.
*/
#ifndef _OSI_INODE_H_
#define _OSI_INODE_H_
#define BAD_IGET -1000
#define VICEMAGIC 0xb61cfa84
#define DI_VICEP3(p) \
( ((u_int)((p)->di_vicep3a)) << 16 | ((u_int)((p)->di_vicep3b)) )
#define I_VICE3(p) \
( ((u_int)((p)->i_vicep3a)) << 16 | ((u_int)((p)->i_vicep3b)) )
#define FAKE_INODE_SIZE (sizeof(struct vnode)+sizeof(struct inode))
#define MOUNTLIST_UNLOCK() simple_lock_unlock(&mountlist_slock)
#define MOUNTLIST_LOCK() simple_lock(&mountlist_slock)
/* FreeBSD doesn't actually have a di_proplb, so we use di_spare[0] */
#define di_proplb di_spare[0]
/* For some reason, they're called "oldids" instead of "bc_{u,g}id" */
#define di_bcuid di_u.oldids[0]
#define di_bcgid di_u.oldids[1]
#define i_vicemagic i_din.di_spare[0]
#define i_vicep1 i_din.di_uid
#define i_vicep2 i_din.di_gid
#define i_vicep3a i_din.di_u.oldids[0]
#define i_vicep3b i_din.di_u.oldids[1]
#define i_vicep4 i_din.di_spare[1] /* not used */
#define di_vicemagic di_spare[0]
#define di_vicep1 di_uid
#define di_vicep2 di_gid
#define di_vicep3a di_u.oldids[0]
#define di_vicep3b di_u.oldids[1]
#define di_vicep4 di_spare[1] /* not used */
/*
* Macros for handling inode numbers:
* inode number to file system block offset.
* inode number to cylinder group number.
* inode number to file system block address.
*/
#define itoo(fs, x) ((x) % INOPB(fs))
#define itog(fs, x) ((x) / (fs)->fs_ipg)
#define itod(fs, x) \
((daddr_t)(cgimin(fs, itog(fs, x)) + \
(blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
#define IS_VICEMAGIC(ip) ((ip)->i_vicemagic == VICEMAGIC)
#define IS_DVICEMAGIC(dp) ((dp)->di_vicemagic == VICEMAGIC)
#define CLEAR_VICEMAGIC(ip) (ip)->i_vicemagic = 0
#define CLEAR_DVICEMAGIC(dp) (dp)->di_vicemagic = 0
#endif /* _OSI_INODE_H_ */

104
src/afs/NBSD/osi_machdep.h
View File

@ -1,104 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
*
* NetBSD OSI header file. Extends afs_osi.h.
*
* afs_osi.h includes this file, which is the only way this file should
* be included in a source file. This file can redefine macros declared in
* afs_osi.h.
*/
#ifndef _OSI_MACHDEP_H_
#define _OSI_MACHDEP_H_
#include <sys/lock.h>
/* #include <kern/sched_prim.h> */
/* #include <sys/unix_defs.h> */
#define getpid() curproc
/*
* Time related macros
*/
extern struct timeval time;
#define osi_Time() (time.tv_sec)
#define afs_hz hz
typedef struct ucred afs_ucred_t;
typedef struct proc afs_proc_t;
#define afs_bufferpages bufpages
#undef gop_lookupname
#define gop_lookupname(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp))
#undef gop_lookupname_user
#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp))
#define osi_vnhold(avc,r) do { \
if ((avc)->vrefCount) { VN_HOLD((struct vnode *)(avc)); } \
else osi_Panic("refcnt==0"); } while(0)
#define gop_rdwr(rw,gp,base,len,offset,segflg,unit,cred,aresid) \
vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(unit),(cred),(aresid), curproc)
#undef afs_suser
extern struct simplelock afs_global_lock;
#if 0
extern thread_t afs_global_owner;
#define AFS_GLOCK() \
do { \
usimple_lock(&afs_global_lock); \
osi_Assert(afs_global_owner == (thread_t)0); \
afs_global_owner = current_thread(); \
} while (0)
#define AFS_GUNLOCK() \
do { \
osi_Assert(afs_global_owner == current_thread()); \
afs_global_owner = (thread_t)0; \
usimple_unlock(&afs_global_lock); \
} while(0)
#define ISAFS_GLOCK() (afs_global_owner == current_thread())
#else
#define AFS_GLOCK() \
do { \
simple_lock(&afs_global_lock); \
} while (0)
#define AFS_GUNLOCK() \
do { \
simple_unlock(&afs_global_lock); \
} while(0)
#define osi_InitGlock() \
do { \
lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0); \
afs_global_owner = 0; \
} while (0)
#endif /* 0 */
#undef SPLVAR
#define SPLVAR
#undef NETPRI
#define NETPRI
#undef USERPRI
#define USERPRI
/* Vnode related macros */
extern int (**afs_vnodeop_p) ();
#define vType(vc) AFSTOV(vc)->v_type
#define vSetVfsp(vc, vfsp) AFSTOV(vc)->v_mount = (vfsp)
#define vSetType(vc, type) AFSTOV(vc)->v_type = (type)
#define IsAfsVnode(v) ((v)->v_op == afs_vnodeop_p)
#define SetAfsVnode(v) /* nothing; done in getnewvnode() */
#define osi_procname(procname, size) strncpy(procname, curproc->p_comm, size)
#endif /* _OSI_MACHDEP_H_ */

38
src/afs/NBSD/osi_misc.c
View File

@ -1,38 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
* osi_misc.c
*
* Implements:
* afs_suser
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
/*
* afs_suser() returns true if the caller is superuser, false otherwise.
*
* Note that it must NOT set errno.
*/
afs_suser(void *credp)
{
int error;
if (suser(curproc) == 0) {
return (1);
}
return (0);
}

199
src/afs/NBSD/osi_sleep.c
View File

@ -1,199 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* afs statistics */
static char waitV;
void
afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
{
AFS_STATCNT(osi_InitWaitHandle);
achandle->proc = (caddr_t) 0;
}
/* cancel osi_Wait */
void
afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
{
caddr_t proc;
AFS_STATCNT(osi_CancelWait);
proc = achandle->proc;
if (proc == 0)
return;
achandle->proc = (caddr_t) 0; /* so dude can figure out he was signalled */
afs_osi_Wakeup(&waitV);
}
/* afs_osi_Wait
* Waits for data on ahandle, or ams ms later. ahandle may be null.
* Returns 0 if timeout and EINTR if signalled.
*/
int
afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
{
int code;
afs_int32 endTime, tid;
AFS_STATCNT(osi_Wait);
endTime = osi_Time() + (ams / 1000);
if (ahandle)
ahandle->proc = (caddr_t) curproc;
do {
AFS_ASSERT_GLOCK();
code = 0;
code = afs_osi_TimedSleep(&waitV, ams, aintok);
if (code)
break; /* if something happened, quit now */
/* if we we're cancelled, quit now */
if (ahandle && (ahandle->proc == (caddr_t) 0)) {
/* we've been signalled */
break;
}
} while (osi_Time() < endTime);
return code;
}
typedef struct afs_event {
struct afs_event *next; /* next in hash chain */
char *event; /* lwp event: an address */
int refcount; /* Is it in use? */
int seq; /* Sequence number: this is incremented
* by wakeup calls; wait will not return until
* it changes */
int cond;
} afs_event_t;
#define HASHSIZE 128
afs_event_t *afs_evhasht[HASHSIZE]; /* Hash table for events */
#define afs_evhash(event) (afs_uint32) ((((long)event)>>2) & (HASHSIZE-1));
int afs_evhashcnt = 0;
/* Get and initialize event structure corresponding to lwp event (i.e. address)
* */
static afs_event_t *
afs_getevent(char *event)
{
afs_event_t *evp, *newp = 0;
int hashcode;
AFS_ASSERT_GLOCK();
hashcode = afs_evhash(event);
evp = afs_evhasht[hashcode];
while (evp) {
if (evp->event == event) {
evp->refcount++;
return evp;
}
if (evp->refcount == 0)
newp = evp;
evp = evp->next;
}
if (!newp) {
newp = (afs_event_t *) osi_AllocSmallSpace(sizeof(afs_event_t));
afs_evhashcnt++;
newp->next = afs_evhasht[hashcode];
afs_evhasht[hashcode] = newp;
newp->seq = 0;
}
newp->event = event;
newp->refcount = 1;
return newp;
}
/* Release the specified event */
#define relevent(evp) ((evp)->refcount--)
void
afs_osi_Sleep(void *event)
{
struct afs_event *evp;
int seq;
evp = afs_getevent(event);
seq = evp->seq;
while (seq == evp->seq) {
AFS_ASSERT_GLOCK();
assert_wait((vm_offset_t) (&evp->cond), 0);
AFS_GUNLOCK();
thread_block();
AFS_GLOCK();
}
relevent(evp);
}
int
afs_osi_SleepSig(void *event)
{
afs_osi_Sleep(event);
return 0;
}
/* afs_osi_TimedSleep
*
* Arguments:
* event - event to sleep on
* ams --- max sleep time in milliseconds
* aintok - 1 if should sleep interruptibly
*
* Returns 0 if timeout and EINTR if signalled.
*/
int
afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
{
int code = 0;
struct afs_event *evp;
int ticks;
ticks = (ams * afs_hz) / 1000;
evp = afs_getevent(event);
assert_wait((vm_offset_t) (&evp->cond), aintok);
AFS_GUNLOCK();
thread_set_timeout(ticks);
thread_block();
AFS_GLOCK();
/* if (current_thread()->wait_result != THREAD_AWAKENED)
* code = EINTR; */
relevent(evp);
return code;
}
int
afs_osi_Wakeup(void *event)
{
int ret = 1;
struct afs_event *evp;
evp = afs_getevent(event);
if (evp->refcount > 1) {
evp->seq++;
thread_wakeup((vm_offset_t) (&evp->cond));
ret = 0;
}
relevent(evp);
return ret;
}

498
src/afs/NBSD/osi_vfsops.c
View File

@ -1,498 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/*
* osi_vfsops.c for NetBSD
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* statistics stuff */
#include <sys/types.h>
#include <kern/mach_param.h>
#include <sys/sysconfig.h>
#include <sys/systm.h>
#include <sys/resource.h>
#include <sys/errno.h>
#include <sys/conf.h>
#include <machine/machlimits.h>
struct vcache *afs_globalVp = 0;
struct mount *afs_globalVFS = 0;
static u_char afs_mntid;
int afs_vfsdev = 0;
udecl_simple_lock_data(, afsmntid_lock)
#define AFSMNTID_LOCK() usimple_lock(&afsmntid_lock)
#define AFSMNTID_UNLOCK() usimple_unlock(&afsmntid_lock)
#define AFSMNTID_LOCK_INIT() usimple_lock_init(&afsmntid_lock)
int mp_afs_mount(struct mount *afsp, char *path, caddr_t data,
struct nameidata *ndp)
{
u_int size;
fsid_t tfsid;
struct mount *xmp, *getvfs();
int code;
AFS_GLOCK();
AFS_STATCNT(afs_mount);
if (afs_globalVFS) { /* Don't allow remounts. */
AFS_GUNLOCK();
return (EBUSY);
}
afs_globalVFS = afsp;
afsp->vfs_bsize = 8192;
/*
* Generate a unique afs mount i.d. ( see nfs_mount() ).
*/
afsp->m_stat.f_fsid.val[0] = makedev(130, 0);
afsp->m_stat.f_fsid.val[1] = MOUNT_AFS;
AFSMNTID_LOCK();
if (++afs_mntid == 0)
++afs_mntid;
AFSMNTID_UNLOCK();
BM(AFSMNTID_LOCK());
tfsid.val[0] = makedev(130, afs_mntid);
tfsid.val[1] = MOUNT_AFS;
BM(AFSMNTID_UNLOCK());
while (xmp = getvfs(&tfsid)) {
UNMOUNT_READ_UNLOCK(xmp);
tfsid.val[0]++;
AFSMNTID_LOCK();
afs_mntid++;
AFSMNTID_UNLOCK();
}
if (major(tfsid.val[0]) != 130) {
AFS_GUNLOCK();
return (ENOENT);
}
afsp->m_stat.f_fsid.val[0] = tfsid.val[0];
afsp->m_stat.f_mntonname = AFS_KALLOC(MNAMELEN);
afsp->m_stat.f_mntfromname = AFS_KALLOC(MNAMELEN);
if (!afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
panic("malloc failure in afs_mount\n");
memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
AFS_COPYINSTR(path, (caddr_t) afsp->m_stat.f_mntonname, MNAMELEN, &size,
code);
memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
AFS_GUNLOCK();
(void)mp_afs_statfs(afsp);
AFS_GLOCK();
afs_vfsdev = afsp->m_stat.f_fsid.val[0];
#ifndef AFS_NONFSTRANS
/* Set up the xlator in case it wasn't done elsewhere */
afs_xlatorinit_v2();
afs_xlatorinit_v3();
#endif
AFS_GUNLOCK();
return 0;
}
int
mp_afs_unmount(struct mount *afsp, int flag)
{
AFS_GLOCK();
AFS_STATCNT(afs_unmount);
afs_globalVFS = 0;
afs_shutdown();
AFS_GUNLOCK();
return 0;
}
int
mp_afs_start(struct mount *mp, int flags)
{
return (0);
}
int
mp_afs_root(struct mount *afsp, struct vnode **avpp)
{
register afs_int32 code = 0;
struct vrequest treq;
register struct vcache *tvp = 0;
AFS_GLOCK();
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
tvp = afs_globalVp;
} else {
if (afs_globalVp) {
afs_PutVCache(afs_globalVp);
afs_globalVp = NULL;
}
if (!(code = afs_InitReq(&treq, cred)) && !(code = afs_CheckInit())) {
tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
/* we really want this to stay around */
if (tvp) {
afs_globalVp = tvp;
} else
code = ENOENT;
}
}
if (tvp) {
AFS_GUNLOCK();
VN_HOLD((struct vnode *)tvp);
VN_LOCK((struct vnode *)tvp);
tvp->v.v_flag |= VROOT; /* No-op on Ultrix 2.2 */
VN_UNLOCK((struct vnode *)tvp);
AFS_GLOCK();
afs_globalVFS = afsp;
*avpp = (struct vnode *)tvp;
}
afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
ICL_TYPE_INT32, code);
AFS_GUNLOCK();
return code;
}
mp_afs_quotactl(struct mount * mp, int cmd, uid_t uid, caddr_t arg)
{
return EOPNOTSUPP;
}
int
mp_afs_statfs(struct mount *afsp)
{
struct nstatfs *abp = &afsp->m_stat;
AFS_GLOCK();
AFS_STATCNT(afs_statfs);
abp->f_type = MOUNT_AFS;
abp->f_bsize = afsp->vfs_bsize;
/* Fake a high number below to satisfy programs that use the statfs call
* to make sure that there's enough space in the device partition before
* storing something there.
*/
abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
abp->f_ffree = 2000000;
abp->f_fsize = 1024;
abp->f_fsid.val[0] = afsp->m_stat.f_fsid.val[0];
abp->f_fsid.val[1] = afsp->m_stat.f_fsid.val[1];
AFS_GUNLOCK();
return 0;
}
int
mp_afs_sync(struct mount *mp, int flags)
{
AFS_STATCNT(afs_sync);
return 0;
}
int
mp_afs_fhtovp(struct mount *afsp, struct fid *fidp, struct vnode **avcp)
{
struct vrequest treq;
register code = 0;
AFS_GLOCK();
AFS_STATCNT(afs_vget);
*avcp = NULL;
if ((code = afs_InitReq(&treq, cred)) == 0) {
code = afs_osi_vget((struct vcache **)avcp, fidp, &treq);
}
afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp,
ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, fidp);
code = afs_CheckCode(code, &treq, 42);
AFS_GUNLOCK();
return code;
}
/*
* afs_vptofh
*
* afs_vptofh can return two flavors of NFS fid, depending on if submounts are
* allowed. The reason for this is that we can't guarantee that we found all
* the entry points any OS might use to get the fid for the NFS mountd.
* Hence we return a "magic" fid for all but /afs. If it goes through the
* translator code, it will get transformed into a SmallFid that we recognize.
* So, if submounts are disallowed, and an NFS client tries a submount, it will
* get a fid which we don't recognize and the mount will either fail or we
* will ignore subsequent requests for that mount.
*
* The Alpha fid is organized differently than for other platforms. Their
* intention was to have the data portion of the fid aligned on a 4 byte
* boundary. To do so, the fid is organized as:
* u_short reserved
* u_short len
* char data[8]
* The len field is the length of the entire fid, from reserved through data.
* This length is used by fid_copy to include copying the reserved field.
* Alpha's zero the reserved field before handing us the fid, but they use
* it in fid_cmp. We use the reserved field to store the 16 bits of the Vnode.
*
* Note that the SmallFid only allows for 8 bits of the cell index and
* 16 bits of the vnode.
*/
#define AFS_FIDDATASIZE 8
#define AFS_SIZEOFSMALLFID 12 /* full size of fid, including len field */
extern int afs_NFSRootOnly; /* 1 => only allow NFS mounts of /afs. */
int afs_fid_vnodeoverflow = 0, afs_fid_uniqueoverflow = 0;
int
mp_afs_vptofh(struct vnode *avn, struct fid *fidp)
{
struct SmallFid Sfid;
long addr[2];
register struct cell *tcell;
int rootvp = 0;
struct vcache *avc = VTOAFS(avn);
AFS_GLOCK();
AFS_STATCNT(afs_fid);
if (afs_shuttingdown) {
AFS_GUNLOCK();
return EIO;
}
if (afs_NFSRootOnly && (avc == afs_globalVp))
rootvp = 1;
if (!afs_NFSRootOnly || rootvp) {
tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);
Sfid.Volume = avc->f.fid.Fid.Volume;
fidp->fid_reserved = avc->f.fid.Fid.Vnode;
Sfid.CellAndUnique =
((tcell->cellIndex << 24) + (avc->f.fid.Fid.Unique & 0xffffff));
afs_PutCell(tcell, READ_LOCK);
if (avc->f.fid.Fid.Vnode > 0xffff)
afs_fid_vnodeoverflow++;
if (avc->f.fid.Fid.Unique > 0xffffff)
afs_fid_uniqueoverflow++;
} else {
fidp->fid_reserved = AFS_XLATOR_MAGIC;
addr[0] = (long)avc;
AFS_GUNLOCK();
VN_HOLD((struct vnode *)avc);
AFS_GLOCK();
}
/* Use the fid pointer passed to us. */
fidp->fid_len = AFS_SIZEOFSMALLFID;
if (afs_NFSRootOnly) {
if (rootvp) {
memcpy(fidp->fid_data, (caddr_t) & Sfid, AFS_FIDDATASIZE);
} else {
memcpy(fidp->fid_data, (caddr_t) addr, AFS_FIDDATASIZE);
}
} else {
memcpy(fidp->fid_data, (caddr_t) & Sfid, AFS_FIDDATASIZE);
}
AFS_GUNLOCK();
return 0;
}
int mp_Afs_init(void); /* vfs_init - defined below */
/* This is only called by vfs_mount when afs is going to be mounted as root.
* Since we don't support diskless clients we shouldn't come here.
*/
int afsmountroot = 0;
int
mp_afs_mountroot(struct mount *afsp, struct vnode **vp)
{
AFS_GLOCK();
AFS_STATCNT(afs_mountroot);
afsmountroot++;
AFS_GUNLOCK();
return EINVAL;
}
/* It's called to setup swapping over the net for diskless clients; again
* not for us.
*/
int afsswapvp = 0;
int
mp_afs_swapvp(void)
{
AFS_GLOCK();
AFS_STATCNT(afs_swapvp);
afsswapvp++;
AFS_GUNLOCK();
return EINVAL;
}
struct vfsops afs_vfsops = {
mp_afs_mount,
mp_afs_start,
mp_afs_unmount,
mp_afs_root,
mp_afs_quotactl,
mp_afs_statfs,
mp_afs_sync,
mp_afs_fhtovp, /* afs_vget */
mp_afs_vptofh,
mp_Afs_init,
mp_afs_mountroot,
mp_afs_swapvp
};
/*
* System Call Entry Points
*/
#define NULL_FUNC (int (*)(int))0
int (*afs_syscall_func) () = NULL_FUNC;
int (*afs_xsetgroups_func) () = NULL_FUNC;
int (*afs_xioctl_func) () = NULL_FUNC;
afssyscall(p, args, retval)
struct proc *p;
void *args;
long *retval;
{
int (*func) ();
int code;
AFS_GLOCK();
func = afs_syscall_func;
if (func == NULL_FUNC) {
code = nosys(p, args, retval);
} else {
code = (*func) (p, args, retval);
}
AFS_GUNLOCK();
return code;
}
afsxsetgroups(p, args, retval)
struct proc *p;
void *args;
long *retval;
{
int (*func) ();
int code;
AFS_GLOCK();
func = afs_xsetgroups_func;
if (func == NULL_FUNC) {
code = nosys(p, args, retval);
} else {
code = (*func) (p, args, retval);
}
AFS_GUNLOCK();
return code;
}
afsxioctl(p, args, retval)
struct proc *p;
void *args;
long *retval;
{
int (*func) ();
int code;
AFS_GLOCK();
func = afs_xioctl_func;
if (func == NULL_FUNC) {
code = nosys(p, args, retval);
} else {
code = (*func) (p, args, retval);
}
AFS_GUNLOCK();
return code;
}
/*
* VFS initialization and unload
*/
afs_unconfig()
{
return EBUSY;
}
cfg_subsys_attr_t afs_attributes[] = {
{"", 0, 0, 0, 0, 0, 0} /* must be the last element */
};
afs_configure(cfg_op_t op, caddr_t indata, size_t indata_size,
caddr_t outdata, size_t outdata_size)
{
cfg_attr_t *attributes;
int ret = ESUCCESS;
int i, j, size;
caddr_t p;
switch (op) {
case CFG_OP_CONFIGURE:
/*
* The indata parameter is a list of attributes to be configured, and
* indata_size is the count of attributes.
*/
if ((ret = vfssw_add_fsname(MOUNT_AFS, &afs_vfsops, "afs")) != 0)
return (ret);
break;
case CFG_OP_UNCONFIGURE:
if ((ret = afs_unconfig()) != 0)
return (ret);
break;
default:
ret = EINVAL;
break;
}
return ret;
}
int
mp_Afs_init(void)
{
extern int Afs_xsetgroups(), afs_xioctl();
AFS_GLOCK();
sysent[AFS_SYSCALL].sy_call = afs3_syscall;
sysent[AFS_SYSCALL].sy_parallel = 0;
sysent[AFS_SYSCALL].sy_narg = 6;
sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
afs_xioctl_func = afsxioctl;
afs_xsetgroups_func = afsxsetgroups;
afs_syscall_func = afssyscall;
AFS_GUNLOCK();
return 0;
}

202
src/afs/NBSD/osi_vm.c
View File

@ -1,202 +0,0 @@
/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
/* osi_vm.c implements:
*
* osi_VM_FlushVCache(avc, slept)
* osi_ubc_flush_dirty_and_wait(vp, flags)
* osi_VM_StoreAllSegments(avc)
* osi_VM_TryToSmush(avc, acred, sync)
* osi_VM_FlushPages(avc, credp)
* osi_VM_Truncate(avc, alen, acred)
*/
#include <afsconfig.h>
#include "afs/param.h"
#include "afs/sysincludes.h" /* Standard vendor system headers */
#include "afsincludes.h" /* Afs-based standard headers */
#include "afs/afs_stats.h" /* statistics */
/* #include <vm/vm_ubc.h> */
#include <limits.h>
#include <float.h>
/* Try to discard pages, in order to recycle a vcache entry.
*
* We also make some sanity checks: ref count, open count, held locks.
*
* We also do some non-VM-related chores, such as releasing the cred pointer
* (for AIX and Solaris) and releasing the gnode (for AIX).
*
* Locking: afs_xvcache lock is held. If it is dropped and re-acquired,
* *slept should be set to warn the caller.
*
* Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it
* is not dropped and re-acquired for any platform. It may be that *slept is
* therefore obsolescent.
*
* OSF/1 Locking: VN_LOCK has been called.
*/
int
osi_VM_FlushVCache(struct vcache *avc, int *slept)
{
#ifdef SECRETLY_OSF1
if (avc->vrefCount > 1)
return EBUSY;
if (avc->opens)
return EBUSY;
/* if a lock is held, give up */
if (CheckLock(&avc->lock))
return EBUSY;
AFS_GUNLOCK();
ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
AFS_GLOCK();
#endif /* SECRETLY_OSF1 */
return 0;
}
/*
* osi_ubc_flush_dirty_and_wait -- ensure all dirty pages cleaned
*
* Alpha OSF/1 doesn't make it easy to wait for all dirty pages to be cleaned.
* NFS tries to do this by calling waitforio(), which waits for v_numoutput
* to go to zero. But that isn't good enough, because afs_putpage() doesn't
* increment v_numoutput until it has obtained the vcache entry lock. Suppose
* that Process A, trying to flush a page, is waiting for that lock, and
* Process B tries to close the file. Process B calls waitforio() which thinks
* that everything is cool because v_numoutput is still zero. Process B then
* proceeds to call afs_StoreAllSegments(). Finally when B is finished, A gets
* to proceed and flush its page. But then it's too late because the file is
* already closed.
*
* (I suspect that waitforio() is not adequate for NFS, just as it isn't
* adequate for us. But that's not my problem.)
*
* The only way we can be sure that there are no more dirty pages is if there
* are no more pages with pg_busy set. We look for them on the cleanpl.
*
* For some reason, ubc_flush_dirty() only looks at the dirtypl, not the
* dirtywpl. I don't know why this is good enough, but I assume it is. By
* the same token, I only look for busy pages on the cleanpl, not the cleanwpl.
*
* Called with the global lock NOT held.
*/
static void
osi_ubc_flush_dirty_and_wait(struct vnode *vp, int flags)
{
int retry;
vm_page_t pp;
int first;
#ifdef SECRETLY_OSF1
do {
struct vm_ubc_object *vop;
vop = (struct vm_ubc_object *)(vp->v_object);
ubc_flush_dirty(vop, flags);
vm_object_lock(vop);
if (vop->vu_dirtypl)
/* shouldn't happen, but who knows */
retry = 1;
else {
retry = 0;
if (vop->vu_cleanpl) {
for (first = 1, pp = vop->vu_cleanpl;
first || pp != vop->vu_cleanpl;
first = 0, pp = pp->pg_onext) {
if (pp->pg_busy) {
retry = 1;
pp->pg_wait = 1;
assert_wait_mesg((vm_offset_t) pp, FALSE, "pg_wait");
vm_object_unlock(vop);
thread_block();
break;
}
}
}
if (retry)
continue;
}
vm_object_unlock(vop);
} while (retry);
#endif /* SECRETLY_OSF1 */
}
/* Try to store pages to cache, in order to store a file back to the server.
*
* Locking: the vcache entry's lock is held. It will usually be dropped and
* re-obtained.
*/
void
osi_VM_StoreAllSegments(struct vcache *avc)
{
#ifdef SECRETLY_OSF1
ReleaseWriteLock(&avc->lock);
AFS_GUNLOCK();
osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0);
AFS_GLOCK();
ObtainWriteLock(&avc->lock, 94);
#endif /* SECRETLY_OSF1 */
}
/* Try to invalidate pages, for "fs flush" or "fs flushv"; or
* try to free pages, when deleting a file.
*
* Locking: the vcache entry's lock is held. It may be dropped and
* re-obtained.
*
* Since we drop and re-obtain the lock, we can't guarantee that there won't
* be some pages around when we return, newly created by concurrent activity.
*/
void
osi_VM_TryToSmush(struct vcache *avc, afs_ucred_t *acred, int sync)
{
#ifdef SECRETLY_OSF1
ReleaseWriteLock(&avc->lock);
AFS_GUNLOCK();
osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0);
ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
AFS_GLOCK();
ObtainWriteLock(&avc->lock, 59);
#endif /* SECRETLY_OSF1 */
}
/* Purge VM for a file when its callback is revoked.
*
* Locking: No lock is held, not even the global lock.
*/
void
osi_VM_FlushPages(struct vcache *avc, afs_ucred_t *credp)
{
#ifdef SECRETLY_OSF1
ubc_flush_dirty(((struct vnode *)avc)->v_object, 0);
ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
#endif /* SECRETLY_OSF1 */
}
/* Purge pages beyond end-of-file, when truncating a file.
*
* Locking: no lock is held, not even the global lock.
* activeV is raised. This is supposed to block pageins, but at present
* it only works on Solaris.
*/
void
osi_VM_Truncate(struct vcache *avc, int alen, afs_ucred_t *acred)
{
#ifdef SECRETLY_OSF1
ubc_invalidate(((struct vnode *)avc)->v_object, alen, MAXINT - alen,
B_INVAL);
#endif /* SECRETLY_OSF1 */
}

1098
src/afs/NBSD/osi_vnodeops.c
View File

File diff suppressed because it is too large Load Diff

0
src/afs/NBSD/placeholder Normal file
View File