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