xref: /csrg-svn/sys/isofs/cd9660/cd9660_node.c (revision 65789)

/*-
 * Copyright (c) 1982, 1986, 1989, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley
 * by Pace Willisson (pace@blitz.com).  The Rock Ridge Extension
 * Support code is derived from software contributed to Berkeley
 * by Atsushi Murai (amurai@spec.co.jp).
 *
 * %sccs.include.redist.c%
 *
 *	@(#)cd9660_node.c	8.1 (Berkeley) 01/21/94
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/file.h>
#include <sys/buf.h>
#include <sys/vnode.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/stat.h>

#include <isofs/cd9660/iso.h>
#include <isofs/cd9660/isofs_node.h>
#include <isofs/cd9660/iso_rrip.h>

#define	INOHSZ	512
#if	((INOHSZ&(INOHSZ-1)) == 0)
#define	INOHASH(dev,ino)	(((dev)+((ino)>>12))&(INOHSZ-1))
#else
#define	INOHASH(dev,ino)	(((unsigned)((dev)+((ino)>>12)))%INOHSZ)
#endif

union iso_ihead {
	union  iso_ihead *ih_head[2];
	struct iso_node *ih_chain[2];
} iso_ihead[INOHSZ];

#ifdef	ISODEVMAP
#define	DNOHSZ	64
#if	((DNOHSZ&(DNOHSZ-1)) == 0)
#define	DNOHASH(dev,ino)	(((dev)+((ino)>>12))&(DNOHSZ-1))
#else
#define	DNOHASH(dev,ino)	(((unsigned)((dev)+((ino)>>12)))%DNOHSZ)
#endif

union iso_dhead {
	union  iso_dhead  *dh_head[2];
	struct iso_dnode *dh_chain[2];
} iso_dhead[DNOHSZ];
#endif

int prtactive;	/* 1 => print out reclaim of active vnodes */

/*
 * Initialize hash links for inodes and dnodes.
 */
isofs_init()
{
	register int i;
	register union iso_ihead *ih = iso_ihead;
#ifdef	ISODEVMAP
	register union iso_dhead *dh = iso_dhead;
#endif

	for (i = INOHSZ; --i >= 0; ih++) {
		ih->ih_head[0] = ih;
		ih->ih_head[1] = ih;
	}
#ifdef	ISODEVMAP
	for (i = DNOHSZ; --i >= 0; dh++) {
		dh->dh_head[0] = dh;
		dh->dh_head[1] = dh;
	}
#endif
}

#ifdef	ISODEVMAP
/*
 * Enter a new node into the device hash list
 */
struct iso_dnode *
iso_dmap(dev,ino,create)
	dev_t	dev;
	ino_t	ino;
	int	create;
{
	struct iso_dnode *dp;
	union iso_dhead *dh;

	dh = &iso_dhead[DNOHASH(dev, ino)];
	for (dp = dh->dh_chain[0];
	     dp != (struct iso_dnode *)dh;
	     dp = dp->d_forw)
		if (ino == dp->i_number && dev == dp->i_dev)
			return dp;

	if (!create)
		return (struct iso_dnode *)0;

	MALLOC(dp,struct iso_dnode *,sizeof(struct iso_dnode),M_CACHE,M_WAITOK);
	dp->i_dev = dev;
	dp->i_number = ino;
	insque(dp,dh);

	return dp;
}

void
iso_dunmap(dev)
	dev_t	dev;
{
	struct iso_dnode *dp, *dq;
	union iso_dhead *dh;

	for (dh = iso_dhead; dh < iso_dhead + DNOHSZ; dh++) {
		for (dp = dh->dh_chain[0];
		     dp != (struct iso_dnode *)dh;
		     dp = dq) {
			dq = dp->d_forw;
			if (dev == dp->i_dev) {
				remque(dp);
				FREE(dp,M_CACHE);
			}
		}
	}
}
#endif

