[unix-history] / sys / isofs / isofs_vnops.c

/*
 *	$Id: isofs_vnops.c,v 1.3 1993/11/25 01:32:31 wollman Exp $
 */
#include "param.h"
#include "systm.h"
#include "namei.h"
#include "resourcevar.h"
#include "kernel.h"
#include "file.h"
#include "stat.h"
#include "buf.h"
#include "proc.h"
#include "conf.h"
#include "mount.h"
#include "vnode.h"
#include "specdev.h"
#include "fifo.h"
#include "malloc.h"
#include "dir.h"

#include "iso.h"
#include "isofs_node.h"
#include "iso_rrip.h"

/*
 * Open called.
 *
 * Nothing to do.
 */
/* ARGSUSED */
int
isofs_open(vp, mode, cred, p)
	struct vnode *vp;
	int mode;
	struct ucred *cred;
	struct proc *p;
{
	return (0);
}

/*
 * Close called
 *
 * Update the times on the inode on writeable file systems.
 */
/* ARGSUSED */
int
isofs_close(vp, fflag, cred, p)
	struct vnode *vp;
	int fflag;
	struct ucred *cred;
	struct proc *p;
{
	return (0);
}

/*
 * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC.
 * The mode is shifted to select the owner/group/other fields. The
 * super user is granted all permissions.
 */
int
isofs_access(vp, mode, cred, p)
	struct vnode *vp;
	register int mode;
	struct ucred *cred;
	struct proc *p;
{
	return (0);
}

/* ARGSUSED */
int
isofs_getattr(vp, vap, cred, p)
	struct vnode *vp;
	register struct vattr *vap;
	struct ucred *cred;
	struct proc *p;
{
	register struct iso_node *ip = VTOI(vp);
	int i;

	vap->va_fsid = ip->i_dev;
	vap->va_fileid = ip->i_number;
	if (vp->v_type == VDIR)
		vap->va_nlink = 2;
	else
		vap->va_nlink = 1;

	vap->va_mode = ip->inode.iso_mode;
	vap->va_uid  = ip->inode.iso_uid;
	vap->va_gid  = ip->inode.iso_gid;
	vap->va_atime= ip->inode.iso_atime;
	vap->va_mtime= ip->inode.iso_mtime;
	vap->va_ctime= ip->inode.iso_ctime;

	vap->va_rdev = 0;
	vap->va_size = ip->i_size;
	vap->va_size_rsv = 0;
	vap->va_flags = 0;
	vap->va_gen = 1;
	vap->va_blocksize = ip->i_mnt->logical_block_size;
	vap->va_bytes = ip->i_size;
	vap->va_bytes_rsv = 0;
	vap->va_type = vp->v_type;
	return (0);
}

/*
 * Vnode op for reading.
 */
/* ARGSUSED */
int
isofs_read(vp, uio, ioflag, cred)
	struct vnode *vp;
	register struct uio *uio;
	int ioflag;
	struct ucred *cred;
{
	register struct iso_node *ip = VTOI(vp);
	register struct iso_mnt *imp;
	struct buf *bp;
	daddr_t lbn, bn, rablock;
	int size, diff, error = 0;
	long n, on, type;

#ifdef DIAGNOSTICx
	if (uio->uio_rw != UIO_READ)
		panic("isofs_read mode");
	type = ip->i_mode & IFMT;
	if (type != IFDIR && type != IFREG && type != IFLNK)
		panic("isofs_read type");
#endif
	if (uio->uio_resid == 0)
		return (0);
	if (uio->uio_offset < 0)
		return (EINVAL);
	ip->i_flag |= IACC;
	imp = ip->i_mnt;
	do {
		lbn = iso_lblkno(imp, uio->uio_offset);
		on = iso_blkoff(imp, uio->uio_offset);
		n = MIN((unsigned)(imp->im_bsize - on), uio->uio_resid);
		diff = ip->i_size - uio->uio_offset;
		if (diff <= 0)
			return (0);
		if (diff < n)
			n = diff;
		size = iso_blksize(imp, ip, lbn);
		rablock = lbn + 1;
		if (vp->v_lastr + 1 == lbn &&
		    iso_lblktosize(imp, rablock) < ip->i_size)
			error = breada(ITOV(ip), lbn, size, rablock,
				iso_blksize(imp, ip, rablock), NOCRED, &bp);
		else
			error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
		vp->v_lastr = lbn;
		n = MIN(n, size - bp->b_resid);
		if (error) {
			brelse(bp);
			return (error);
		}

		error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
		if (n + on == imp->im_bsize || uio->uio_offset == ip->i_size)
			bp->b_flags |= B_AGE;
		brelse(bp);
	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	return (error);
}

/* ARGSUSED */
int
isofs_ioctl(vp, com, data, fflag, cred, p)
	struct vnode *vp;
	int com;
	caddr_t data;
	int fflag;
	struct ucred *cred;
	struct proc *p;
{
	return (ENOTTY);
}

/* ARGSUSED */
int
isofs_select(vp, which, fflags, cred, p)
	struct vnode *vp;
	int which, fflags;
	struct ucred *cred;
	struct proc *p;
{

