940 lines
18 KiB
C
940 lines
18 KiB
C
/*
|
|
* Copyright (c) 1994 Christian E. Hopps
|
|
* 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 Christian E. Hopps.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
|
*
|
|
* $Id: advnops.c,v 1.5 1994/06/02 23:42:50 chopps Exp $
|
|
*/
|
|
#include <sys/param.h>
|
|
#include <sys/vnode.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/time.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/namei.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/dirent.h>
|
|
#include <sys/stat.h>
|
|
#include <miscfs/specfs/specdev.h>
|
|
#include <adosfs/adosfs.h>
|
|
|
|
extern struct vnodeops adosfs_vnodeops;
|
|
|
|
int
|
|
adosfs_open(vp, mod, ucp, p)
|
|
struct vnode *vp;
|
|
int mod;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(open [0x%x %d 0x%x 0x%x] 0)", vp, mod, ucp, p);
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
int
|
|
adosfs_close(vp, fflag, ucp, p)
|
|
struct vnode *vp;
|
|
int fflag;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(close [0x%x %d 0x%x 0x%x] 0)", vp, fflag, ucp, p);
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
int
|
|
adosfs_create(ndp, vap, p)
|
|
struct nameidata *ndp;
|
|
struct vattr *vap;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(create EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
int
|
|
adosfs_remove(ndp, p)
|
|
struct nameidata *ndp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(remove EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
int
|
|
adosfs_getattr(vp, vap, ucp, p)
|
|
struct vnode *vp;
|
|
struct vattr *vap;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
struct amount *amp;
|
|
struct anode *ap;
|
|
u_long fblks;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(getattr [0x%x 0x%x 0x%x 0x%x] ", vp, vap, ucp, p);
|
|
#endif
|
|
ap = VTOA(vp);
|
|
amp = ap->amp;
|
|
vattr_null(vap);
|
|
vap->va_uid = amp->uid;
|
|
vap->va_gid = amp->gid;
|
|
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
|
|
microtime(&vap->va_atime);
|
|
vap->va_mtime = vap->va_atime;
|
|
vap->va_ctime = vap->va_ctime;
|
|
vap->va_gen = 0;
|
|
vap->va_flags = 0;
|
|
vap->va_rdev = NODEV;
|
|
vap->va_fileid = ap->block;
|
|
vap->va_type = vp->v_type;
|
|
vap->va_mode = amp->mask & adunixprot(ap->adprot);
|
|
if (vp->v_type == VDIR) {
|
|
vap->va_nlink = 1; /* XXX bogus, oh well */
|
|
vap->va_bytes = amp->bsize;
|
|
vap->va_size = amp->bsize;
|
|
} else {
|
|
/*
|
|
* XXX actually we can track this if we were to walk the list
|
|
* of links if it exists.
|
|
*/
|
|
vap->va_nlink = 1;
|
|
/*
|
|
* round up to nearest blocks add number of file list
|
|
* blocks needed and mutiply by number of bytes per block.
|
|
*/
|
|
fblks = howmany(ap->fsize, amp->bsize);
|
|
fblks += howmany(fblks, ANODENDATBLKENT(ap));
|
|
vap->va_bytes = fblks * amp->bsize;
|
|
vap->va_size = ap->fsize;
|
|
}
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
/*
|
|
* are things locked??? they need to be to avoid this being
|
|
* deleted or changed (data block pointer blocks moving about.)
|
|
*/
|
|
int
|
|
adosfs_read(vp, uio, ioflag, ucp)
|
|
struct vnode *vp;
|
|
struct uio *uio;
|
|
int ioflag;
|
|
struct ucred *ucp;
|
|
{
|
|
struct anode *ap;
|
|
struct amount *amp;
|
|
struct fs *fs;
|
|
struct buf *bp;
|
|
daddr_t lbn, bn;
|
|
int size, diff, error;
|
|
long n, on;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(read [0x%x 0x%x %d 0x %x]", vp, uio, ioflag, ucp);
|
|
#endif
|
|
error = 0;
|
|
ap = VTOA(vp);
|
|
amp = ap->amp;
|
|
/*
|
|
* Return EOF for character devices, EIO for others
|
|
*/
|
|
if (vp->v_type != VREG) {
|
|
error = EIO;
|
|
goto reterr;
|
|
}
|
|
if (uio->uio_resid == 0)
|
|
goto reterr;
|
|
if (uio->uio_offset < 0) {
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
|
|
/*
|
|
* to expensive to let general algorithm figure out that
|
|
* we are beyond the file. Do it now.
|
|
*/
|
|
if (uio->uio_offset >= ap->fsize)
|
|
goto reterr;
|
|
|
|
/*
|
|
* taken from ufs_read()
|
|
*/
|
|
do {
|
|
/*
|
|
* we are only supporting ADosFFS currently
|
|
* (which have data blocks of 512 bytes)
|
|
*/
|
|
size = amp->bsize;
|
|
lbn = uio->uio_offset / size;
|
|
on = uio->uio_offset % size;
|
|
n = min((u_int)(size - on), uio->uio_resid);
|
|
diff = ap->fsize - uio->uio_offset;
|
|
/*
|
|
* check for EOF
|
|
*/
|
|
if (diff <= 0)
|
|
return(0);
|
|
if (diff < n)
|
|
n = diff;
|
|
/*
|
|
* read ahead could possibly be worth something
|
|
* but not much as ados makes little attempt to
|
|
* make things contigous
|
|
*/
|
|
error = bread(vp, lbn, size, NOCRED, &bp);
|
|
vp->v_lastr = lbn;
|
|
n = min(n, (u_int)size - bp->b_resid);
|
|
if (error) {
|
|
brelse(bp);
|
|
goto reterr;
|
|
}
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d+%d-%d+%d", lbn, on, lbn, n);
|
|
#endif
|
|
error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
|
|
brelse(bp);
|
|
} while (error == 0 && uio->uio_resid > 0 && n != 0);
|
|
reterr:
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
int
|
|
adosfs_write(vp, uio, ioflag, ucp)
|
|
register struct vnode *vp;
|
|
struct uio *uio;
|
|
int ioflag;
|
|
struct ucred *ucp;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(write EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*
|
|
* Device ioctl operation.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
adosfs_ioctl(vp, com, data, fflag, ucp, p)
|
|
struct vnode *vp;
|
|
register int com;
|
|
caddr_t data;
|
|
int fflag;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(ioctl ENOTTY)");
|
|
#endif
|
|
return(ENOTTY);
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
int
|
|
adosfs_select(vp, which, fflags, ucp, p)
|
|
struct vnode *vp;
|
|
int which, fflags;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
/*
|
|
* sure there's something to read...
|
|
*/
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(select [0x%x %d 0x%x 0x%x 0x%x] 1)", vp, which, fflags, ucp,
|
|
p);
|
|
#endif
|
|
return(1);
|
|
}
|
|
|
|
/*
|
|
* Just call the device strategy routine
|
|
*/
|
|
int
|
|
adosfs_strategy(bp)
|
|
struct buf *bp;
|
|
{
|
|
struct anode *ap;
|
|
struct vnode *vp;
|
|
int error;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(strategy [0x%x]", bp);
|
|
#endif
|
|
error = 0;
|
|
if (bp->b_vp == NULL) {
|
|
bp->b_flags |= B_ERROR;
|
|
biodone(bp);
|
|
error = EIO;
|
|
goto reterr;
|
|
}
|
|
if ((long)bp->b_blkno == -1) {
|
|
biodone(bp);
|
|
goto reterr;
|
|
}
|
|
vp = bp->b_vp;
|
|
ap = VTOA(vp);
|
|
if (bp->b_blkno == bp->b_lblkno)
|
|
if (error = adosfs_bmap(vp, bp->b_lblkno,NULL, &bp->b_blkno)) {
|
|
bp->b_flags |= B_ERROR;
|
|
biodone(bp);
|
|
goto reterr;
|
|
}
|
|
vp = ap->amp->devvp;
|
|
bp->b_dev = vp->v_rdev;
|
|
(*(vp->v_op->vop_strategy))(bp);
|
|
reterr:
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
/*
|
|
* lock the vnode
|
|
*/
|
|
int
|
|
adosfs_lock(vp)
|
|
struct vnode *vp;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(lock [0x%x]", vp);
|
|
#endif
|
|
ALOCK(VTOA(vp));
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
int
|
|
adosfs_unlock(vp)
|
|
struct vnode *vp;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(unlock [0x%x]", vp);
|
|
#endif
|
|
AUNLOCK(VTOA(vp));
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* Wait until the vnode has finished changing state.
|
|
*/
|
|
int
|
|
adosfs_bmap(vp, bn, vpp, bnp)
|
|
struct vnode *vp;
|
|
daddr_t bn;
|
|
struct vnode **vpp;
|
|
daddr_t *bnp;
|
|
{
|
|
struct anode *ap;
|
|
struct buf *flbp;
|
|
long nb, flblk, flblkoff;
|
|
int error;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(bmap [0x%x %d 0x%x 0x%x]", vp, bn, vpp, bnp);
|
|
#endif
|
|
|
|
error = 0;
|
|
ap = VTOA(vp);
|
|
|
|
if (bn < 0) {
|
|
error = EFBIG;
|
|
goto reterr;
|
|
}
|
|
if (vpp != NULL)
|
|
*vpp = ap->amp->devvp;
|
|
if (bnp == NULL)
|
|
goto reterr;
|
|
if (vp->v_type != VREG) {
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
|
|
/*
|
|
* walk the chain of file list blocks until we find
|
|
* the one that will yield the block pointer we need.
|
|
*/
|
|
if (ap->type == AFILE)
|
|
nb = ap->block; /* pointer to ourself */
|
|
else if (ap->type == ALFILE)
|
|
nb = ap->linkto; /* pointer to real file */
|
|
else {
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
|
|
flblk = bn / ANODENDATBLKENT(ap);
|
|
flbp = NULL;
|
|
while (flblk >= 0) {
|
|
if (flbp)
|
|
brelse(flbp);
|
|
if (nb == 0) {
|
|
#ifdef DIAGNOSTIC
|
|
printf("adosfs: bad file list chain.\n");
|
|
#endif
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
if (error = bread(ap->amp->devvp, nb, ap->amp->bsize,
|
|
NOCRED, &flbp))
|
|
goto reterr;
|
|
if (adoscksum(flbp, ap->nwords)) {
|
|
#ifdef DIAGNOSTIC
|
|
printf("adosfs: blk %d failed cksum.\n", nb);
|
|
#endif
|
|
brelse(flbp);
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
nb = adoswordn(flbp, ap->nwords - 2);
|
|
flblk--;
|
|
}
|
|
/*
|
|
* calculate offset of block number in table. The table starts
|
|
* at nwords - 51 and goes to offset 6 or less if indicated by the
|
|
* valid table entries stored at offset ADBI_NBLKTABENT.
|
|
*/
|
|
flblkoff = bn % ANODENDATBLKENT(ap);
|
|
if (flblkoff < adoswordn(flbp, 2 /* ADBI_NBLKTABENT */)) {
|
|
flblkoff = (ap->nwords - 51) - flblkoff;
|
|
*bnp = adoswordn(flbp, flblkoff);
|
|
} else {
|
|
#ifdef DIAGNOSTIC
|
|
printf("flblk offset %d too large in lblk %d blk %d\n",
|
|
flblkoff, bn, flbp->b_blkno);
|
|
#endif
|
|
error = EINVAL;
|
|
}
|
|
brelse(flbp);
|
|
reterr:
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
if (error == 0 && bnp)
|
|
printf(" %d => %d", bn, *bnp);
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
/*
|
|
* Print out the contents of a adosfs vnode.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
adosfs_print(vp)
|
|
struct vnode *vp;
|
|
{
|
|
printf("print 0x%x\n", vp);
|
|
return(0);
|
|
}
|
|
|
|
struct adirent {
|
|
u_long fileno;
|
|
u_short reclen;
|
|
u_short namlen;
|
|
char name[32]; /* maxlen of 30 plus 2 NUL's */
|
|
};
|
|
|
|
int
|
|
adosfs_readdir(pvp, uio, ucp, eofp, cookies, ncookies)
|
|
struct vnode *pvp;
|
|
struct uio *uio;
|
|
struct ucred *ucp;
|
|
int *eofp, ncookies;
|
|
u_int *cookies;
|
|
{
|
|
int error, useri, chainc, hashi, scanned, uavail;
|
|
struct adirent ad, *adp;
|
|
struct anode *pap, *ap;
|
|
struct amount *amp;
|
|
u_long nextbn, resid;
|
|
off_t uoff;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(readdir [0x%x 0x%x 0x%x 0x%x 0x%x %d]", pvp, uio, ucp, eofp,
|
|
cookies, ncookies);
|
|
#endif
|
|
if (pvp->v_type != VDIR) {
|
|
error = ENOTDIR;
|
|
goto reterr;
|
|
}
|
|
|
|
uoff = uio->uio_offset;
|
|
if (uoff < 0) {
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
|
|
pap = VTOA(pvp);
|
|
amp = pap->amp;
|
|
adp = &ad;
|
|
error = nextbn = hashi = chainc = scanned = 0;
|
|
uavail = uio->uio_resid / sizeof(ad);
|
|
useri = uoff / sizeof(ad);
|
|
|
|
/*
|
|
* if no slots available or offset requested is not on a slot boundry
|
|
*/
|
|
if (uavail < 1 || uoff % sizeof(ad)) {
|
|
error = EINVAL;
|
|
goto reterr;
|
|
}
|
|
|
|
while (uavail && (cookies == NULL || ncookies > 0)) {
|
|
if (hashi == pap->ntabent) {
|
|
*eofp = 1;
|
|
break;
|
|
}
|
|
if (pap->tab[hashi] == 0) {
|
|
hashi++;
|
|
continue;
|
|
}
|
|
if (nextbn == 0)
|
|
nextbn = pap->tab[hashi];
|
|
|
|
/*
|
|
* first determine if we can skip this chain
|
|
*/
|
|
if (chainc == 0) {
|
|
int skip;
|
|
|
|
skip = useri - scanned;
|
|
if (pap->tabi[hashi] > 0 && pap->tabi[hashi] <= skip) {
|
|
scanned += pap->tabi[hashi];
|
|
hashi++;
|
|
nextbn = 0;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* now [continue to] walk the chain
|
|
*/
|
|
ap = NULL;
|
|
do {
|
|
if (error = aget(amp->mp, nextbn, &ap))
|
|
goto reterr;
|
|
scanned++;
|
|
chainc++;
|
|
nextbn = ap->hashf;
|
|
|
|
/*
|
|
* check for end of chain.
|
|
*/
|
|
if (nextbn == 0) {
|
|
pap->tabi[hashi] = chainc;
|
|
hashi++;
|
|
chainc = 0;
|
|
} else if (pap->tabi[hashi] <= 0 &&
|
|
-chainc < pap->tabi[hashi])
|
|
pap->tabi[hashi] = -chainc;
|
|
|
|
if (useri >= scanned) {
|
|
aput(ap);
|
|
ap = NULL;
|
|
}
|
|
} while (ap == NULL && nextbn != 0);
|
|
|
|
/*
|
|
* we left the loop but without a result so do main over.
|
|
*/
|
|
if (ap == NULL)
|
|
continue;
|
|
/*
|
|
* Fill in dirent record
|
|
*/
|
|
bzero(adp, sizeof(struct adirent));
|
|
adp->fileno = ap->block;
|
|
adp->reclen = sizeof(struct adirent);
|
|
adp->namlen = strlen(ap->name);
|
|
bcopy(ap->name, adp->name, adp->namlen);
|
|
aput(ap);
|
|
|
|
error = uiomove(adp, sizeof(struct adirent), uio);
|
|
if (error)
|
|
break;
|
|
if (cookies) {
|
|
*cookies++ = uoff;
|
|
ncookies--;
|
|
}
|
|
uoff += sizeof(struct adirent);
|
|
useri++;
|
|
uavail--;
|
|
}
|
|
#if doesnt_uiomove_handle_this
|
|
uio->uio_offset = uoff;
|
|
#endif
|
|
reterr:
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_mknod(ndp, vap, ucp, p)
|
|
struct nameidata *ndp;
|
|
struct vattr *vap;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(mknod EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_access(vp, mode, ucp, p)
|
|
struct vnode *vp;
|
|
int mode;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
struct anode *ap;
|
|
gid_t *gp;
|
|
int i, error;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(access [0x%x %d 0x%x 0x%x]", vp, mode, ucp, p);
|
|
#endif
|
|
|
|
error = 0;
|
|
ap = VTOA(vp);
|
|
#ifdef DIAGNOSTIC
|
|
if (!VOP_ISLOCKED(vp)) {
|
|
vprint("adosfs_access: not locked", vp);
|
|
panic("adosfs_access: not locked");
|
|
}
|
|
#endif
|
|
#ifdef QUOTA
|
|
#endif
|
|
/*
|
|
* super-user always gets a go ahead (suser()?)
|
|
*/
|
|
if (suser(ucp, NULL) == 0)
|
|
return(0);
|
|
|
|
/*
|
|
* not the owner of the mount?
|
|
*/
|
|
if (ucp->cr_uid != ap->amp->uid) {
|
|
mode >>= 3;
|
|
gp = ucp->cr_groups;
|
|
for (i = 0; i < ucp->cr_ngroups; i++, gp++)
|
|
if (ap->amp->gid == *gp)
|
|
goto found;
|
|
/*
|
|
* check other status
|
|
*/
|
|
mode >>= 3;
|
|
}
|
|
found:
|
|
if ((adunixprot(ap->adprot) & mode) != mode)
|
|
error = EACCES;
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_setattr(vp, vap, ucp, p)
|
|
struct vnode *vp;
|
|
struct vattr *vap;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(setattr EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_mmap(vp, fflags, ucp, p)
|
|
struct vnode *vp;
|
|
int fflags;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(mmap EINVAL)");
|
|
#endif
|
|
return(EINVAL);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_fsync(vp, fflags, ucp, waitfor, p)
|
|
struct vnode *vp;
|
|
int fflags, waitfor;
|
|
struct ucred *ucp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(fsync 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_seek(vp, ooff, noff, ucp)
|
|
struct vnode *vp;
|
|
off_t ooff, noff;
|
|
struct ucred *ucp;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(seek 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_link(vp, ndp, p)
|
|
struct vnode *vp;
|
|
struct nameidata *ndp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(link EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_rename(ondp, nndp, p)
|
|
struct nameidata *ondp;
|
|
struct nameidata *nndp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(rename EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_mkdir(ndp, vap, p)
|
|
struct nameidata *ndp;
|
|
struct vattr *vap;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(mkdir EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_rmdir(ndp, p)
|
|
struct nameidata *ndp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(rmdir EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_symlink(ndp, vap, targ, p)
|
|
struct nameidata *ndp;
|
|
struct vattr *vap;
|
|
char *targ;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(symlink EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_readlink(vp, uio, ucp)
|
|
struct vnode *vp;
|
|
struct uio *uio;
|
|
struct ucred *ucp;
|
|
{
|
|
struct anode *ap;
|
|
int error;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(readlink [0x%x 0x%x 0x%x]", vp, uio, ucp);
|
|
#endif
|
|
error = 0;
|
|
ap = VTOA(vp);
|
|
if (ap->type != ASLINK)
|
|
error = EBADF;
|
|
/*
|
|
* XXX Should this be NULL terminated?
|
|
*/
|
|
if (error == 0)
|
|
error = uiomove(ap->slinkto, strlen(ap->slinkto) + 1, uio);
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", error);
|
|
#endif
|
|
return(error);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_abortop(ndp)
|
|
struct nameidata *ndp;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(abortop EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_inactive(vp, p)
|
|
struct vnode *vp;
|
|
struct proc *p;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(inactive ");
|
|
#endif
|
|
if (vp->v_usecount == 0 /* && check for file gone? */)
|
|
vgone(vp);
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" 0)");
|
|
#endif
|
|
return(0);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_advlock(vp, id, op, flp, flags)
|
|
struct vnode *vp;
|
|
caddr_t id;
|
|
int op;
|
|
struct flock *flp;
|
|
int flags;
|
|
{
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(advlock EOPNOTSUPP)");
|
|
#endif
|
|
return(EOPNOTSUPP);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
int
|
|
adosfs_islocked(vp)
|
|
struct vnode *vp;
|
|
{
|
|
int locked;
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf("(islocked [0x%x]", vp);
|
|
#endif
|
|
locked = (VTOA(vp)->flags & ALOCKED) == ALOCKED;
|
|
|
|
#ifdef ADOSFS_DIAGNOSTIC
|
|
printf(" %d)", locked);
|
|
#endif
|
|
return(locked);
|
|
}
|
|
|
|
int adosfs_lookup __P((struct vnode *, struct nameidata *, struct proc *));
|
|
int adosfs_reclaim __P((struct vnode *));
|
|
|
|
/*
|
|
* vnode indirect function call structure.
|
|
*/
|
|
struct vnodeops adosfs_vnodeops = {
|
|
adosfs_lookup, /* lookup */
|
|
adosfs_create, /* create */
|
|
adosfs_mknod, /* mknod */
|
|
adosfs_open, /* open */
|
|
adosfs_close, /* close */
|
|
adosfs_access, /* access */
|
|
adosfs_getattr, /* getattr */
|
|
adosfs_setattr, /* setattr */
|
|
adosfs_read, /* read */
|
|
adosfs_write, /* write */
|
|
adosfs_ioctl, /* ioctl */
|
|
adosfs_select, /* select */
|
|
adosfs_mmap, /* mmap */
|
|
adosfs_fsync, /* fsync */
|
|
adosfs_seek, /* seek */
|
|
adosfs_remove, /* remove */
|
|
adosfs_link, /* link */
|
|
adosfs_rename, /* rename */
|
|
adosfs_mkdir, /* mkdir */
|
|
adosfs_rmdir, /* rmdir */
|
|
adosfs_symlink, /* symlink */
|
|
adosfs_readdir, /* readdir */
|
|
adosfs_readlink,/* readlink */
|
|
adosfs_abortop, /* abortop */
|
|
adosfs_inactive,/* inactive */
|
|
adosfs_reclaim, /* reclaim */
|
|
adosfs_lock, /* lock */
|
|
adosfs_unlock, /* unlock */
|
|
adosfs_bmap, /* bmap */
|
|
adosfs_strategy,/* strategy */
|
|
adosfs_print, /* print */
|
|
adosfs_islocked,/* islocked */
|
|
adosfs_advlock, /* advlock */
|
|
};
|