/*
 * Look up a ISOFS dinode number to find its incore vnode.
 * If it is not in core, read it in from the specified device.
 * If it is in core, wait for the lock bit to clear, then
 * return the inode locked. Detection and handling of mount
 * points must be done by the calling routine.
 */
iso_iget(xp, ino, relocated, ipp, isodir)
	struct iso_node *xp;
	ino_t ino;
	struct iso_node **ipp;
	struct iso_directory_record *isodir;
{
	dev_t dev = xp->i_dev;
	struct mount *mntp = ITOV(xp)->v_mount;
	register struct iso_node *ip, *iq;
	register struct vnode *vp;
	register struct iso_dnode *dp;
	struct vnode *nvp;
	struct buf *bp = NULL, *bp2 = NULL;
	union iso_ihead *ih;
	union iso_dhead *dh;
	int i, error, result;
	struct iso_mnt *imp;
	ino_t defino;

	ih = &iso_ihead[INOHASH(dev, ino)];
loop:
	for (ip = ih->ih_chain[0];
	     ip != (struct iso_node *)ih;
	     ip = ip->i_forw) {
		if (ino != ip->i_number || dev != ip->i_dev)
			continue;
		if ((ip->i_flag&ILOCKED) != 0) {
			ip->i_flag |= IWANT;
			sleep((caddr_t)ip, PINOD);
			goto loop;
		}
		if (vget(ITOV(ip), 1))
			goto loop;
		*ipp = ip;
		return 0;
	}
	/*
	 * Allocate a new vnode/iso_node.
	 */
	if (error = getnewvnode(VT_ISOFS, mntp, isofs_vnodeop_p, &nvp)) {
		*ipp = 0;
		return error;
	}
	MALLOC(ip, struct iso_node *, sizeof(struct iso_node),
	       M_ISOFSNODE, M_WAITOK);
	bzero((caddr_t)ip, sizeof(struct iso_node));
	nvp->v_data = ip;
	ip->i_vnode = nvp;
	ip->i_flag = 0;
	ip->i_devvp = 0;
	ip->i_diroff = 0;
	ip->i_lockf = 0;

	/*
	 * Put it onto its hash chain and lock it so that other requests for
	 * this inode will block if they arrive while we are sleeping waiting
	 * for old data structures to be purged or for the contents of the
	 * disk portion of this inode to be read.
	 */
	ip->i_dev = dev;
	ip->i_number = ino;
	insque(ip, ih);
	ISO_ILOCK(ip);

	imp = VFSTOISOFS (mntp);
	ip->i_mnt = imp;
	ip->i_devvp = imp->im_devvp;
	VREF(ip->i_devvp);

	if (relocated) {
		/*
		 * On relocated directories we must
		 * read the `.' entry out of a dir.
		 */
		ip->iso_start = ino >> imp->im_bshift;
		if (error = iso_blkatoff(ip,0,&bp)) {
			vrele(ip->i_devvp);
			remque(ip);
			ip->i_forw = ip;
			ip->i_back = ip;
			iso_iput(ip);
			*ipp = 0;
			return error;
		}
		isodir = (struct iso_directory_record *)bp->b_un.b_addr;
	}

	ip->iso_extent = isonum_733(isodir->extent);
	ip->i_size = isonum_733(isodir->size);
	ip->iso_start = isonum_711(isodir->ext_attr_length) + ip->iso_extent;

	vp = ITOV(ip);

	/*
	 * Setup time stamp, attribute
	 */
	vp->v_type = VNON;
	switch (imp->iso_ftype) {
	default:	/* ISO_FTYPE_9660 */
		if ((imp->im_flags&ISOFSMNT_EXTATT)
		    && isonum_711(isodir->ext_attr_length))
			iso_blkatoff(ip,-isonum_711(isodir->ext_attr_length),
				     &bp2);
		isofs_defattr(isodir,ip,bp2 );
		isofs_deftstamp(isodir,ip,bp2 );
		break;
	case ISO_FTYPE_RRIP:
		result = isofs_rrip_analyze(isodir,ip,imp);
		break;
	}
	if (bp2)
		brelse(bp2);
	if (bp)
		brelse(bp);