	/*
	 * We should really check to see if I/O is possible.
	 */
	return (1);
}

/*
 * Mmap a file
 *
 * NB Currently unsupported.
 */
/* ARGSUSED */
int
isofs_mmap(vp, fflags, cred, p)
	struct vnode *vp;
	int fflags;
	struct ucred *cred;
	struct proc *p;
{

	return (EINVAL);
}

/*
 * Seek on a file
 *
 * Nothing to do, so just return.
 */
/* ARGSUSED */
int
isofs_seek(vp, oldoff, newoff, cred)
	struct vnode *vp;
	off_t oldoff, newoff;
	struct ucred *cred;
{

	return (0);
}

/*
 * Vnode op for readdir
 */
int
isofs_readdir(vp, uio, cred, eofflagp)
	struct vnode *vp;
	register struct uio *uio;
	struct ucred *cred;
	int *eofflagp;
{
	struct dirent dirent;
	int iso_offset;
	int entryoffsetinblock;
	int error = 0;
	int endsearch;
	struct iso_directory_record *ep;
	int reclen;
	struct iso_mnt *imp;
	struct iso_node *ip;
	struct buf *bp = NULL;
	int i;
	int end_flag = 0;
	ISO_RRIP_ANALYZE ana;

	ip = VTOI (vp);
	imp = ip->i_mnt;

	iso_offset = uio->uio_offset;

	entryoffsetinblock = iso_blkoff(imp, iso_offset);
	if (entryoffsetinblock != 0) {
		if (error = iso_blkatoff(ip, iso_offset, (char **)0, &bp))
			return (error);
	}

	endsearch = ip->i_size;

	while (iso_offset < endsearch && uio->uio_resid > 0) {
		/*
		 * If offset is on a block boundary,
		 * read the next directory block.
		 * Release previous if it exists.
		 */

		if (iso_blkoff(imp, iso_offset) == 0) {
			if (bp != NULL)
				brelse(bp);
			if (error = iso_blkatoff(ip, iso_offset,
						 (char **)0, &bp))
				return (error);
			entryoffsetinblock = 0;
		}
		/*
		 * Get pointer to next entry.
		 */

		ep = (struct iso_directory_record *)
			(bp->b_un.b_addr + entryoffsetinblock);

		reclen = isonum_711 (ep->length);
		if (reclen == 0) {
			/* skip to next block, if any */
			iso_offset = roundup (iso_offset,
					      imp->logical_block_size);
			continue;
		}

		if (reclen < sizeof (struct iso_directory_record))
			/* illegal entry, stop */
			break;

/* 10 Aug 92*/	if (entryoffsetinblock + reclen -1 >= imp->logical_block_size)
			/* illegal directory, so stop looking */
			break;

		dirent.d_fileno = isonum_733 (ep->extent);
		dirent.d_namlen = isonum_711 (ep->name_len);

		if (reclen < sizeof (struct iso_directory_record)
		    + dirent.d_namlen)
			/* illegal entry, stop */
			break;

		/*
		 *
		 */
		switch (ep->name[0]) {
		case 0:
			dirent.d_name[0] = '.';
			dirent.d_namlen = 1;
			break;
		case 1:
			dirent.d_name[0] = '.';
			dirent.d_name[1] = '.';
			dirent.d_namlen = 2;
			break;
		default:
			switch ( imp->iso_ftype ) {
			case ISO_FTYPE_RRIP:
				isofs_rrip_getname( ep, dirent.d_name, &dirent.d_namlen );
				break;
			case ISO_FTYPE_9660:
			{
				int namelen = dirent.d_namlen;
				isofntrans(ep->name, dirent.d_namlen,
					   dirent.d_name, &namelen);
				dirent.d_namlen = namelen;
				break;
			}
			default:
				break;
			}
			break;
		}

		dirent.d_name[dirent.d_namlen] = 0;
		dirent.d_reclen = DIRSIZ (&dirent);

		if (uio->uio_resid < dirent.d_reclen)
			break;

		if (error = uiomove (&dirent, dirent.d_reclen, uio))
			break;

		iso_offset += reclen;
		entryoffsetinblock += reclen;
	}
			
	if (bp)
		brelse (bp);

	if (end_flag || (VTOI(vp)->i_size - iso_offset) <= 0)
		*eofflagp = 1;
	else
		*eofflagp = 0;

	uio->uio_offset = iso_offset;

	return (error);
}

/*
 * Return target name of a symbolic link
 */
typedef struct iso_directory_record ISODIR;
typedef struct iso_node             ISONODE;
typedef struct iso_mnt              ISOMNT;
int isofs_readlink(vp, uio, cred)
struct vnode *vp;
struct uio   *uio;
struct ucred *cred;
{
        ISONODE *ip;
        ISODIR  *dirp;                   
        ISOMNT  *imp;
        struct  buf *bp;
        int     symlen;
        int     error;
        char    symname[NAME_MAX];

