[unix-history] / usr / src / sys.386bsd / isofs / isofs_vnops.c

#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"

/*
 * Open called.
 *
 * Nothing to do.
 */
/* ARGSUSED */
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 */
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.
 */
isofs_access(vp, mode, cred, p)
	struct vnode *vp;
	register int mode;
	struct ucred *cred;
	struct proc *p;
{
	return (0);
}

/* ARGSUSED */
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 year, month, day, hour ,minute, second, tz;
	int crtime, days;
	int i;

	year = ip->iso_time[0] - 70;
	month = ip->iso_time[1];
	day = ip->iso_time[2];
	hour = ip->iso_time[3];
	minute = ip->iso_time[4];
	second = ip->iso_time[5];
	tz = ip->iso_time[6];
	
	if (year < 0) {
		crtime = 0;
	} else {
		int monlen[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
		days = year * 365;
		if (year > 2)
			days += (year+2) / 4;
		for (i = 1; i < month; i++)
			days += monlen[i-1];
		if (((year+2) % 4) == 0 && month > 2)
			days++;
		days += day - 1;
		crtime = ((((days * 24) + hour) * 60 + minute) * 60)
			+ second;

		/* sign extend */
		if (tz & 0x80)
			tz |= (-1 << 8);

		/* timezone offset is unreliable on some disks */
		if (-48 <= tz && tz <= 52)
			crtime += tz * 15 * 60;
	}

	vap->va_fsid = ip->i_dev;
	vap->va_fileid = ip->i_number;
	vap->va_mode = VREAD|VEXEC;
	vap->va_mode |= (vap->va_mode >> 3) | (vap->va_mode >> 6);
	if (vp->v_type == VDIR)
		vap->va_nlink = 2;
	else
		vap->va_nlink = 1;
	vap->va_uid = 0;
	vap->va_gid = 0;
	vap->va_rdev = 0;
	vap->va_size = ip->i_size;
	vap->va_size_rsv = 0;
	vap->va_atime.tv_sec = crtime;
	vap->va_atime.tv_usec = 0;
	vap->va_mtime.tv_sec = crtime;
	vap->va_mtime.tv_usec = 0;
	vap->va_ctime.tv_sec = crtime;
	vap->va_ctime.tv_usec = 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 */
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 */
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 */
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 */
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 */
isofs_seek(vp, oldoff, newoff, cred)
	struct vnode *vp;
	off_t oldoff, newoff;
	struct ucred *cred;
{

	return (0);
}

/*
 * Vnode op for readdir
 */
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;

	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;

		if (entryoffsetinblock + reclen >= 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;

		/*bcopy (ep->name, dirent.d_name, dirent.d_namlen);*/
		isofntrans(ep->name, dirent.d_namlen,
			dirent.d_name, &dirent.d_namlen);
		if (dirent.d_namlen == 1) {
			switch (dirent.d_name[0]) {
			case 0:
				dirent.d_name[0] = '.';
				break;
			case 1:
				dirent.d_name[0] = '.';
				dirent.d_name[1] = '.';
				dirent.d_namlen = 2;
			}
		}
		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);
}

/*
 * 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 */
isofs_abortop(ndp)
	struct nameidata *ndp;
{

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

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

	ISO_ILOCK(ip);
	return (0);
}

/*
 * Unlock an inode.
 */
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.
 */
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.
 */

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