	/*
	 * Initialize the associated vnode
	 */
	vp->v_type = IFTOVT(ip->inode.iso_mode);

	if ( vp->v_type == VFIFO ) {
#ifdef	FIFO
		extern int (**isofs_fifoop_p)();
		vp->v_op = isofs_fifoop_p;
#else
		iso_iput(ip);
		*ipp = 0;
		return EOPNOTSUPP;
#endif	/* FIFO */
	} else if ( vp->v_type == VCHR || vp->v_type == VBLK ) {
		extern int (**isofs_specop_p)();

		/*
		 * if device, look at device number table for translation
		 */
#ifdef	ISODEVMAP
		if (dp = iso_dmap(dev,ino,0))
			ip->inode.iso_rdev = dp->d_dev;
#endif
		vp->v_op = isofs_specop_p;
		if (nvp = checkalias(vp, ip->inode.iso_rdev, mntp)) {
			/*
			 * Reinitialize aliased inode.
			 */
			vp = nvp;
			iq = VTOI(vp);
			iq->i_vnode = vp;
			iq->i_flag = 0;
			ISO_ILOCK(iq);
			iq->i_dev = dev;
			iq->i_number = ino;
			iq->i_mnt = ip->i_mnt;
			bcopy(&ip->iso_extent,&iq->iso_extent,
			      (char *)(ip + 1) - (char *)&ip->iso_extent);
			insque(iq, ih);
			/*
			 * Discard unneeded vnode
			 * (This introduces the need of INACTIVE modification)
			 */
			ip->inode.iso_mode = 0;
			iso_iput(ip);
			ip = iq;
		}
	}

	if (ip->iso_extent == imp->root_extent)
		vp->v_flag |= VROOT;

	*ipp = ip;
	return 0;
}

/*
 * Unlock and decrement the reference count of an inode structure.
 */
iso_iput(ip)
	register struct iso_node *ip;
{

	if ((ip->i_flag & ILOCKED) == 0)
		panic("iso_iput");
	ISO_IUNLOCK(ip);
	vrele(ITOV(ip));
}

/*
 * Last reference to an inode, write the inode out and if necessary,
 * truncate and deallocate the file.
 */
int
isofs_inactive(ap)
	struct vop_inactive_args /* {
		struct vnode *a_vp;
	} */ *ap;
{
	struct vnode *vp = ap->a_vp;
	register struct iso_node *ip = VTOI(vp);
	int mode, error = 0;

	if (prtactive && vp->v_usecount != 0)
		vprint("isofs_inactive: pushing active", vp);

	ip->i_flag = 0;
	/*
	 * If we are done with the inode, reclaim it
	 * so that it can be reused immediately.
	 */
	if (vp->v_usecount == 0 && ip->inode.iso_mode == 0)
		vgone(vp);
	return error;
}

/*
 * Reclaim an inode so that it can be used for other purposes.
 */
int
isofs_reclaim(ap)
	struct vop_reclaim_args /* {
		struct vnode *a_vp;
	} */ *ap;
{
	register struct vnode *vp = ap->a_vp;
	register struct iso_node *ip = VTOI(vp);
	int i;

	if (prtactive && vp->v_usecount != 0)
		vprint("isofs_reclaim: pushing active", vp);
	/*
	 * Remove the inode from its hash chain.
	 */
	remque(ip);
	ip->i_forw = ip;
	ip->i_back = ip;
	/*
	 * Purge old data structures associated with the inode.
	 */
	cache_purge(vp);
	if (ip->i_devvp) {
		vrele(ip->i_devvp);
		ip->i_devvp = 0;
	}
	FREE(vp->v_data, M_ISOFSNODE);
	vp->v_data = NULL;
	return 0;
}

/*
 * Lock an inode. If its already locked, set the WANT bit and sleep.
 */