        ip  = VTOI( vp );
        imp = ip->i_mnt;
        /*
         * Get parents directory record block that this inode included.
         */
        error = bread(  imp->im_devvp,
                        (daddr_t)(( ip->iso_parent_ext + (ip->iso_parent >> 11 ) )
                        * imp->im_bsize / DEV_BSIZE ),
                        imp->im_bsize,
                        NOCRED,
                        &bp );
        if ( error ) {
                return( EINVAL );
        }

        /*
         * Setup the directory pointer for this inode
         */

        dirp = (ISODIR *)(bp->b_un.b_addr + ( ip->iso_parent & 0x7ff ) );
#ifdef DEBUG
        printf("lbn=%d[base=%d,off=%d,bsize=%d,DEV_BSIZE=%d], dirp= %08x, b_addr=%08x, offset=%08x(%08x)\n",
                                (daddr_t)(( ip->iso_parent_ext + (ip->iso_parent >> 12 ) ) * imp->im_bsize / DEV_BSIZE ),
                                ip->iso_parent_ext,
                                (ip->iso_parent >> 11 ),
                                imp->im_bsize,
                                DEV_BSIZE,
                                dirp,
                                bp->b_un.b_addr,
                                ip->iso_parent,
                                ip->iso_parent & 0x7ff );
#endif

        /*
         * Just make sure, we have a right one....
         *   1: Check not cross boundary on block
         *   2: Check number of inode
         */
        if ( (ip->iso_parent & 0x7ff) + isonum_711( dirp->length ) >=
                                                imp->im_bsize )         {
                brelse ( bp );
                return( EINVAL );
        }
        if ( isonum_733(dirp->extent) != ip->i_number ) {
                brelse ( bp );
                return( EINVAL );
        }

        /*
         * Ok, we just gathering a Symbolick name in SL record.
         */
        if ( isofs_rrip_getsymname( vp, dirp, symname, &symlen ) == 0 ) {
                brelse ( bp );
                return( EINVAL );
        }
        /*
         * Don't forget before you leave from home ;-)
         */
        brelse( bp );

        /*
         * return with the Symbolick name to caller's.
         */
        return ( uiomove( symname, symlen, uio ) );
}

/*
 * Ufs abort op, called after namei() when a CREATE/DELETE isn't actually
 * done. If a buffer has been saved in anticipation of a CREATE, delete it.
 */
/* ARGSUSED */
int
isofs_abortop(ndp)
	struct nameidata *ndp;
{

	if ((ndp->ni_nameiop & (HASBUF | SAVESTART)) == HASBUF)
		FREE(ndp->ni_pnbuf, M_NAMEI);
	return (0);
}

/*
 * Lock an inode.
 */
int
isofs_lock(vp)
	struct vnode *vp;
{
	register struct iso_node *ip = VTOI(vp);

	ISO_ILOCK(ip);
	return (0);
}

/*
 * Unlock an inode.
 */
int
isofs_unlock(vp)
	struct vnode *vp;
{
	register struct iso_node *ip = VTOI(vp);

	if (!(ip->i_flag & ILOCKED))
		panic("isofs_unlock NOT LOCKED");
	ISO_IUNLOCK(ip);
	return (0);
}

/*
 * Check for a locked inode.
 */
int
isofs_islocked(vp)
	struct vnode *vp;
{

