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