iso_ilock(ip)
	register struct iso_node *ip;
{

	while (ip->i_flag & ILOCKED) {
		ip->i_flag |= IWANT;
		if (ip->i_spare0 == curproc->p_pid)
			panic("locking against myself");
		ip->i_spare1 = curproc->p_pid;
		(void) sleep((caddr_t)ip, PINOD);
	}
	ip->i_spare1 = 0;
	ip->i_spare0 = curproc->p_pid;
	ip->i_flag |= ILOCKED;
}

/*
 * Unlock an inode.  If WANT bit is on, wakeup.
 */
iso_iunlock(ip)
	register struct iso_node *ip;
{

	if ((ip->i_flag & ILOCKED) == 0)
		vprint("iso_iunlock: unlocked inode", ITOV(ip));
	ip->i_spare0 = 0;
	ip->i_flag &= ~ILOCKED;
	if (ip->i_flag&IWANT) {
		ip->i_flag &= ~IWANT;
		wakeup((caddr_t)ip);
	}
}

/*
 * File attributes
 */
void
isofs_defattr(isodir,inop,bp)
	struct iso_directory_record *isodir;
	struct iso_node *inop;
	struct buf *bp;
{
	struct buf *bp2 = NULL;
	struct iso_mnt *imp;
	struct iso_extended_attributes *ap = NULL;
	int off;

	if (isonum_711(isodir->flags)&2) {
		inop->inode.iso_mode = S_IFDIR;
		/*
		 * If we return 2, fts() will assume there are no subdirectories
		 * (just links for the path and .), so instead we return 1.
		 */
		inop->inode.iso_links = 1;
	} else {
		inop->inode.iso_mode = S_IFREG;
		inop->inode.iso_links = 1;
	}
	if (!bp
	    && ((imp = inop->i_mnt)->im_flags&ISOFSMNT_EXTATT)
	    && (off = isonum_711(isodir->ext_attr_length))) {
		iso_blkatoff(inop,-off * imp->logical_block_size,&bp2);
		bp = bp2;
	}
	if (bp) {
		ap = (struct iso_extended_attributes *)bp->b_un.b_addr;

		if (isonum_711(ap->version) == 1) {
			if (!(ap->perm[0]&0x40))
				inop->inode.iso_mode |= VEXEC >> 6;
			if (!(ap->perm[0]&0x10))
				inop->inode.iso_mode |= VREAD >> 6;
			if (!(ap->perm[0]&4))
				inop->inode.iso_mode |= VEXEC >> 3;
			if (!(ap->perm[0]&1))
				inop->inode.iso_mode |= VREAD >> 3;
			if (!(ap->perm[1]&0x40))
				inop->inode.iso_mode |= VEXEC;
			if (!(ap->perm[1]&0x10))
				inop->inode.iso_mode |= VREAD;
			inop->inode.iso_uid = isonum_723(ap->owner); /* what about 0? */
			inop->inode.iso_gid = isonum_723(ap->group); /* what about 0? */
		} else
			ap = NULL;
	}
	if (!ap) {
		inop->inode.iso_mode |= VREAD|VEXEC|(VREAD|VEXEC)>>3|(VREAD|VEXEC)>>6;
		inop->inode.iso_uid = (uid_t)0;
		inop->inode.iso_gid = (gid_t)0;
	}
	if (bp2)
		brelse(bp2);
}

/*
 * Time stamps
 */
void
isofs_deftstamp(isodir,inop,bp)
	struct iso_directory_record *isodir;
	struct iso_node *inop;
	struct buf *bp;
{
	struct buf *bp2 = NULL;
	struct iso_mnt *imp;
	struct iso_extended_attributes *ap = NULL;
	int off;