	if (VTOI(vp)->i_flag & ILOCKED)
		return (1);
	return (0);
}

/*
 * Calculate the logical to physical mapping if not done already,
 * then call the device strategy routine.
 */

int
isofs_strategy(bp)
	register struct buf *bp;
{
	register struct iso_node *ip = VTOI(bp->b_vp);
	struct vnode *vp;
	int error;

	if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR)
		panic("isofs_strategy: spec");
	if (bp->b_blkno == bp->b_lblkno) {
		if (error = iso_bmap(ip, bp->b_lblkno, &bp->b_blkno))
			return (error);
		if ((long)bp->b_blkno == -1)
			clrbuf(bp);
	}
	if ((long)bp->b_blkno == -1) {
		biodone(bp);
		return (0);
	}
	vp = ip->i_devvp;
	bp->b_dev = vp->v_rdev;
	(*(vp->v_op->vop_strategy))(bp);
	return (0);
}

/*
 * Print out the contents of an inode.
 */
void
isofs_print(vp)
	struct vnode *vp;
{
	printf ("tag VT_ISOFS, isofs vnode\n");
}

extern int enodev ();

/*
 * Global vfs data structures for isofs
 */
struct vnodeops isofs_vnodeops = {
	isofs_lookup,		/* lookup */
	(void *)enodev,		/* create */
	(void *)enodev,		/* mknod */
	isofs_open,		/* open */
	isofs_close,		/* close */
	isofs_access,		/* access */
	isofs_getattr,		/* getattr */
	(void *)enodev,		/* setattr */
	isofs_read,		/* read */
	(void *)enodev,		/* write */
	isofs_ioctl,		/* ioctl */
	isofs_select,		/* select */
	isofs_mmap,		/* mmap */
	(void *)nullop,		/* fsync */
	isofs_seek,		/* seek */
	(void *)enodev,		/* remove */
	(void *)enodev,		/* link */
	(void *)enodev,		/* rename */
	(void *)enodev,		/* mkdir */
	(void *)enodev,		/* rmdir */
	(void *)enodev,		/* symlink */
	isofs_readdir,		/* readdir */
	isofs_readlink,		/* readlink */
	isofs_abortop,		/* abortop */
	isofs_inactive,		/* inactive */
	isofs_reclaim,		/* reclaim */
	isofs_lock,		/* lock */
	isofs_unlock,		/* unlock */
	(void *)enodev,		/* bmap */
	isofs_strategy,		/* strategy */
	isofs_print,		/* print */
	isofs_islocked,		/* islocked */
	(void *)enodev,		/* advlock */
};
Commit	Line	Data
15637ed4	1	/*
fde1aeb2	2	* $Id: isofs_vnops.c,v 1.3 1993/11/25 01:32:31 wollman Exp $
15637ed4 RG	3	*/
	4	#include "param.h"
	5	#include "systm.h"
	6	#include "namei.h"
	7	#include "resourcevar.h"
	8	#include "kernel.h"
	9	#include "file.h"
	10	#include "stat.h"
	11	#include "buf.h"
	12	#include "proc.h"
	13	#include "conf.h"
	14	#include "mount.h"
	15	#include "vnode.h"
	16	#include "specdev.h"
	17	#include "fifo.h"
	18	#include "malloc.h"
	19	#include "dir.h"
	20
	21	#include "iso.h"
	22	#include "isofs_node.h"
584fddaa	23	#include "iso_rrip.h"
15637ed4 RG	24
	25	/*
	26	* Open called.
	27	*
	28	* Nothing to do.
	29	*/
	30	/* ARGSUSED */
4c45483e	31	int
15637ed4 RG	32	isofs_open(vp, mode, cred, p)
	33	struct vnode *vp;
	34	int mode;
	35	struct ucred *cred;
	36	struct proc *p;
	37	{
	38	return (0);
	39	}
	40
	41	/*
	42	* Close called
	43	*
	44	* Update the times on the inode on writeable file systems.
	45	*/
	46	/* ARGSUSED */
4c45483e	47	int
15637ed4 RG	48	isofs_close(vp, fflag, cred, p)
	49	struct vnode *vp;
	50	int fflag;
	51	struct ucred *cred;
	52	struct proc *p;
	53	{
	54	return (0);
	55	}
	56
	57	/*
	58	* Check mode permission on inode pointer. Mode is READ, WRITE or EXEC.
	59	* The mode is shifted to select the owner/group/other fields. The
	60	* super user is granted all permissions.
	61	*/
4c45483e	62	int
15637ed4 RG	63	isofs_access(vp, mode, cred, p)
	64	struct vnode *vp;
	65	register int mode;
	66	struct ucred *cred;
	67	struct proc *p;
	68	{
	69	return (0);
	70	}
	71
	72	/* ARGSUSED */
