xref: /illumos-gate/usr/src/common/fs/ufsops.c (revision 48bbca81)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21342440ecSPrasad Singamsetty 
227c478bd9Sstevel@tonic-gate /*
23342440ecSPrasad Singamsetty  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
25*48bbca81SDaniel Hoffman  * Copyright (c) 2016 by Delphix. All rights reserved.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate #include <sys/types.h>
297c478bd9Sstevel@tonic-gate #include <sys/param.h>
307c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
317c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h>
327c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fs.h>
337c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_inode.h>
347c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
357c478bd9Sstevel@tonic-gate #include <sys/bootvfs.h>
367c478bd9Sstevel@tonic-gate #include <sys/filep.h>
377c478bd9Sstevel@tonic-gate 
387c478bd9Sstevel@tonic-gate #ifdef	_BOOT
397c478bd9Sstevel@tonic-gate #include "../common/util.h"
407c478bd9Sstevel@tonic-gate #else
417c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
427c478bd9Sstevel@tonic-gate #endif
437c478bd9Sstevel@tonic-gate 
447c478bd9Sstevel@tonic-gate extern void *bkmem_alloc(size_t);
457c478bd9Sstevel@tonic-gate extern void bkmem_free(void *, size_t);
46ae115bc7Smrj extern int cf_check_compressed(fileid_t *);
47ae115bc7Smrj extern void cf_close(fileid_t *);
48ae115bc7Smrj extern void cf_seek(fileid_t *, off_t, int);
49ae115bc7Smrj extern int cf_read(fileid_t *, caddr_t, size_t);
507c478bd9Sstevel@tonic-gate 
517c478bd9Sstevel@tonic-gate int bootrd_debug;
527c478bd9Sstevel@tonic-gate #ifdef _BOOT
537c478bd9Sstevel@tonic-gate #define	dprintf	if (bootrd_debug) printf
547c478bd9Sstevel@tonic-gate #else
557c478bd9Sstevel@tonic-gate #define	printf	kobj_printf
567c478bd9Sstevel@tonic-gate #define	dprintf	if (bootrd_debug) kobj_printf
577c478bd9Sstevel@tonic-gate 
587c478bd9Sstevel@tonic-gate /* PRINTLIKE */
597c478bd9Sstevel@tonic-gate extern void kobj_printf(char *, ...);
607c478bd9Sstevel@tonic-gate #endif
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate /*
637c478bd9Sstevel@tonic-gate  * This fd is used when talking to the device file itself.
647c478bd9Sstevel@tonic-gate  */
657c478bd9Sstevel@tonic-gate static fileid_t *head;
667c478bd9Sstevel@tonic-gate 
677c478bd9Sstevel@tonic-gate /* Only got one of these...ergo, only 1 fs open at once */
687c478bd9Sstevel@tonic-gate /* static */
697c478bd9Sstevel@tonic-gate devid_t		*ufs_devp;
707c478bd9Sstevel@tonic-gate 
717c478bd9Sstevel@tonic-gate struct dirinfo {
727c478bd9Sstevel@tonic-gate 	int 	loc;
737c478bd9Sstevel@tonic-gate 	fileid_t *fi;
747c478bd9Sstevel@tonic-gate };
757c478bd9Sstevel@tonic-gate 
767c478bd9Sstevel@tonic-gate static	int	bufs_close(int);
777c478bd9Sstevel@tonic-gate static	void	bufs_closeall(int);
787c478bd9Sstevel@tonic-gate static 	ino_t	find(fileid_t *filep, char *path);
797c478bd9Sstevel@tonic-gate static	ino_t	dlook(fileid_t *filep, char *path);
807c478bd9Sstevel@tonic-gate static 	daddr32_t	sbmap(fileid_t *filep, daddr32_t bn);
817c478bd9Sstevel@tonic-gate static  struct direct *readdir(struct dirinfo *dstuff);
827c478bd9Sstevel@tonic-gate static	void set_cache(int, void *, uint_t);
837c478bd9Sstevel@tonic-gate static	void *get_cache(int);
847c478bd9Sstevel@tonic-gate static	void free_cache();
857c478bd9Sstevel@tonic-gate 
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate /*
887c478bd9Sstevel@tonic-gate  *	There is only 1 open (mounted) device at any given time.
897c478bd9Sstevel@tonic-gate  *	So we can keep a single, global devp file descriptor to
907c478bd9Sstevel@tonic-gate  *	use to index into the di[] array.  This is not true for the
917c478bd9Sstevel@tonic-gate  *	fi[] array.  We can have more than one file open at once,
927c478bd9Sstevel@tonic-gate  *	so there is no global fd for the fi[].
937c478bd9Sstevel@tonic-gate  *	The user program must save the fd passed back from open()
947c478bd9Sstevel@tonic-gate  *	and use it to do subsequent read()'s.
957c478bd9Sstevel@tonic-gate  */
967c478bd9Sstevel@tonic-gate 
977c478bd9Sstevel@tonic-gate static int
987c478bd9Sstevel@tonic-gate openi(fileid_t *filep, ino_t inode)
997c478bd9Sstevel@tonic-gate {
1007c478bd9Sstevel@tonic-gate 	struct dinode *dp;
1017c478bd9Sstevel@tonic-gate 	devid_t *devp = filep->fi_devp;
1027c478bd9Sstevel@tonic-gate 
1037c478bd9Sstevel@tonic-gate 	filep->fi_inode = get_cache((int)inode);
1047c478bd9Sstevel@tonic-gate 	if (filep->fi_inode != 0)
1057c478bd9Sstevel@tonic-gate 		return (0);
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate 	filep->fi_offset = 0;
1087c478bd9Sstevel@tonic-gate 	filep->fi_blocknum = fsbtodb(&devp->un_fs.di_fs,
109342440ecSPrasad Singamsetty 	    itod(&devp->un_fs.di_fs, inode));
1107c478bd9Sstevel@tonic-gate 
1117c478bd9Sstevel@tonic-gate 	/* never more than 1 disk block */
1127c478bd9Sstevel@tonic-gate 	filep->fi_count = devp->un_fs.di_fs.fs_bsize;
1137c478bd9Sstevel@tonic-gate 	filep->fi_memp = 0;		/* cached read */
1147c478bd9Sstevel@tonic-gate 	if (diskread(filep) != 0) {
1157c478bd9Sstevel@tonic-gate 		return (0);
1167c478bd9Sstevel@tonic-gate 	}
1177c478bd9Sstevel@tonic-gate 
1187c478bd9Sstevel@tonic-gate 	dp = (struct dinode *)filep->fi_memp;
1197c478bd9Sstevel@tonic-gate 	filep->fi_inode = (struct inode *)
1207c478bd9Sstevel@tonic-gate 	    bkmem_alloc(sizeof (struct inode));
1217c478bd9Sstevel@tonic-gate 	bzero((char *)filep->fi_inode, sizeof (struct inode));
1227c478bd9Sstevel@tonic-gate 	filep->fi_inode->i_ic =
1237c478bd9Sstevel@tonic-gate 	    dp[itoo(&devp->un_fs.di_fs, inode)].di_un.di_icom;
1247c478bd9Sstevel@tonic-gate 	filep->fi_inode->i_number = inode;
1257c478bd9Sstevel@tonic-gate 	set_cache((int)inode, (void *)filep->fi_inode, sizeof (struct inode));
1267c478bd9Sstevel@tonic-gate 	return (0);
1277c478bd9Sstevel@tonic-gate }
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate static fileid_t *
1307c478bd9Sstevel@tonic-gate find_fp(int fd)
1317c478bd9Sstevel@tonic-gate {
1327c478bd9Sstevel@tonic-gate 	fileid_t *filep = head;
1337c478bd9Sstevel@tonic-gate 
1347c478bd9Sstevel@tonic-gate 	if (fd >= 0) {
1357c478bd9Sstevel@tonic-gate 		while ((filep = filep->fi_forw) != head)
1367c478bd9Sstevel@tonic-gate 			if (fd == filep->fi_filedes)
1377c478bd9Sstevel@tonic-gate 				return (filep->fi_taken ? filep : 0);
1387c478bd9Sstevel@tonic-gate 	}
1397c478bd9Sstevel@tonic-gate 
1407c478bd9Sstevel@tonic-gate 	return (0);
1417c478bd9Sstevel@tonic-gate }
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate static ino_t
1447c478bd9Sstevel@tonic-gate find(fileid_t *filep, char *path)
1457c478bd9Sstevel@tonic-gate {
1467c478bd9Sstevel@tonic-gate 	char *q;
1477c478bd9Sstevel@tonic-gate 	char c;
1487c478bd9Sstevel@tonic-gate 	ino_t inode;
1497c478bd9Sstevel@tonic-gate 	char lpath[MAXPATHLEN];
1507c478bd9Sstevel@tonic-gate 	char *lpathp = lpath;
1517c478bd9Sstevel@tonic-gate 	int len, r;
1527c478bd9Sstevel@tonic-gate 	devid_t	*devp;
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate 	if (path == NULL || *path == '\0') {
1557c478bd9Sstevel@tonic-gate 		printf("null path\n");
1567c478bd9Sstevel@tonic-gate 		return ((ino_t)0);
1577c478bd9Sstevel@tonic-gate 	}
1587c478bd9Sstevel@tonic-gate 
1597c478bd9Sstevel@tonic-gate 	dprintf("openi: %s\n", path);
1607c478bd9Sstevel@tonic-gate 
1617c478bd9Sstevel@tonic-gate 	bzero(lpath, sizeof (lpath));
1627c478bd9Sstevel@tonic-gate 	bcopy(path, lpath, strlen(path));
1637c478bd9Sstevel@tonic-gate 	devp = filep->fi_devp;
1647c478bd9Sstevel@tonic-gate 	while (*lpathp) {
1657c478bd9Sstevel@tonic-gate 		/* if at the beginning of pathname get root inode */
1667c478bd9Sstevel@tonic-gate 		r = (lpathp == lpath);
1677c478bd9Sstevel@tonic-gate 		if (r && openi(filep, (ino_t)UFSROOTINO))
1687c478bd9Sstevel@tonic-gate 			return ((ino_t)0);
1697c478bd9Sstevel@tonic-gate 		while (*lpathp == '/')
1707c478bd9Sstevel@tonic-gate 			lpathp++;	/* skip leading slashes */
1717c478bd9Sstevel@tonic-gate 		q = lpathp;
1727c478bd9Sstevel@tonic-gate 		while (*q != '/' && *q != '\0')
1737c478bd9Sstevel@tonic-gate 			q++;		/* find end of component */
1747c478bd9Sstevel@tonic-gate 		c = *q;
1757c478bd9Sstevel@tonic-gate 		*q = '\0';		/* terminate component */
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate 		/* Bail out early if opening root */
1787c478bd9Sstevel@tonic-gate 		if (r && (*lpathp == '\0'))
1797c478bd9Sstevel@tonic-gate 			return ((ino_t)UFSROOTINO);
1807c478bd9Sstevel@tonic-gate 		if ((inode = dlook(filep, lpathp)) != 0) {
1817c478bd9Sstevel@tonic-gate 			if (openi(filep, inode))
1827c478bd9Sstevel@tonic-gate 				return ((ino_t)0);
1837c478bd9Sstevel@tonic-gate 			if ((filep->fi_inode->i_smode & IFMT) == IFLNK) {
1847c478bd9Sstevel@tonic-gate 				filep->fi_blocknum =
1857c478bd9Sstevel@tonic-gate 				    fsbtodb(&devp->un_fs.di_fs,
1867c478bd9Sstevel@tonic-gate 				    filep->fi_inode->i_db[0]);
1877c478bd9Sstevel@tonic-gate 				filep->fi_count = DEV_BSIZE;
1887c478bd9Sstevel@tonic-gate 				filep->fi_memp = 0;
1897c478bd9Sstevel@tonic-gate 				if (diskread(filep) != 0)
1907c478bd9Sstevel@tonic-gate 					return ((ino_t)0);
1917c478bd9Sstevel@tonic-gate 				len = strlen(filep->fi_memp);
1927c478bd9Sstevel@tonic-gate 				if (filep->fi_memp[0] == '/')
1937c478bd9Sstevel@tonic-gate 					/* absolute link */
1947c478bd9Sstevel@tonic-gate 					lpathp = lpath;
1957c478bd9Sstevel@tonic-gate 				/* copy rest of unprocessed path up */
1967c478bd9Sstevel@tonic-gate 				bcopy(q, lpathp + len, strlen(q + 1) + 2);
1977c478bd9Sstevel@tonic-gate 				/* point to unprocessed path */
1987c478bd9Sstevel@tonic-gate 				*(lpathp + len) = c;
1997c478bd9Sstevel@tonic-gate 				/* prepend link in before unprocessed path */
2007c478bd9Sstevel@tonic-gate 				bcopy(filep->fi_memp, lpathp, len);
2017c478bd9Sstevel@tonic-gate 				lpathp = lpath;
2027c478bd9Sstevel@tonic-gate 				continue;
2037c478bd9Sstevel@tonic-gate 			} else
2047c478bd9Sstevel@tonic-gate 				*q = c;
2057c478bd9Sstevel@tonic-gate 			if (c == '\0')
2067c478bd9Sstevel@tonic-gate 				break;
2077c478bd9Sstevel@tonic-gate 			lpathp = q;
2087c478bd9Sstevel@tonic-gate 			continue;
2097c478bd9Sstevel@tonic-gate 		} else {
2107c478bd9Sstevel@tonic-gate 			return ((ino_t)0);
2117c478bd9Sstevel@tonic-gate 		}
2127c478bd9Sstevel@tonic-gate 	}
2137c478bd9Sstevel@tonic-gate 	return (inode);
2147c478bd9Sstevel@tonic-gate }
2157c478bd9Sstevel@tonic-gate 
2167c478bd9Sstevel@tonic-gate static daddr32_t
2177c478bd9Sstevel@tonic-gate sbmap(fileid_t *filep, daddr32_t bn)
2187c478bd9Sstevel@tonic-gate {
2197c478bd9Sstevel@tonic-gate 	struct inode *inodep;
2207c478bd9Sstevel@tonic-gate 	int i, j, sh;
2217c478bd9Sstevel@tonic-gate 	daddr32_t nb, *bap;
2227c478bd9Sstevel@tonic-gate 	daddr32_t *db;
2237c478bd9Sstevel@tonic-gate 	devid_t	*devp;
2247c478bd9Sstevel@tonic-gate 
2257c478bd9Sstevel@tonic-gate 	devp = filep->fi_devp;
2267c478bd9Sstevel@tonic-gate 	inodep = filep->fi_inode;
2277c478bd9Sstevel@tonic-gate 	db = inodep->i_db;
2287c478bd9Sstevel@tonic-gate 
2297c478bd9Sstevel@tonic-gate 	/*
2307c478bd9Sstevel@tonic-gate 	 * blocks 0..NDADDR are direct blocks
2317c478bd9Sstevel@tonic-gate 	 */
2327c478bd9Sstevel@tonic-gate 	if (bn < NDADDR) {
2337c478bd9Sstevel@tonic-gate 		nb = db[bn];
2347c478bd9Sstevel@tonic-gate 		return (nb);
2357c478bd9Sstevel@tonic-gate 	}
2367c478bd9Sstevel@tonic-gate 
2377c478bd9Sstevel@tonic-gate 	/*
2387c478bd9Sstevel@tonic-gate 	 * addresses NIADDR have single and double indirect blocks.
2397c478bd9Sstevel@tonic-gate 	 * the first step is to determine how many levels of indirection.
2407c478bd9Sstevel@tonic-gate 	 */
2417c478bd9Sstevel@tonic-gate 	sh = 1;
2427c478bd9Sstevel@tonic-gate 	bn -= NDADDR;
2437c478bd9Sstevel@tonic-gate 	for (j = NIADDR; j > 0; j--) {
2447c478bd9Sstevel@tonic-gate 		sh *= NINDIR(&devp->un_fs.di_fs);
2457c478bd9Sstevel@tonic-gate 		if (bn < sh)
2467c478bd9Sstevel@tonic-gate 			break;
2477c478bd9Sstevel@tonic-gate 		bn -= sh;
2487c478bd9Sstevel@tonic-gate 	}
2497c478bd9Sstevel@tonic-gate 	if (j == 0) {
2507c478bd9Sstevel@tonic-gate 		return ((daddr32_t)0);
2517c478bd9Sstevel@tonic-gate 	}
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	/*
2547c478bd9Sstevel@tonic-gate 	 * fetch the first indirect block address from the inode
2557c478bd9Sstevel@tonic-gate 	 */
2567c478bd9Sstevel@tonic-gate 	nb = inodep->i_ib[NIADDR - j];
2577c478bd9Sstevel@tonic-gate 	if (nb == 0) {
2587c478bd9Sstevel@tonic-gate 		return ((daddr32_t)0);
2597c478bd9Sstevel@tonic-gate 	}
2607c478bd9Sstevel@tonic-gate 
2617c478bd9Sstevel@tonic-gate 	/*
2627c478bd9Sstevel@tonic-gate 	 * fetch through the indirect blocks
2637c478bd9Sstevel@tonic-gate 	 */
2647c478bd9Sstevel@tonic-gate 	for (; j <= NIADDR; j++) {
265941880d6Saf 		filep->fi_blocknum = fsbtodb(&devp->un_fs.di_fs, nb);
266941880d6Saf 		filep->fi_count = devp->un_fs.di_fs.fs_bsize;
267941880d6Saf 		filep->fi_memp = 0;
268941880d6Saf 		if (diskread(filep) != 0)
269941880d6Saf 			return (0);
270941880d6Saf 		bap = (daddr32_t *)filep->fi_memp;
2717c478bd9Sstevel@tonic-gate 		sh /= NINDIR(&devp->un_fs.di_fs);
2727c478bd9Sstevel@tonic-gate 		i = (bn / sh) % NINDIR(&devp->un_fs.di_fs);
2737c478bd9Sstevel@tonic-gate 		nb = bap[i];
2747c478bd9Sstevel@tonic-gate 		if (nb == 0) {
2757c478bd9Sstevel@tonic-gate 			return ((daddr32_t)0);
2767c478bd9Sstevel@tonic-gate 		}
2777c478bd9Sstevel@tonic-gate 	}
2787c478bd9Sstevel@tonic-gate 	return (nb);
2797c478bd9Sstevel@tonic-gate }
2807c478bd9Sstevel@tonic-gate 
2817c478bd9Sstevel@tonic-gate static ino_t
2827c478bd9Sstevel@tonic-gate dlook(fileid_t *filep, char *path)
2837c478bd9Sstevel@tonic-gate {
2847c478bd9Sstevel@tonic-gate 	struct direct *dp;
2857c478bd9Sstevel@tonic-gate 	struct inode *ip;
2867c478bd9Sstevel@tonic-gate 	struct dirinfo dirp;
2877c478bd9Sstevel@tonic-gate 	int len;
2887c478bd9Sstevel@tonic-gate 
2897c478bd9Sstevel@tonic-gate 	ip = filep->fi_inode;
2907c478bd9Sstevel@tonic-gate 	if (path == NULL || *path == '\0')
2917c478bd9Sstevel@tonic-gate 		return (0);
2927c478bd9Sstevel@tonic-gate 
2937c478bd9Sstevel@tonic-gate 	dprintf("dlook: %s\n", path);
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate 	if ((ip->i_smode & IFMT) != IFDIR) {
2967c478bd9Sstevel@tonic-gate 		return (0);
2977c478bd9Sstevel@tonic-gate 	}
2987c478bd9Sstevel@tonic-gate 	if (ip->i_size == 0) {
2997c478bd9Sstevel@tonic-gate 		return (0);
3007c478bd9Sstevel@tonic-gate 	}
3017c478bd9Sstevel@tonic-gate 	len = strlen(path);
3027c478bd9Sstevel@tonic-gate 	dirp.loc = 0;
3037c478bd9Sstevel@tonic-gate 	dirp.fi = filep;
3047c478bd9Sstevel@tonic-gate 	for (dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
3057c478bd9Sstevel@tonic-gate 		if (dp->d_ino == 0)
3067c478bd9Sstevel@tonic-gate 			continue;
3077c478bd9Sstevel@tonic-gate 		if (dp->d_namlen == len && strcmp(path, dp->d_name) == 0) {
3087c478bd9Sstevel@tonic-gate 			return (dp->d_ino);
3097c478bd9Sstevel@tonic-gate 		}
3107c478bd9Sstevel@tonic-gate 		/* Allow "*" to print all names at that level, w/out match */
3117c478bd9Sstevel@tonic-gate 		if (strcmp(path, "*") == 0)
3127c478bd9Sstevel@tonic-gate 			dprintf("%s\n", dp->d_name);
3137c478bd9Sstevel@tonic-gate 	}
3147c478bd9Sstevel@tonic-gate 	return (0);
3157c478bd9Sstevel@tonic-gate }
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate /*
3187c478bd9Sstevel@tonic-gate  * get next entry in a directory.
3197c478bd9Sstevel@tonic-gate  */
3207c478bd9Sstevel@tonic-gate struct direct *
3217c478bd9Sstevel@tonic-gate readdir(struct dirinfo *dstuff)
3227c478bd9Sstevel@tonic-gate {
3237c478bd9Sstevel@tonic-gate 	struct direct *dp;
3247c478bd9Sstevel@tonic-gate 	fileid_t *filep;
3257c478bd9Sstevel@tonic-gate 	daddr32_t lbn, d;
3267c478bd9Sstevel@tonic-gate 	int off;
3277c478bd9Sstevel@tonic-gate 	devid_t	*devp;
3287c478bd9Sstevel@tonic-gate 
3297c478bd9Sstevel@tonic-gate 	filep = dstuff->fi;
3307c478bd9Sstevel@tonic-gate 	devp = filep->fi_devp;
3317c478bd9Sstevel@tonic-gate 	for (;;) {
3327c478bd9Sstevel@tonic-gate 		if (dstuff->loc >= filep->fi_inode->i_size) {
3337c478bd9Sstevel@tonic-gate 			return (NULL);
3347c478bd9Sstevel@tonic-gate 		}
3357c478bd9Sstevel@tonic-gate 		off = blkoff(&devp->un_fs.di_fs, dstuff->loc);
3367c478bd9Sstevel@tonic-gate 		dprintf("readdir: off = 0x%x\n", off);
3377c478bd9Sstevel@tonic-gate 		if (off == 0) {
3387c478bd9Sstevel@tonic-gate 			lbn = lblkno(&devp->un_fs.di_fs, dstuff->loc);
3397c478bd9Sstevel@tonic-gate 			d = sbmap(filep, lbn);
3407c478bd9Sstevel@tonic-gate 
3417c478bd9Sstevel@tonic-gate 			if (d == 0)
3427c478bd9Sstevel@tonic-gate 				return (NULL);
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 			filep->fi_blocknum = fsbtodb(&devp->un_fs.di_fs, d);
3457c478bd9Sstevel@tonic-gate 			filep->fi_count =
3467c478bd9Sstevel@tonic-gate 			    blksize(&devp->un_fs.di_fs, filep->fi_inode, lbn);
3477c478bd9Sstevel@tonic-gate 			filep->fi_memp = 0;
3487c478bd9Sstevel@tonic-gate 			if (diskread(filep) != 0) {
3497c478bd9Sstevel@tonic-gate 				return (NULL);
3507c478bd9Sstevel@tonic-gate 			}
3517c478bd9Sstevel@tonic-gate 		}
3527c478bd9Sstevel@tonic-gate 		dp = (struct direct *)(filep->fi_memp + off);
3537c478bd9Sstevel@tonic-gate 		dstuff->loc += dp->d_reclen;
3547c478bd9Sstevel@tonic-gate 		if (dp->d_ino == 0)
3557c478bd9Sstevel@tonic-gate 			continue;
3567c478bd9Sstevel@tonic-gate 		dprintf("readdir: name = %s\n", dp->d_name);
3577c478bd9Sstevel@tonic-gate 		return (dp);
3587c478bd9Sstevel@tonic-gate 	}
3597c478bd9Sstevel@tonic-gate }
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate /*
3627c478bd9Sstevel@tonic-gate  * Get the next block of data from the file.  If possible, dma right into
3637c478bd9Sstevel@tonic-gate  * user's buffer
3647c478bd9Sstevel@tonic-gate  */
3657c478bd9Sstevel@tonic-gate static int
3667c478bd9Sstevel@tonic-gate getblock(fileid_t *filep, caddr_t buf, int count, int *rcount)
3677c478bd9Sstevel@tonic-gate {
3687c478bd9Sstevel@tonic-gate 	struct fs *fs;
3697c478bd9Sstevel@tonic-gate 	caddr_t p;
3707c478bd9Sstevel@tonic-gate 	int off, size, diff;
3717c478bd9Sstevel@tonic-gate 	daddr32_t lbn;
3727c478bd9Sstevel@tonic-gate 	devid_t	*devp;
3737c478bd9Sstevel@tonic-gate 
3747c478bd9Sstevel@tonic-gate 	dprintf("getblock: buf 0x%p, count 0x%x\n", (void *)buf, count);
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 	devp = filep->fi_devp;
3777c478bd9Sstevel@tonic-gate 	p = filep->fi_memp;
3787c478bd9Sstevel@tonic-gate 	if ((signed)filep->fi_count <= 0) {
3797c478bd9Sstevel@tonic-gate 
3807c478bd9Sstevel@tonic-gate 		/* find the amt left to be read in the file */
3817c478bd9Sstevel@tonic-gate 		diff = filep->fi_inode->i_size - filep->fi_offset;
3827c478bd9Sstevel@tonic-gate 		if (diff <= 0) {
3837c478bd9Sstevel@tonic-gate 			printf("Short read\n");
3847c478bd9Sstevel@tonic-gate 			return (-1);
3857c478bd9Sstevel@tonic-gate 		}
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 		fs = &devp->un_fs.di_fs;
3887c478bd9Sstevel@tonic-gate 		/* which block (or frag) in the file do we read? */
3897c478bd9Sstevel@tonic-gate 		lbn = lblkno(fs, filep->fi_offset);
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate 		/* which physical block on the device do we read? */
3927c478bd9Sstevel@tonic-gate 		filep->fi_blocknum = fsbtodb(fs, sbmap(filep, lbn));
3937c478bd9Sstevel@tonic-gate 
3947c478bd9Sstevel@tonic-gate 		off = blkoff(fs, filep->fi_offset);
3957c478bd9Sstevel@tonic-gate 
3967c478bd9Sstevel@tonic-gate 		/* either blksize or fragsize */
3977c478bd9Sstevel@tonic-gate 		size = blksize(fs, filep->fi_inode, lbn);
3987c478bd9Sstevel@tonic-gate 		filep->fi_count = size;
3997c478bd9Sstevel@tonic-gate 		filep->fi_memp = filep->fi_buf;
4007c478bd9Sstevel@tonic-gate 
4017c478bd9Sstevel@tonic-gate 		/*
4027c478bd9Sstevel@tonic-gate 		 * optimization if we are reading large blocks of data then
4037c478bd9Sstevel@tonic-gate 		 * we can go directly to user's buffer
4047c478bd9Sstevel@tonic-gate 		 */
4057c478bd9Sstevel@tonic-gate 		*rcount = 0;
4067c478bd9Sstevel@tonic-gate 		if (off == 0 && count >= size) {
4077c478bd9Sstevel@tonic-gate 			filep->fi_memp = buf;
4087c478bd9Sstevel@tonic-gate 			if (diskread(filep)) {
4097c478bd9Sstevel@tonic-gate 				return (-1);
4107c478bd9Sstevel@tonic-gate 			}
4117c478bd9Sstevel@tonic-gate 			*rcount = size;
4127c478bd9Sstevel@tonic-gate 			filep->fi_count = 0;
4137c478bd9Sstevel@tonic-gate 			return (0);
4147c478bd9Sstevel@tonic-gate 		} else if (diskread(filep))
4157c478bd9Sstevel@tonic-gate 			return (-1);
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 		if (filep->fi_offset - off + size >= filep->fi_inode->i_size)
4187c478bd9Sstevel@tonic-gate 			filep->fi_count = diff + off;
4197c478bd9Sstevel@tonic-gate 		filep->fi_count -= off;
4207c478bd9Sstevel@tonic-gate 		p = &filep->fi_memp[off];
4217c478bd9Sstevel@tonic-gate 	}
4227c478bd9Sstevel@tonic-gate 	filep->fi_memp = p;
4237c478bd9Sstevel@tonic-gate 	return (0);
4247c478bd9Sstevel@tonic-gate }
4257c478bd9Sstevel@tonic-gate 
426ae115bc7Smrj /*
427ae115bc7Smrj  * Get the next block of data from the file.  Don't attempt to go directly
428ae115bc7Smrj  * to user's buffer.
429ae115bc7Smrj  */
430ae115bc7Smrj static int
431ae115bc7Smrj getblock_noopt(fileid_t *filep)
432ae115bc7Smrj {
433ae115bc7Smrj 	struct fs *fs;
434ae115bc7Smrj 	caddr_t p;
435ae115bc7Smrj 	int off, size, diff;
436ae115bc7Smrj 	daddr32_t lbn;
437ae115bc7Smrj 	devid_t	*devp;
438ae115bc7Smrj 
439ae115bc7Smrj 	dprintf("getblock_noopt: start\n");
440ae115bc7Smrj 
441ae115bc7Smrj 	devp = filep->fi_devp;
442ae115bc7Smrj 	p = filep->fi_memp;
443ae115bc7Smrj 	if ((signed)filep->fi_count <= 0) {
444ae115bc7Smrj 
445ae115bc7Smrj 		/* find the amt left to be read in the file */
446ae115bc7Smrj 		diff = filep->fi_inode->i_size - filep->fi_offset;
447ae115bc7Smrj 		if (diff <= 0) {
448ae115bc7Smrj 			printf("Short read\n");
449ae115bc7Smrj 			return (-1);
450ae115bc7Smrj 		}
451ae115bc7Smrj 
452ae115bc7Smrj 		fs = &devp->un_fs.di_fs;
453ae115bc7Smrj 		/* which block (or frag) in the file do we read? */
454ae115bc7Smrj 		lbn = lblkno(fs, filep->fi_offset);
455ae115bc7Smrj 
456ae115bc7Smrj 		/* which physical block on the device do we read? */
457ae115bc7Smrj 		filep->fi_blocknum = fsbtodb(fs, sbmap(filep, lbn));
458ae115bc7Smrj 
459ae115bc7Smrj 		off = blkoff(fs, filep->fi_offset);
460ae115bc7Smrj 
461ae115bc7Smrj 		/* either blksize or fragsize */
462ae115bc7Smrj 		size = blksize(fs, filep->fi_inode, lbn);
463ae115bc7Smrj 		filep->fi_count = size;
464ae115bc7Smrj 		/* reading on a ramdisk, just get a pointer to the data */
465ae115bc7Smrj 		filep->fi_memp = NULL;
466ae115bc7Smrj 
467ae115bc7Smrj 		if (diskread(filep))
468ae115bc7Smrj 			return (-1);
469ae115bc7Smrj 
470ae115bc7Smrj 		if (filep->fi_offset - off + size >= filep->fi_inode->i_size)
471ae115bc7Smrj 			filep->fi_count = diff + off;
472ae115bc7Smrj 		filep->fi_count -= off;
473ae115bc7Smrj 		p = &filep->fi_memp[off];
474ae115bc7Smrj 	}
475ae115bc7Smrj 	filep->fi_memp = p;
476ae115bc7Smrj 	return (0);
477ae115bc7Smrj }
478ae115bc7Smrj 
4797c478bd9Sstevel@tonic-gate 
4807c478bd9Sstevel@tonic-gate /*
4817c478bd9Sstevel@tonic-gate  *  This is the high-level read function.  It works like this.
4827c478bd9Sstevel@tonic-gate  *  We assume that our IO device buffers up some amount of
4837c478bd9Sstevel@tonic-gate  *  data and that we can get a ptr to it.  Thus we need
4847c478bd9Sstevel@tonic-gate  *  to actually call the device func about filesize/blocksize times
4857c478bd9Sstevel@tonic-gate  *  and this greatly increases our IO speed.  When we already
4867c478bd9Sstevel@tonic-gate  *  have data in the buffer, we just return that data (with bcopy() ).
4877c478bd9Sstevel@tonic-gate  */
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate static ssize_t
4907c478bd9Sstevel@tonic-gate bufs_read(int fd, caddr_t buf, size_t count)
4917c478bd9Sstevel@tonic-gate {
4927c478bd9Sstevel@tonic-gate 	size_t i, j;
4937c478bd9Sstevel@tonic-gate 	caddr_t	n;
4947c478bd9Sstevel@tonic-gate 	int rcount;
4957c478bd9Sstevel@tonic-gate 	fileid_t *filep;
4967c478bd9Sstevel@tonic-gate 
4977c478bd9Sstevel@tonic-gate 	if (!(filep = find_fp(fd))) {
4987c478bd9Sstevel@tonic-gate 		return (-1);
4997c478bd9Sstevel@tonic-gate 	}
5007c478bd9Sstevel@tonic-gate 
501ae115bc7Smrj 	if ((filep->fi_flags & FI_COMPRESSED) == 0 &&
502ae115bc7Smrj 	    filep->fi_offset + count > filep->fi_inode->i_size)
5037c478bd9Sstevel@tonic-gate 		count = filep->fi_inode->i_size - filep->fi_offset;
5047c478bd9Sstevel@tonic-gate 
5057c478bd9Sstevel@tonic-gate 	/* that was easy */
5067c478bd9Sstevel@tonic-gate 	if ((i = count) == 0)
5077c478bd9Sstevel@tonic-gate 		return (0);
5087c478bd9Sstevel@tonic-gate 
5097c478bd9Sstevel@tonic-gate 	n = buf;
5107c478bd9Sstevel@tonic-gate 	while (i > 0) {
511ae115bc7Smrj 		if (filep->fi_flags & FI_COMPRESSED) {
512ae115bc7Smrj 			if ((j = cf_read(filep, buf, count)) < 0)
513ae115bc7Smrj 				return (0); /* encountered an error */
514ae115bc7Smrj 			if (j < i)
515ae115bc7Smrj 				i = j; /* short read, must have hit EOF */
5167c478bd9Sstevel@tonic-gate 		} else {
517ae115bc7Smrj 			/* If we need to reload the buffer, do so */
518ae115bc7Smrj 			if ((j = filep->fi_count) == 0) {
519ae115bc7Smrj 				(void) getblock(filep, buf, i, &rcount);
520ae115bc7Smrj 				i -= rcount;
521ae115bc7Smrj 				buf += rcount;
522ae115bc7Smrj 				filep->fi_offset += rcount;
523ae115bc7Smrj 				continue;
524ae115bc7Smrj 			} else {
525ae115bc7Smrj 				/* else just bcopy from our buffer */
526ae115bc7Smrj 				j = MIN(i, j);
527ae115bc7Smrj 				bcopy(filep->fi_memp, buf, (unsigned)j);
528ae115bc7Smrj 			}
5297c478bd9Sstevel@tonic-gate 		}
530ae115bc7Smrj 		buf += j;
531ae115bc7Smrj 		filep->fi_memp += j;
532ae115bc7Smrj 		filep->fi_offset += j;
533ae115bc7Smrj 		filep->fi_count -= j;
534ae115bc7Smrj 		i -= j;
5357c478bd9Sstevel@tonic-gate 	}
5367c478bd9Sstevel@tonic-gate 	return (buf - n);
5377c478bd9Sstevel@tonic-gate }
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate /*
5407c478bd9Sstevel@tonic-gate  *	This routine will open a device as it is known by the V2 OBP.
5417c478bd9Sstevel@tonic-gate  *	Interface Defn:
5427c478bd9Sstevel@tonic-gate  *	err = mountroot(string);
5437c478bd9Sstevel@tonic-gate  *		err = 0 on success
5447c478bd9Sstevel@tonic-gate  *		err = -1 on failure
5457c478bd9Sstevel@tonic-gate  *	string:	char string describing the properties of the device.
5467c478bd9Sstevel@tonic-gate  *	We must not dork with any fi[]'s here.  Save that for later.
5477c478bd9Sstevel@tonic-gate  */
5487c478bd9Sstevel@tonic-gate 
5497c478bd9Sstevel@tonic-gate static int
5507c478bd9Sstevel@tonic-gate bufs_mountroot(char *str)
5517c478bd9Sstevel@tonic-gate {
5527c478bd9Sstevel@tonic-gate 	if (ufs_devp)		/* already mounted */
5537c478bd9Sstevel@tonic-gate 		return (0);
5547c478bd9Sstevel@tonic-gate 
5557c478bd9Sstevel@tonic-gate 	ufs_devp = (devid_t *)bkmem_alloc(sizeof (devid_t));
5567c478bd9Sstevel@tonic-gate 	ufs_devp->di_taken = 1;
5577c478bd9Sstevel@tonic-gate 	ufs_devp->di_dcookie = 0;
5587c478bd9Sstevel@tonic-gate 	ufs_devp->di_desc = (char *)bkmem_alloc(strlen(str) + 1);
5597c478bd9Sstevel@tonic-gate 	(void) strcpy(ufs_devp->di_desc, str);
5607c478bd9Sstevel@tonic-gate 	bzero(ufs_devp->un_fs.dummy, SBSIZE);
5617c478bd9Sstevel@tonic-gate 	head = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
5627c478bd9Sstevel@tonic-gate 	head->fi_back = head->fi_forw = head;
5637c478bd9Sstevel@tonic-gate 	head->fi_filedes = 0;
5647c478bd9Sstevel@tonic-gate 	head->fi_taken = 0;
5657c478bd9Sstevel@tonic-gate 
5667c478bd9Sstevel@tonic-gate 	/* Setup read of the superblock */
5677c478bd9Sstevel@tonic-gate 	head->fi_devp = ufs_devp;
5687c478bd9Sstevel@tonic-gate 	head->fi_blocknum = SBLOCK;
5697c478bd9Sstevel@tonic-gate 	head->fi_count = (uint_t)SBSIZE;
5707c478bd9Sstevel@tonic-gate 	head->fi_memp = (caddr_t)&(ufs_devp->un_fs.di_fs);
5717c478bd9Sstevel@tonic-gate 	head->fi_offset = 0;
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate 	if (diskread(head)) {
5747c478bd9Sstevel@tonic-gate 		printf("failed to read superblock\n");
5757c478bd9Sstevel@tonic-gate 		(void) bufs_closeall(1);
5767c478bd9Sstevel@tonic-gate 		return (-1);
5777c478bd9Sstevel@tonic-gate 	}
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 	if (ufs_devp->un_fs.di_fs.fs_magic != FS_MAGIC) {
5807c478bd9Sstevel@tonic-gate 		dprintf("fs magic = 0x%x\n", ufs_devp->un_fs.di_fs.fs_magic);
5817c478bd9Sstevel@tonic-gate 		(void) bufs_closeall(1);
5827c478bd9Sstevel@tonic-gate 		return (-1);
5837c478bd9Sstevel@tonic-gate 	}
5847c478bd9Sstevel@tonic-gate 	dprintf("mountroot succeeded\n");
5857c478bd9Sstevel@tonic-gate 	return (0);
5867c478bd9Sstevel@tonic-gate }
5877c478bd9Sstevel@tonic-gate 
5887c478bd9Sstevel@tonic-gate /*
5897c478bd9Sstevel@tonic-gate  * Unmount the currently mounted root fs.  In practice, this means
5907c478bd9Sstevel@tonic-gate  * closing all open files and releasing resources.  All of this
5917c478bd9Sstevel@tonic-gate  * is done by closeall().
5927c478bd9Sstevel@tonic-gate  */
5937c478bd9Sstevel@tonic-gate 
5947c478bd9Sstevel@tonic-gate static int
5957c478bd9Sstevel@tonic-gate bufs_unmountroot(void)
5967c478bd9Sstevel@tonic-gate {
5977c478bd9Sstevel@tonic-gate 	if (ufs_devp == NULL)
5987c478bd9Sstevel@tonic-gate 		return (-1);
5997c478bd9Sstevel@tonic-gate 
6007c478bd9Sstevel@tonic-gate 	(void) bufs_closeall(1);
6017c478bd9Sstevel@tonic-gate 
6027c478bd9Sstevel@tonic-gate 	return (0);
6037c478bd9Sstevel@tonic-gate }
6047c478bd9Sstevel@tonic-gate 
6057c478bd9Sstevel@tonic-gate /*
6067c478bd9Sstevel@tonic-gate  *	We allocate an fd here for use when talking
6077c478bd9Sstevel@tonic-gate  *	to the file itself.
6087c478bd9Sstevel@tonic-gate  */
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6117c478bd9Sstevel@tonic-gate static int
6127c478bd9Sstevel@tonic-gate bufs_open(char *filename, int flags)
6137c478bd9Sstevel@tonic-gate {
6147c478bd9Sstevel@tonic-gate 	fileid_t	*filep;
6157c478bd9Sstevel@tonic-gate 	ino_t	inode;
6167c478bd9Sstevel@tonic-gate 	static int	filedes = 1;
6177c478bd9Sstevel@tonic-gate 
6187c478bd9Sstevel@tonic-gate 	dprintf("open: %s\n", filename);
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	/* build and link a new file descriptor */
6217c478bd9Sstevel@tonic-gate 	filep = (fileid_t *)bkmem_alloc(sizeof (fileid_t));
6227c478bd9Sstevel@tonic-gate 	filep->fi_back = head->fi_back;
6237c478bd9Sstevel@tonic-gate 	filep->fi_forw = head;
6247c478bd9Sstevel@tonic-gate 	head->fi_back->fi_forw = filep;
6257c478bd9Sstevel@tonic-gate 	head->fi_back = filep;
6267c478bd9Sstevel@tonic-gate 	filep->fi_filedes = filedes++;
6277c478bd9Sstevel@tonic-gate 	filep->fi_taken = 1;
6287c478bd9Sstevel@tonic-gate 	filep->fi_path = (char *)bkmem_alloc(strlen(filename) + 1);
6297c478bd9Sstevel@tonic-gate 	(void) strcpy(filep->fi_path, filename);
6307c478bd9Sstevel@tonic-gate 	filep->fi_devp = ufs_devp; /* dev is already "mounted" */
6317c478bd9Sstevel@tonic-gate 	filep->fi_inode = NULL;
6327c478bd9Sstevel@tonic-gate 	bzero(filep->fi_buf, MAXBSIZE);
633ae115bc7Smrj 	filep->fi_getblock = getblock_noopt;
634ae115bc7Smrj 	filep->fi_flags = 0;
6357c478bd9Sstevel@tonic-gate 
6367c478bd9Sstevel@tonic-gate 	inode = find(filep, (char *)filename);
6377c478bd9Sstevel@tonic-gate 	if (inode == (ino_t)0) {
6387c478bd9Sstevel@tonic-gate 		dprintf("open: cannot find %s\n", filename);
6397c478bd9Sstevel@tonic-gate 		(void) bufs_close(filep->fi_filedes);
6407c478bd9Sstevel@tonic-gate 		return (-1);
6417c478bd9Sstevel@tonic-gate 	}
6427c478bd9Sstevel@tonic-gate 	if (openi(filep, inode)) {
6437c478bd9Sstevel@tonic-gate 		printf("open: cannot open %s\n", filename);
6447c478bd9Sstevel@tonic-gate 		(void) bufs_close(filep->fi_filedes);
6457c478bd9Sstevel@tonic-gate 		return (-1);
6467c478bd9Sstevel@tonic-gate 	}
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate 	filep->fi_offset = filep->fi_count = 0;
6497c478bd9Sstevel@tonic-gate 
650ae115bc7Smrj 	if (cf_check_compressed(filep) != 0)
651ae115bc7Smrj 		return (-1);
6527c478bd9Sstevel@tonic-gate 	return (filep->fi_filedes);
6537c478bd9Sstevel@tonic-gate }
6547c478bd9Sstevel@tonic-gate 
6557c478bd9Sstevel@tonic-gate /*
6567c478bd9Sstevel@tonic-gate  *  We don't do any IO here.
6577c478bd9Sstevel@tonic-gate  *  We just play games with the device pointers.
6587c478bd9Sstevel@tonic-gate  */
6597c478bd9Sstevel@tonic-gate 
6607c478bd9Sstevel@tonic-gate static off_t
6617c478bd9Sstevel@tonic-gate bufs_lseek(int fd, off_t addr, int whence)
6627c478bd9Sstevel@tonic-gate {
6637c478bd9Sstevel@tonic-gate 	fileid_t *filep;
6647c478bd9Sstevel@tonic-gate 
665*48bbca81SDaniel Hoffman 	/* Make sure user knows what file they are talking to */
6667c478bd9Sstevel@tonic-gate 	if (!(filep = find_fp(fd)))
6677c478bd9Sstevel@tonic-gate 		return (-1);
6687c478bd9Sstevel@tonic-gate 
669ae115bc7Smrj 	if (filep->fi_flags & FI_COMPRESSED) {
670ae115bc7Smrj 		cf_seek(filep, addr, whence);
671ae115bc7Smrj 	} else {
672ae115bc7Smrj 		switch (whence) {
673ae115bc7Smrj 		case SEEK_CUR:
674ae115bc7Smrj 			filep->fi_offset += addr;
675ae115bc7Smrj 			break;
676ae115bc7Smrj 		case SEEK_SET:
677ae115bc7Smrj 			filep->fi_offset = addr;
678ae115bc7Smrj 			break;
679ae115bc7Smrj 		default:
680ae115bc7Smrj 		case SEEK_END:
681ae115bc7Smrj 			printf("lseek(): invalid whence value %d\n", whence);
682ae115bc7Smrj 			break;
683ae115bc7Smrj 		}
684ae115bc7Smrj 		filep->fi_blocknum = addr / DEV_BSIZE;
6857c478bd9Sstevel@tonic-gate 	}
6867c478bd9Sstevel@tonic-gate 
6877c478bd9Sstevel@tonic-gate 	filep->fi_count = 0;
6887c478bd9Sstevel@tonic-gate 
6897c478bd9Sstevel@tonic-gate 	return (0);
6907c478bd9Sstevel@tonic-gate }
6917c478bd9Sstevel@tonic-gate 
692ea8dc4b6Seschrock 
693ea8dc4b6Seschrock int
694ea8dc4b6Seschrock bufs_fstat(int fd, struct bootstat *stp)
695ea8dc4b6Seschrock {
696ea8dc4b6Seschrock 	fileid_t	*filep;
697ea8dc4b6Seschrock 	struct inode	*ip;
698ea8dc4b6Seschrock 
699ea8dc4b6Seschrock 	if (!(filep = find_fp(fd)))
700ea8dc4b6Seschrock 		return (-1);
701ea8dc4b6Seschrock 
702ea8dc4b6Seschrock 	ip = filep->fi_inode;
703ea8dc4b6Seschrock 
704ea8dc4b6Seschrock 	stp->st_mode = 0;
705ea8dc4b6Seschrock 	stp->st_size = 0;
706ea8dc4b6Seschrock 
707ea8dc4b6Seschrock 	if (ip == NULL)
708ea8dc4b6Seschrock 		return (0);
709ea8dc4b6Seschrock 
710ea8dc4b6Seschrock 	switch (ip->i_smode & IFMT) {
711ea8dc4b6Seschrock 	case IFLNK:
712ea8dc4b6Seschrock 		stp->st_mode = S_IFLNK;
713ea8dc4b6Seschrock 		break;
714ea8dc4b6Seschrock 	case IFREG:
715ea8dc4b6Seschrock 		stp->st_mode = S_IFREG;
716ea8dc4b6Seschrock 		break;
717ea8dc4b6Seschrock 	default:
718ea8dc4b6Seschrock 		break;
719ea8dc4b6Seschrock 	}
720ae115bc7Smrj 	/*
721ae115bc7Smrj 	 * NOTE: this size will be the compressed size for a compressed file
722ae115bc7Smrj 	 * This could confuse the caller since we decompress the file behind
723ae115bc7Smrj 	 * the scenes when the file is read.
724ae115bc7Smrj 	 */
725ea8dc4b6Seschrock 	stp->st_size = ip->i_size;
726ea8dc4b6Seschrock 	stp->st_atim.tv_sec = ip->i_atime.tv_sec;
727ea8dc4b6Seschrock 	stp->st_atim.tv_nsec = ip->i_atime.tv_usec * 1000;
728ea8dc4b6Seschrock 	stp->st_mtim.tv_sec = ip->i_mtime.tv_sec;
729ea8dc4b6Seschrock 	stp->st_mtim.tv_nsec = ip->i_mtime.tv_usec * 1000;
730ea8dc4b6Seschrock 	stp->st_ctim.tv_sec = ip->i_ctime.tv_sec;
731ea8dc4b6Seschrock 	stp->st_ctim.tv_nsec = ip->i_ctime.tv_usec * 1000;
732ea8dc4b6Seschrock 
733ea8dc4b6Seschrock 	return (0);
734ea8dc4b6Seschrock }
735ea8dc4b6Seschrock 
736ea8dc4b6Seschrock 
7377c478bd9Sstevel@tonic-gate static int
7387c478bd9Sstevel@tonic-gate bufs_close(int fd)
7397c478bd9Sstevel@tonic-gate {
7407c478bd9Sstevel@tonic-gate 	fileid_t *filep;
7417c478bd9Sstevel@tonic-gate 
742*48bbca81SDaniel Hoffman 	/* Make sure user knows what file they are talking to */
7437c478bd9Sstevel@tonic-gate 	if (!(filep = find_fp(fd)))
7447c478bd9Sstevel@tonic-gate 		return (-1);
7457c478bd9Sstevel@tonic-gate 
7467c478bd9Sstevel@tonic-gate 	if (filep->fi_taken && (filep != head)) {
7477c478bd9Sstevel@tonic-gate 		/* Clear the ranks */
7487c478bd9Sstevel@tonic-gate 		bkmem_free(filep->fi_path, strlen(filep->fi_path)+1);
7497c478bd9Sstevel@tonic-gate 		filep->fi_blocknum = filep->fi_count = filep->fi_offset = 0;
7507c478bd9Sstevel@tonic-gate 		filep->fi_memp = (caddr_t)0;
7517c478bd9Sstevel@tonic-gate 		filep->fi_devp = 0;
7527c478bd9Sstevel@tonic-gate 		filep->fi_taken = 0;
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 		/* unlink and deallocate node */
7557c478bd9Sstevel@tonic-gate 		filep->fi_forw->fi_back = filep->fi_back;
7567c478bd9Sstevel@tonic-gate 		filep->fi_back->fi_forw = filep->fi_forw;
757ae115bc7Smrj 		cf_close(filep);
7587c478bd9Sstevel@tonic-gate 		bkmem_free((char *)filep, sizeof (fileid_t));
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 		return (0);
7617c478bd9Sstevel@tonic-gate 	} else {
7627c478bd9Sstevel@tonic-gate 		/* Big problem */
7637c478bd9Sstevel@tonic-gate 		printf("\nFile descrip %d not allocated!", fd);
7647c478bd9Sstevel@tonic-gate 		return (-1);
7657c478bd9Sstevel@tonic-gate 	}
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7697c478bd9Sstevel@tonic-gate static void
7707c478bd9Sstevel@tonic-gate bufs_closeall(int flag)
7717c478bd9Sstevel@tonic-gate {
7727c478bd9Sstevel@tonic-gate 	fileid_t *filep = head;
7737c478bd9Sstevel@tonic-gate 
7747c478bd9Sstevel@tonic-gate 	while ((filep = filep->fi_forw) != head)
7757c478bd9Sstevel@tonic-gate 		if (filep->fi_taken)
7767c478bd9Sstevel@tonic-gate 			if (bufs_close(filep->fi_filedes))
7777c478bd9Sstevel@tonic-gate 				printf("Filesystem may be inconsistent.\n");
7787c478bd9Sstevel@tonic-gate 
7797c478bd9Sstevel@tonic-gate 	ufs_devp->di_taken = 0;
7807c478bd9Sstevel@tonic-gate 	bkmem_free((char *)ufs_devp, sizeof (devid_t));
7817c478bd9Sstevel@tonic-gate 	bkmem_free((char *)head, sizeof (fileid_t));
7827c478bd9Sstevel@tonic-gate 	ufs_devp = (devid_t *)NULL;
7837c478bd9Sstevel@tonic-gate 	head = (fileid_t *)NULL;
7847c478bd9Sstevel@tonic-gate 	free_cache();
7857c478bd9Sstevel@tonic-gate }
7867c478bd9Sstevel@tonic-gate 
7877c478bd9Sstevel@tonic-gate static struct cache {
7887c478bd9Sstevel@tonic-gate 	struct cache *next;
7897c478bd9Sstevel@tonic-gate 	void *data;
7907c478bd9Sstevel@tonic-gate 	int key;
7917c478bd9Sstevel@tonic-gate 	uint_t size;
7927c478bd9Sstevel@tonic-gate } *icache;
7937c478bd9Sstevel@tonic-gate 
7947c478bd9Sstevel@tonic-gate void
7957c478bd9Sstevel@tonic-gate set_cache(int key, void *data, uint_t size)
7967c478bd9Sstevel@tonic-gate {
7977c478bd9Sstevel@tonic-gate 	struct cache *entry = bkmem_alloc(sizeof (*entry));
7987c478bd9Sstevel@tonic-gate 	entry->key = key;
7997c478bd9Sstevel@tonic-gate 	entry->data = data;
8007c478bd9Sstevel@tonic-gate 	entry->size = size;
8017c478bd9Sstevel@tonic-gate 	if (icache) {
8027c478bd9Sstevel@tonic-gate 		entry->next = icache;
8037c478bd9Sstevel@tonic-gate 		icache = entry;
8047c478bd9Sstevel@tonic-gate 	} else {
8057c478bd9Sstevel@tonic-gate 		icache = entry;
8067c478bd9Sstevel@tonic-gate 		entry->next = 0;
8077c478bd9Sstevel@tonic-gate 	}
8087c478bd9Sstevel@tonic-gate }
8097c478bd9Sstevel@tonic-gate 
8107c478bd9Sstevel@tonic-gate void *
8117c478bd9Sstevel@tonic-gate get_cache(int key)
8127c478bd9Sstevel@tonic-gate {
8137c478bd9Sstevel@tonic-gate 	struct cache *entry = icache;
8147c478bd9Sstevel@tonic-gate 	while (entry) {
8157c478bd9Sstevel@tonic-gate 		if (entry->key == key)
8167c478bd9Sstevel@tonic-gate 			return (entry->data);
8177c478bd9Sstevel@tonic-gate 		entry = entry->next;
8187c478bd9Sstevel@tonic-gate 	}
8197c478bd9Sstevel@tonic-gate 	return (NULL);
8207c478bd9Sstevel@tonic-gate }
8217c478bd9Sstevel@tonic-gate 
8227c478bd9Sstevel@tonic-gate void
8237c478bd9Sstevel@tonic-gate free_cache()
8247c478bd9Sstevel@tonic-gate {
8257c478bd9Sstevel@tonic-gate 	struct cache *next, *entry = icache;
8267c478bd9Sstevel@tonic-gate 	while (entry) {
8277c478bd9Sstevel@tonic-gate 		next = entry->next;
8287c478bd9Sstevel@tonic-gate 		bkmem_free(entry->data, entry->size);
8297c478bd9Sstevel@tonic-gate 		bkmem_free(entry, sizeof (*entry));
8307c478bd9Sstevel@tonic-gate 		entry = next;
8317c478bd9Sstevel@tonic-gate 	}
8327c478bd9Sstevel@tonic-gate 	icache = 0;
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate 
8357c478bd9Sstevel@tonic-gate struct boot_fs_ops bufs_ops = {
8367c478bd9Sstevel@tonic-gate 	"boot_ufs",
8377c478bd9Sstevel@tonic-gate 	bufs_mountroot,
8387c478bd9Sstevel@tonic-gate 	bufs_unmountroot,
8397c478bd9Sstevel@tonic-gate 	bufs_open,
8407c478bd9Sstevel@tonic-gate 	bufs_close,
8417c478bd9Sstevel@tonic-gate 	bufs_read,
8427c478bd9Sstevel@tonic-gate 	bufs_lseek,
843ea8dc4b6Seschrock 	bufs_fstat,
8447c478bd9Sstevel@tonic-gate 	NULL
8457c478bd9Sstevel@tonic-gate };
846