	if (!bp
	    && ((imp = inop->i_mnt)->im_flags&ISOFSMNT_EXTATT)
	    && (off = isonum_711(isodir->ext_attr_length))) {
		iso_blkatoff(inop,-off * imp->logical_block_size,&bp2);
		bp = bp2;
	}
	if (bp) {
		ap = (struct iso_extended_attributes *)bp->b_un.b_addr;

		if (isonum_711(ap->version) == 1) {
			if (!isofs_tstamp_conv17(ap->ftime,&inop->inode.iso_atime))
				isofs_tstamp_conv17(ap->ctime,&inop->inode.iso_atime);
			if (!isofs_tstamp_conv17(ap->ctime,&inop->inode.iso_ctime))
				inop->inode.iso_ctime = inop->inode.iso_atime;
			if (!isofs_tstamp_conv17(ap->mtime,&inop->inode.iso_mtime))
				inop->inode.iso_mtime = inop->inode.iso_ctime;
		} else
			ap = NULL;
	}
	if (!ap) {
		isofs_tstamp_conv7(isodir->date,&inop->inode.iso_ctime);
		inop->inode.iso_atime = inop->inode.iso_ctime;
		inop->inode.iso_mtime = inop->inode.iso_ctime;
	}
	if (bp2)
		brelse(bp2);
}

int
isofs_tstamp_conv7(pi,pu)
char *pi;
struct timeval *pu;
{
	int i;
	int crtime, days;
	int y, m, d, hour, minute, second, tz;

	y = pi[0] + 1900;
	m = pi[1];
	d = pi[2];
	hour = pi[3];
	minute = pi[4];
	second = pi[5];
	tz = pi[6];

	if (y < 1970) {
		pu->tv_sec  = 0;
		pu->tv_usec = 0;
		return 0;
	} else {
#ifdef	ORIGINAL
		/* computes day number relative to Sept. 19th,1989 */
		/* don't even *THINK* about changing formula. It works! */
		days = 367*(y-1980)-7*(y+(m+9)/12)/4-3*((y+(m-9)/7)/100+1)/4+275*m/9+d-100;
#else
		/*
		 * Changed :-) to make it relative to Jan. 1st, 1970
		 * and to disambiguate negative division
		 */
		days = 367*(y-1960)-7*(y+(m+9)/12)/4-3*((y+(m+9)/12-1)/100+1)/4+275*m/9+d-239;
#endif
		crtime = ((((days * 24) + hour) * 60 + minute) * 60) + second;

		/* timezone offset is unreliable on some disks */
		if (-48 <= tz && tz <= 52)
			crtime += tz * 15 * 60;
	}
	pu->tv_sec  = crtime;
	pu->tv_usec = 0;
	return 1;
}

static unsigned
isofs_chars2ui(begin,len)
	unsigned char *begin;
	int len;
{
	unsigned rc;

	for (rc = 0; --len >= 0;) {
		rc *= 10;
		rc += *begin++ - '0';
	}
	return rc;
}

int
isofs_tstamp_conv17(pi,pu)
	unsigned char *pi;
	struct timeval *pu;
{
	unsigned char buf[7];

	/* year:"0001"-"9999" -> -1900  */
	buf[0] = isofs_chars2ui(pi,4) - 1900;

	/* month: " 1"-"12"      -> 1 - 12 */
	buf[1] = isofs_chars2ui(pi + 4,2);

	/* day:   " 1"-"31"      -> 1 - 31 */
	buf[2] = isofs_chars2ui(pi + 6,2);

	/* hour:  " 0"-"23"      -> 0 - 23 */
	buf[3] = isofs_chars2ui(pi + 8,2);

	/* minute:" 0"-"59"      -> 0 - 59 */
	buf[4] = isofs_chars2ui(pi + 10,2);

	/* second:" 0"-"59"      -> 0 - 59 */
	buf[5] = isofs_chars2ui(pi + 12,2);

	/* difference of GMT */
	buf[6] = pi[16];

	return isofs_tstamp_conv7(buf,pu);
}

void
isodirino(inump,isodir,imp)
	ino_t *inump;
	struct iso_directory_record *isodir;
	struct iso_mnt *imp;
{
	*inump = (isonum_733(isodir->extent) + isonum_711(isodir->ext_attr_length))
		 * imp->logical_block_size;
}