4c45483e	73	int
15637ed4 RG	74	isofs_getattr(vp, vap, cred, p)
	75	struct vnode *vp;
	76	register struct vattr *vap;
	77	struct ucred *cred;
	78	struct proc *p;
	79	{
	80	register struct iso_node *ip = VTOI(vp);
15637ed4 RG	81	int i;
15637ed4 RG	82
15637ed4 RG	83	vap->va_fsid = ip->i_dev;
15637ed4 RG	84	vap->va_fileid = ip->i_number;
15637ed4 RG	85	if (vp->v_type == VDIR)
	86	vap->va_nlink = 2;
	87	else
	88	vap->va_nlink = 1;
584fddaa JH	89
	90	vap->va_mode = ip->inode.iso_mode;
	91	vap->va_uid = ip->inode.iso_uid;
	92	vap->va_gid = ip->inode.iso_gid;
	93	vap->va_atime= ip->inode.iso_atime;
	94	vap->va_mtime= ip->inode.iso_mtime;
	95	vap->va_ctime= ip->inode.iso_ctime;
	96
15637ed4 RG	97	vap->va_rdev = 0;
	98	vap->va_size = ip->i_size;
	99	vap->va_size_rsv = 0;
15637ed4 RG	100	vap->va_flags = 0;
	101	vap->va_gen = 1;
	102	vap->va_blocksize = ip->i_mnt->logical_block_size;
	103	vap->va_bytes = ip->i_size;
	104	vap->va_bytes_rsv = 0;
	105	vap->va_type = vp->v_type;
	106	return (0);
	107	}
	108
	109	/*
	110	* Vnode op for reading.
	111	*/
	112	/* ARGSUSED */
4c45483e	113	int
15637ed4 RG	114	isofs_read(vp, uio, ioflag, cred)
	115	struct vnode *vp;
	116	register struct uio *uio;
	117	int ioflag;
	118	struct ucred *cred;
	119	{
	120	register struct iso_node *ip = VTOI(vp);
	121	register struct iso_mnt *imp;
	122	struct buf *bp;
	123	daddr_t lbn, bn, rablock;
	124	int size, diff, error = 0;
	125	long n, on, type;
	126
	127	#ifdef DIAGNOSTICx
	128	if (uio->uio_rw != UIO_READ)
	129	panic("isofs_read mode");
	130	type = ip->i_mode & IFMT;
	131	if (type != IFDIR && type != IFREG && type != IFLNK)
	132	panic("isofs_read type");
	133	#endif
	134	if (uio->uio_resid == 0)
	135	return (0);
	136	if (uio->uio_offset < 0)
	137	return (EINVAL);
	138	ip->i_flag \|= IACC;
	139	imp = ip->i_mnt;
	140	do {
	141	lbn = iso_lblkno(imp, uio->uio_offset);
	142	on = iso_blkoff(imp, uio->uio_offset);
	143	n = MIN((unsigned)(imp->im_bsize - on), uio->uio_resid);
	144	diff = ip->i_size - uio->uio_offset;
	145	if (diff <= 0)
	146	return (0);
	147	if (diff < n)
	148	n = diff;
	149	size = iso_blksize(imp, ip, lbn);
	150	rablock = lbn + 1;
	151	if (vp->v_lastr + 1 == lbn &&
	152	iso_lblktosize(imp, rablock) < ip->i_size)
	153	error = breada(ITOV(ip), lbn, size, rablock,
	154	iso_blksize(imp, ip, rablock), NOCRED, &bp);
	155	else
	156	error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
	157	vp->v_lastr = lbn;
	158	n = MIN(n, size - bp->b_resid);
	159	if (error) {
	160	brelse(bp);
	161	return (error);
	162	}
	163
	164	error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
	165	if (n + on == imp->im_bsize \|\| uio->uio_offset == ip->i_size)
	166	bp->b_flags \|= B_AGE;
	167	brelse(bp);
	168	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	169	return (error);
	170	}
	171
	172	/* ARGSUSED */
4c45483e	173	int
15637ed4 RG	174	isofs_ioctl(vp, com, data, fflag, cred, p)
	175	struct vnode *vp;
	176	int com;
	177	caddr_t data;
	178	int fflag;
	179	struct ucred *cred;
	180	struct proc *p;
	181	{
	182	return (ENOTTY);
	183	}
	184
	185	/* ARGSUSED */
4c45483e	186	int
15637ed4 RG	187	isofs_select(vp, which, fflags, cred, p)
	188	struct vnode *vp;
	189	int which, fflags;
	190	struct ucred *cred;
	191	struct proc *p;
	192	{
	193
	194	/*
	195	* We should really check to see if I/O is possible.
	196	*/
	197	return (1);
	198	}
	199
	200	/*
	201	* Mmap a file
	202	*
	203	* NB Currently unsupported.
	204	*/
	205	/* ARGSUSED */
4c45483e	206	int
15637ed4 RG	207	isofs_mmap(vp, fflags, cred, p)
	208	struct vnode *vp;
	209	int fflags;
	210	struct ucred *cred;
	211	struct proc *p;
	212	{
	213
	214	return (EINVAL);
	215	}
	216
	217	/*
	218	* Seek on a file
	219	*
	220	* Nothing to do, so just return.
	221	*/
	222	/* ARGSUSED */
4c45483e	223	int
15637ed4 RG	224	isofs_seek(vp, oldoff, newoff, cred)
	225	struct vnode *vp;
	226	off_t oldoff, newoff;
	227	struct ucred *cred;
	228	{
	229
	230	return (0);
	231	}
	232
	233	/*
	234	* Vnode op for readdir
	235	*/
4c45483e	236	int
15637ed4 RG	237	isofs_readdir(vp, uio, cred, eofflagp)
	238	struct vnode *vp;
	239	register struct uio *uio;
	240	struct ucred *cred;
	241	int *eofflagp;
	242	{
	243	struct dirent dirent;
	244	int iso_offset;
	245	int entryoffsetinblock;
	246	int error = 0;
	247	int endsearch;
	248	struct iso_directory_record *ep;
	249	int reclen;
	250	struct iso_mnt *imp;
	251	struct iso_node *ip;
	252	struct buf *bp = NULL;
	253	int i;
	254	int end_flag = 0;
584fddaa	255	ISO_RRIP_ANALYZE ana;
15637ed4 RG	256
	257	ip = VTOI (vp);
	258	imp = ip->i_mnt;
	259
	260	iso_offset = uio->uio_offset;
	261
	262	entryoffsetinblock = iso_blkoff(imp, iso_offset);
	263	if (entryoffsetinblock != 0) {
	264	if (error = iso_blkatoff(ip, iso_offset, (char **)0, &bp))
	265	return (error);
	266	}
	267
	268	endsearch = ip->i_size;
	269
	270	while (iso_offset < endsearch && uio->uio_resid > 0) {
	271	/*
	272	* If offset is on a block boundary,
	273	* read the next directory block.
	274	* Release previous if it exists.
	275	*/
	276
	277	if (iso_blkoff(imp, iso_offset) == 0) {
	278	if (bp != NULL)
	279	brelse(bp);
	280	if (error = iso_blkatoff(ip, iso_offset,
	281	(char **)0, &bp))
	282	return (error);
	283	entryoffsetinblock = 0;
	284	}
	285	/*
	286	* Get pointer to next entry.
	287	*/
	288
	289	ep = (struct iso_directory_record *)
	290	(bp->b_un.b_addr + entryoffsetinblock);
	291
	292	reclen = isonum_711 (ep->length);
	293	if (reclen == 0) {
	294	/* skip to next block, if any */
	295	iso_offset = roundup (iso_offset,
	296	imp->logical_block_size);
	297	continue;
	298	}
	299
	300	if (reclen < sizeof (struct iso_directory_record))
	301	/* illegal entry, stop */
	302	break;
	303
	304	/* 10 Aug 92*/ if (entryoffsetinblock + reclen -1 >= imp->logical_block_size)
	305	/* illegal directory, so stop looking */
	306	break;
	307
	308	dirent.d_fileno = isonum_733 (ep->extent);
	309	dirent.d_namlen = isonum_711 (ep->name_len);
	310
	311	if (reclen < sizeof (struct iso_directory_record)
	312	+ dirent.d_namlen)
	313	/* illegal entry, stop */
	314	break;
	315
584fddaa JH	316	/*
	317	*
	318	*/
	319	switch (ep->name[0]) {
fde1aeb2 GW	320	case 0:
	321	dirent.d_name[0] = '.';
	322	dirent.d_namlen = 1;
	323	break;
	324	case 1:
	325	dirent.d_name[0] = '.';
	326	dirent.d_name[1] = '.';
	327	dirent.d_namlen = 2;
	328	break;
	329	default:
	330	switch ( imp->iso_ftype ) {
	331	case ISO_FTYPE_RRIP:
	332	isofs_rrip_getname( ep, dirent.d_name, &dirent.d_namlen );
15637ed4	333	break;
fde1aeb2 GW	334	case ISO_FTYPE_9660:
	335	{
	336	int namelen = dirent.d_namlen;
	337	isofntrans(ep->name, dirent.d_namlen,
	338	dirent.d_name, &namelen);
	339	dirent.d_namlen = namelen;
584fddaa	340	break;
fde1aeb2	341	}
584fddaa	342	default:
584fddaa	343	break;
fde1aeb2 GW	344	}
fde1aeb2 GW	345	break;
15637ed4	346	}
584fddaa	347
15637ed4 RG	348	dirent.d_name[dirent.d_namlen] = 0;
	349	dirent.d_reclen = DIRSIZ (&dirent);
	350
	351	if (uio->uio_resid < dirent.d_reclen)
	352	break;
	353
	354	if (error = uiomove (&dirent, dirent.d_reclen, uio))
	355	break;
	356
	357	iso_offset += reclen;
	358	entryoffsetinblock += reclen;
	359	}
	360
	361	if (bp)
	362	brelse (bp);
	363
	364	if (end_flag \|\| (VTOI(vp)->i_size - iso_offset) <= 0)
	365	*eofflagp = 1;
	366	else
	367	*eofflagp = 0;
	368
	369	uio->uio_offset = iso_offset;
	370
	371	return (error);
	372	}
	373
584fddaa JH	374	/*
	375	* Return target name of a symbolic link
	376	*/
	377	typedef struct iso_directory_record ISODIR;
	378	typedef struct iso_node ISONODE;
	379	typedef struct iso_mnt ISOMNT;
	380	int isofs_readlink(vp, uio, cred)
	381	struct vnode *vp;
	382	struct uio *uio;
	383	struct ucred *cred;
	384	{
	385	ISONODE *ip;
	386	ISODIR *dirp;
	387	ISOMNT *imp;
	388	struct buf *bp;
	389	int symlen;
	390	int error;
	391	char symname[NAME_MAX];
	392
	393	ip = VTOI( vp );
	394	imp = ip->i_mnt;
	395	/*
	396	* Get parents directory record block that this inode included.
	397	*/
	398	error = bread( imp->im_devvp,
	399	(daddr_t)(( ip->iso_parent_ext + (ip->iso_parent >> 11 ) )
	400	* imp->im_bsize / DEV_BSIZE ),
	401	imp->im_bsize,
	402	NOCRED,
	403	&bp );
	404	if ( error ) {
	405	return( EINVAL );
	406	}
	407
	408	/*
	409	* Setup the directory pointer for this inode
	410	*/
	411
	412	dirp = (ISODIR *)(bp->b_un.b_addr + ( ip->iso_parent & 0x7ff ) );
	413	#ifdef DEBUG
	414	printf("lbn=%d[base=%d,off=%d,bsize=%d,DEV_BSIZE=%d], dirp= %08x, b_addr=%08x, offset=%08x(%08x)\n",
	415	(daddr_t)(( ip->iso_parent_ext + (ip->iso_parent >> 12 ) ) * imp->im_bsize / DEV_BSIZE ),
	416	ip->iso_parent_ext,
	417	(ip->iso_parent >> 11 ),
	418	imp->im_bsize,
	419	DEV_BSIZE,
	420	dirp,
	421	bp->b_un.b_addr,
	422	ip->iso_parent,
	423	ip->iso_parent & 0x7ff );
	424	#endif
	425
	426	/*
	427	* Just make sure, we have a right one....
	428	* 1: Check not cross boundary on block
	429	* 2: Check number of inode
	430	*/
	431	if ( (ip->iso_parent & 0x7ff) + isonum_711( dirp->length ) >=
	432	imp->im_bsize ) {
	433	brelse ( bp );
	434	return( EINVAL );
	435	}
	436	if ( isonum_733(dirp->extent) != ip->i_number ) {
	437	brelse ( bp );
438	return( EINVAL );
439	}
440
441	/*
442	* Ok, we just gathering a Symbolick name in SL record.
443	*/
444	if ( isofs_rrip_getsymname( vp, dirp, symname, &symlen ) == 0 ) {
445	brelse ( bp );
446	return( EINVAL );
447	}
448	/*
449	* Don't forget before you leave from home ;-)
450	*/
451	brelse( bp );
452
453	/*
454	* return with the Symbolick name to caller's.
455	*/
456	return ( uiomove( symname, symlen, uio ) );
457	}
458
15637ed4 RG	459	/*
	460	* Ufs abort op, called after namei() when a CREATE/DELETE isn't actually
	461	* done. If a buffer has been saved in anticipation of a CREATE, delete it.
	462	*/
	463	/* ARGSUSED */
4c45483e	464	int
15637ed4 RG	465	isofs_abortop(ndp)
	466	struct nameidata *ndp;
	467	{
	468
	469	if ((ndp->ni_nameiop & (HASBUF \| SAVESTART)) == HASBUF)
	470	FREE(ndp->ni_pnbuf, M_NAMEI);
	471	return (0);
	472	}
	473
	474	/*
	475	* Lock an inode.
	476	*/
4c45483e	477	int
15637ed4 RG	478	isofs_lock(vp)
	479	struct vnode *vp;
	480	{
	481	register struct iso_node *ip = VTOI(vp);
	482
	483	ISO_ILOCK(ip);
	484	return (0);
	485	}
	486
	487	/*
	488	* Unlock an inode.
	489	*/
4c45483e	490	int
15637ed4 RG	491	isofs_unlock(vp)
	492	struct vnode *vp;
	493	{
	494	register struct iso_node *ip = VTOI(vp);
	495
	496	if (!(ip->i_flag & ILOCKED))
	497	panic("isofs_unlock NOT LOCKED");
	498	ISO_IUNLOCK(ip);
	499	return (0);
	500	}
	501
	502	/*
	503	* Check for a locked inode.
	504	*/
4c45483e	505	int
15637ed4 RG	506	isofs_islocked(vp)
	507	struct vnode *vp;
	508	{
	509
	510	if (VTOI(vp)->i_flag & ILOCKED)
	511	return (1);
	512	return (0);
	513	}
	514
	515	/*
	516	* Calculate the logical to physical mapping if not done already,
	517	* then call the device strategy routine.
	518	*/
	519
4c45483e	520	int
15637ed4 RG	521	isofs_strategy(bp)
	522	register struct buf *bp;
	523	{
	524	register struct iso_node *ip = VTOI(bp->b_vp);
	525	struct vnode *vp;
	526	int error;
	527
	528	if (bp->b_vp->v_type == VBLK \|\| bp->b_vp->v_type == VCHR)
	529	panic("isofs_strategy: spec");
	530	if (bp->b_blkno == bp->b_lblkno) {
	531	if (error = iso_bmap(ip, bp->b_lblkno, &bp->b_blkno))
	532	return (error);
	533	if ((long)bp->b_blkno == -1)
	534	clrbuf(bp);
	535	}
	536	if ((long)bp->b_blkno == -1) {
	537	biodone(bp);
	538	return (0);
	539	}
	540	vp = ip->i_devvp;
	541	bp->b_dev = vp->v_rdev;
	542	(*(vp->v_op->vop_strategy))(bp);
	543	return (0);
	544	}
	545
	546	/*
	547	* Print out the contents of an inode.
	548	*/
4c45483e	549	void
15637ed4 RG	550	isofs_print(vp)
	551	struct vnode *vp;
	552	{
584fddaa	553	printf ("tag VT_ISOFS, isofs vnode\n");
15637ed4 RG	554	}
	555
	556	extern int enodev ();
	557
	558	/*
	559	* Global vfs data structures for isofs
	560	*/
	561	struct vnodeops isofs_vnodeops = {
	562	isofs_lookup, /* lookup */
	563	(void )enodev, / create */
	564	(void )enodev, / mknod */
	565	isofs_open, /* open */
	566	isofs_close, /* close */
	567	isofs_access, /* access */
	568	isofs_getattr, /* getattr */
	569	(void )enodev, / setattr */
	570	isofs_read, /* read */
	571	(void )enodev, / write */
	572	isofs_ioctl, /* ioctl */
	573	isofs_select, /* select */
	574	isofs_mmap, /* mmap */
	575	(void )nullop, / fsync */
	576	isofs_seek, /* seek */
	577	(void )enodev, / remove */
	578	(void )enodev, / link */
	579	(void )enodev, / rename */
	580	(void )enodev, / mkdir */
	581	(void )enodev, / rmdir */
	582	(void )enodev, / symlink */
	583	isofs_readdir, /* readdir */
584fddaa	584	isofs_readlink, /* readlink */
15637ed4 RG	585	isofs_abortop, /* abortop */
	586	isofs_inactive, /* inactive */
	587	isofs_reclaim, /* reclaim */
	588	isofs_lock, /* lock */
	589	isofs_unlock, /* unlock */
	590	(void )enodev, / bmap */
	591	isofs_strategy, /* strategy */
	592	isofs_print, /* print */
	593	isofs_islocked, /* islocked */
	594	(void )enodev, / advlock */
	595	};