Home | History | Annotate | Line # | Download | only in libsa
ufs.c revision 1.35
      1  1.35       dsl /*	$NetBSD: ufs.c,v 1.35 2003/04/11 11:24:49 dsl Exp $	*/
      2   1.8       cgd 
      3   1.1    brezak /*-
      4   1.1    brezak  * Copyright (c) 1993
      5   1.1    brezak  *	The Regents of the University of California.  All rights reserved.
      6   1.1    brezak  *
      7   1.1    brezak  * This code is derived from software contributed to Berkeley by
      8   1.1    brezak  * The Mach Operating System project at Carnegie-Mellon University.
      9   1.1    brezak  *
     10   1.1    brezak  * Redistribution and use in source and binary forms, with or without
     11   1.1    brezak  * modification, are permitted provided that the following conditions
     12   1.1    brezak  * are met:
     13   1.1    brezak  * 1. Redistributions of source code must retain the above copyright
     14   1.1    brezak  *    notice, this list of conditions and the following disclaimer.
     15   1.1    brezak  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1    brezak  *    notice, this list of conditions and the following disclaimer in the
     17   1.1    brezak  *    documentation and/or other materials provided with the distribution.
     18   1.1    brezak  * 3. All advertising materials mentioning features or use of this software
     19   1.1    brezak  *    must display the following acknowledgement:
     20   1.1    brezak  *	This product includes software developed by the University of
     21   1.1    brezak  *	California, Berkeley and its contributors.
     22   1.1    brezak  * 4. Neither the name of the University nor the names of its contributors
     23   1.1    brezak  *    may be used to endorse or promote products derived from this software
     24   1.1    brezak  *    without specific prior written permission.
     25   1.1    brezak  *
     26   1.1    brezak  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     27   1.1    brezak  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     28   1.1    brezak  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     29   1.1    brezak  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     30   1.1    brezak  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     31   1.1    brezak  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     32   1.1    brezak  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     33   1.1    brezak  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     34   1.1    brezak  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     35   1.1    brezak  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     36   1.1    brezak  * SUCH DAMAGE.
     37  1.22    simonb  *
     38   1.1    brezak  *
     39   1.1    brezak  * Copyright (c) 1990, 1991 Carnegie Mellon University
     40   1.1    brezak  * All Rights Reserved.
     41   1.1    brezak  *
     42   1.1    brezak  * Author: David Golub
     43  1.22    simonb  *
     44   1.1    brezak  * Permission to use, copy, modify and distribute this software and its
     45   1.1    brezak  * documentation is hereby granted, provided that both the copyright
     46   1.1    brezak  * notice and this permission notice appear in all copies of the
     47   1.1    brezak  * software, derivative works or modified versions, and any portions
     48   1.1    brezak  * thereof, and that both notices appear in supporting documentation.
     49  1.22    simonb  *
     50   1.1    brezak  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     51   1.1    brezak  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
     52   1.1    brezak  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     53  1.22    simonb  *
     54   1.1    brezak  * Carnegie Mellon requests users of this software to return to
     55  1.22    simonb  *
     56   1.1    brezak  *  Software Distribution Coordinator  or  Software.Distribution (at) CS.CMU.EDU
     57   1.1    brezak  *  School of Computer Science
     58   1.1    brezak  *  Carnegie Mellon University
     59   1.1    brezak  *  Pittsburgh PA 15213-3890
     60  1.22    simonb  *
     61   1.1    brezak  * any improvements or extensions that they make and grant Carnegie the
     62   1.1    brezak  * rights to redistribute these changes.
     63  1.27       cgd  */
     64  1.27       cgd 
     65  1.27       cgd /*
     66  1.27       cgd  * XXX NOTE: ufs.c (FFS) and lfs.c (LFS) should eventually use much common
     67  1.27       cgd  * XXX code.  until then, the two files should be easily diffable.
     68   1.1    brezak  */
     69   1.1    brezak 
     70   1.1    brezak /*
     71   1.1    brezak  *	Stand-alone file reading package.
     72   1.1    brezak  */
     73   1.1    brezak 
     74   1.1    brezak #include <sys/param.h>
     75   1.1    brezak #include <sys/time.h>
     76   1.1    brezak #include <ufs/ufs/dinode.h>
     77   1.1    brezak #include <ufs/ufs/dir.h>
     78  1.35       dsl #ifdef LIBSA_LFS
     79  1.35       dsl #include <sys/queue.h>
     80  1.35       dsl #include <sys/mount.h>			/* XXX for MNAMELEN */
     81  1.35       dsl #include <ufs/lfs/lfs.h>
     82  1.35       dsl #else
     83  1.20      ross #include <ufs/ffs/fs.h>
     84  1.35       dsl #endif
     85  1.29   thorpej #ifdef _STANDALONE
     86  1.29   thorpej #include <lib/libkern/libkern.h>
     87  1.29   thorpej #else
     88  1.29   thorpej #include <string.h>
     89  1.29   thorpej #endif
     90   1.2     glass 
     91   1.1    brezak #include "stand.h"
     92  1.35       dsl #ifdef LIBSA_LFS
     93  1.35       dsl #include "lfs.h"
     94  1.35       dsl #else
     95  1.21        pk #include "ufs.h"
     96  1.35       dsl #endif
     97  1.35       dsl 
     98  1.35       dsl /* If this file is compiled by itself, build ufs (aka ffsv1) support */
     99  1.35       dsl #if !defined(LIBSA_FFSv2) && !defined(LIBSA_LFS)
    100  1.35       dsl #define LIBSA_FFSv1
    101  1.35       dsl #endif
    102  1.23       cgd 
    103  1.23       cgd #if defined(LIBSA_FS_SINGLECOMPONENT) && !defined(LIBSA_NO_FS_SYMLINK)
    104  1.23       cgd #define LIBSA_NO_FS_SYMLINK
    105  1.25    simonb #endif
    106  1.25    simonb #if defined(COMPAT_UFS) && defined(LIBSA_NO_COMPAT_UFS)
    107  1.25    simonb #undef COMPAT_UFS
    108  1.23       cgd #endif
    109  1.23       cgd 
    110  1.35       dsl #ifdef LIBSA_LFS
    111  1.35       dsl /*
    112  1.35       dsl  * In-core LFS superblock.  This exists only to placate the macros in lfs.h,
    113  1.35       dsl  */
    114  1.35       dsl struct fs {
    115  1.35       dsl 	struct dlfs	lfs_dlfs;
    116  1.33      fvdl };
    117  1.35       dsl #define fs_magic	lfs_magic
    118  1.35       dsl #define fs_maxsymlinklen lfs_maxsymlinklen
    119  1.33      fvdl 
    120  1.35       dsl #define FS_MAGIC	LFS_MAGIC
    121  1.35       dsl #define SBLOCKSIZE	LFS_SBPAD
    122  1.35       dsl #define SBLOCKOFFSET	LFS_LABELPAD
    123  1.33      fvdl #else
    124  1.35       dsl /* NB ufs2 doesn't use the common suberblock code... */
    125  1.35       dsl #define FS_MAGIC	FS_UFS1_MAGIC
    126  1.35       dsl #define SBLOCKOFFSET	SBLOCK_UFS1
    127  1.35       dsl #endif
    128  1.35       dsl 
    129  1.35       dsl #if defined(LIBSA_NO_TWIDDLE)
    130  1.35       dsl #define twiddle()
    131  1.35       dsl #endif
    132  1.35       dsl 
    133  1.35       dsl #ifndef ufs_dinode
    134  1.35       dsl #define ufs_dinode	ufs1_dinode
    135  1.35       dsl #endif
    136  1.35       dsl #ifndef indp_t
    137  1.35       dsl #define indp_t		uint32_t
    138  1.35       dsl #endif
    139  1.35       dsl #ifndef FSBTODB
    140  1.35       dsl #define FSBTODB(fs, daddr) fsbtodb(fs, daddr)
    141  1.33      fvdl #endif
    142  1.23       cgd 
    143   1.1    brezak /*
    144   1.1    brezak  * In-core open file.
    145   1.1    brezak  */
    146   1.1    brezak struct file {
    147   1.1    brezak 	off_t		f_seekp;	/* seek pointer */
    148   1.1    brezak 	struct fs	*f_fs;		/* pointer to super-block */
    149  1.35       dsl 	struct ufs_dinode	f_di;		/* copy of on-disk inode */
    150  1.35       dsl 	daddr_t		f_nindir[NIADDR];
    151   1.1    brezak 					/* number of blocks mapped by
    152   1.1    brezak 					   indirect block at level i */
    153  1.35       dsl 	int		f_l2indir[NIADDR]; /* log2(f_nindir) */
    154   1.1    brezak 	char		*f_blk[NIADDR];	/* buffer for indirect block at
    155   1.1    brezak 					   level i */
    156  1.13       cgd 	size_t		f_blksize[NIADDR];
    157   1.1    brezak 					/* size of buffer */
    158   1.1    brezak 	daddr_t		f_blkno[NIADDR];/* disk address of block in buffer */
    159   1.1    brezak 	char		*f_buf;		/* buffer for data block */
    160  1.13       cgd 	size_t		f_buf_size;	/* size of data block */
    161   1.1    brezak 	daddr_t		f_buf_blkno;	/* block number of data block */
    162   1.1    brezak };
    163   1.1    brezak 
    164  1.13       cgd static int	read_inode __P((ino_t, struct open_file *));
    165  1.13       cgd static int	block_map __P((struct open_file *, daddr_t, daddr_t *));
    166  1.13       cgd static int	buf_read_file __P((struct open_file *, char **, size_t *));
    167  1.13       cgd static int	search_directory __P((char *, struct open_file *, ino_t *));
    168  1.35       dsl #ifdef LIBSA_FFSv1
    169  1.13       cgd static void	ffs_oldfscompat __P((struct fs *));
    170  1.35       dsl #endif
    171  1.35       dsl #ifdef LIBSA_FFSv2
    172  1.35       dsl static int	ffs_find_superblock __P((struct open_file *, struct fs *));
    173  1.35       dsl #endif
    174  1.35       dsl 
    175  1.35       dsl #ifdef LIBSA_LFS
    176  1.35       dsl /*
    177  1.35       dsl  * Find an inode's block.  Look it up in the ifile.  Whee!
    178  1.35       dsl  */
    179  1.35       dsl static int
    180  1.35       dsl find_inode_sector(ino_t inumber, struct open_file *f, daddr_t *isp)
    181  1.35       dsl {
    182  1.35       dsl 	struct file *fp = (struct file *)f->f_fsdata;
    183  1.35       dsl 	struct fs *fs = fp->f_fs;
    184  1.35       dsl 	daddr_t ifileent_blkno;
    185  1.35       dsl 	char *ent_in_buf;
    186  1.35       dsl 	size_t buf_after_ent;
    187  1.35       dsl 	int rc;
    188  1.33      fvdl 
    189  1.35       dsl 	rc = read_inode(fs->lfs_ifile, f);
    190  1.35       dsl 	if (rc)
    191  1.35       dsl 		return (rc);
    192  1.35       dsl 
    193  1.35       dsl 	ifileent_blkno =
    194  1.35       dsl 	    (inumber / fs->lfs_ifpb) + fs->lfs_cleansz + fs->lfs_segtabsz;
    195  1.35       dsl 	fp->f_seekp = (off_t)ifileent_blkno * fs->fs_bsize +
    196  1.35       dsl 	    (inumber % fs->lfs_ifpb) * sizeof (IFILE_Vx);
    197  1.35       dsl 	rc = buf_read_file(f, &ent_in_buf, &buf_after_ent);
    198  1.35       dsl 	if (rc)
    199  1.35       dsl 		return (rc);
    200  1.35       dsl 	/* make sure something's not badly wrong, but don't panic. */
    201  1.35       dsl 	if (buf_after_ent < sizeof (IFILE_Vx))
    202  1.35       dsl 		return (EINVAL);
    203  1.35       dsl 
    204  1.35       dsl 	*isp = FSBTODB(fs, ((IFILE_Vx *)ent_in_buf)->if_daddr);
    205  1.35       dsl 	if (*isp == LFS_UNUSED_DADDR)	/* again, something badly wrong */
    206  1.35       dsl 		return (EINVAL);
    207  1.35       dsl 	return (0);
    208  1.35       dsl }
    209   1.7    brezak #endif
    210   1.7    brezak 
    211   1.1    brezak /*
    212   1.1    brezak  * Read a new inode into a file structure.
    213   1.1    brezak  */
    214   1.1    brezak static int
    215   1.1    brezak read_inode(inumber, f)
    216   1.1    brezak 	ino_t inumber;
    217   1.1    brezak 	struct open_file *f;
    218   1.1    brezak {
    219  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    220  1.30  augustss 	struct fs *fs = fp->f_fs;
    221   1.1    brezak 	char *buf;
    222  1.13       cgd 	size_t rsize;
    223   1.1    brezak 	int rc;
    224  1.35       dsl 	daddr_t inode_sector;
    225  1.35       dsl #ifdef LIBSA_LFS
    226  1.35       dsl 	struct ufs_dinode *dip;
    227  1.35       dsl 	int cnt;
    228  1.35       dsl #endif
    229  1.35       dsl 
    230  1.35       dsl #ifdef LIBSA_LFS
    231  1.35       dsl 	if (inumber == fs->lfs_ifile)
    232  1.35       dsl 		inode_sector = FSBTODB(fs, fs->lfs_idaddr);
    233  1.35       dsl 	else if ((rc = find_inode_sector(inumber, f, &inode_sector)) != 0)
    234  1.35       dsl 		return (rc);
    235  1.35       dsl #else
    236  1.35       dsl 	inode_sector = FSBTODB(fs, ino_to_fsba(fs, inumber));
    237  1.35       dsl #endif
    238   1.1    brezak 
    239   1.1    brezak 	/*
    240   1.1    brezak 	 * Read inode and save it.
    241   1.1    brezak 	 */
    242   1.1    brezak 	buf = alloc(fs->fs_bsize);
    243  1.11   mycroft 	twiddle();
    244  1.23       cgd 	rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
    245  1.35       dsl 		inode_sector, fs->fs_bsize,
    246  1.13       cgd 		buf, &rsize);
    247   1.1    brezak 	if (rc)
    248   1.1    brezak 		goto out;
    249   1.1    brezak 	if (rsize != fs->fs_bsize) {
    250   1.1    brezak 		rc = EIO;
    251   1.1    brezak 		goto out;
    252   1.1    brezak 	}
    253   1.1    brezak 
    254  1.35       dsl #ifdef LIBSA_LFS
    255  1.35       dsl 	rc = EINVAL;
    256  1.35       dsl 	cnt = INOPBx(fs);
    257  1.35       dsl 	for (dip = (struct ufs_dinode *)buf + (cnt - 1); cnt--; --dip) {
    258  1.35       dsl                 if (dip->di_inumber == inumber) {
    259  1.35       dsl                         rc = 0;
    260  1.35       dsl 			break;
    261  1.33      fvdl 		}
    262   1.1    brezak 	}
    263  1.35       dsl 	/* kernel code panics, but boot blocks which panic are Bad. */
    264  1.35       dsl 	if (rc)
    265  1.35       dsl 		goto out;
    266  1.35       dsl 	fp->f_di = *dip;
    267  1.35       dsl #else
    268  1.35       dsl 	fp->f_di = ((struct ufs_dinode *)buf)[ino_to_fsbo(fs, inumber)];
    269  1.35       dsl #endif
    270   1.1    brezak 
    271   1.1    brezak 	/*
    272   1.1    brezak 	 * Clear out the old buffers
    273   1.1    brezak 	 */
    274   1.1    brezak 	{
    275  1.30  augustss 		int level;
    276   1.1    brezak 
    277   1.1    brezak 		for (level = 0; level < NIADDR; level++)
    278   1.1    brezak 			fp->f_blkno[level] = -1;
    279   1.1    brezak 		fp->f_buf_blkno = -1;
    280   1.1    brezak 	}
    281   1.1    brezak out:
    282   1.1    brezak 	free(buf, fs->fs_bsize);
    283  1.22    simonb 	return (rc);
    284   1.1    brezak }
    285   1.1    brezak 
    286   1.1    brezak /*
    287   1.1    brezak  * Given an offset in a file, find the disk block number that
    288   1.1    brezak  * contains that block.
    289   1.1    brezak  */
    290   1.1    brezak static int
    291   1.1    brezak block_map(f, file_block, disk_block_p)
    292   1.1    brezak 	struct open_file *f;
    293   1.1    brezak 	daddr_t file_block;
    294   1.1    brezak 	daddr_t *disk_block_p;	/* out */
    295   1.1    brezak {
    296  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    297  1.30  augustss 	struct fs *fs = fp->f_fs;
    298   1.1    brezak 	int level;
    299   1.1    brezak 	int idx;
    300   1.1    brezak 	daddr_t ind_block_num;
    301  1.35       dsl 	indp_t *ind_p;
    302   1.1    brezak 	int rc;
    303   1.1    brezak 
    304   1.1    brezak 	/*
    305   1.1    brezak 	 * Index structure of an inode:
    306   1.1    brezak 	 *
    307   1.1    brezak 	 * di_db[0..NDADDR-1]	hold block numbers for blocks
    308   1.1    brezak 	 *			0..NDADDR-1
    309   1.1    brezak 	 *
    310   1.1    brezak 	 * di_ib[0]		index block 0 is the single indirect block
    311   1.1    brezak 	 *			holds block numbers for blocks
    312   1.1    brezak 	 *			NDADDR .. NDADDR + NINDIR(fs)-1
    313   1.1    brezak 	 *
    314   1.1    brezak 	 * di_ib[1]		index block 1 is the double indirect block
    315   1.1    brezak 	 *			holds block numbers for INDEX blocks for blocks
    316   1.1    brezak 	 *			NDADDR + NINDIR(fs) ..
    317   1.1    brezak 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
    318   1.1    brezak 	 *
    319   1.1    brezak 	 * di_ib[2]		index block 2 is the triple indirect block
    320   1.1    brezak 	 *			holds block numbers for double-indirect
    321   1.1    brezak 	 *			blocks for blocks
    322   1.1    brezak 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
    323   1.1    brezak 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2
    324   1.1    brezak 	 *				+ NINDIR(fs)**3 - 1
    325   1.1    brezak 	 */
    326   1.1    brezak 
    327   1.1    brezak 	if (file_block < NDADDR) {
    328   1.1    brezak 		/* Direct block. */
    329  1.35       dsl 		*disk_block_p = fp->f_di.di_db[file_block];
    330   1.1    brezak 		return (0);
    331   1.1    brezak 	}
    332   1.1    brezak 
    333   1.1    brezak 	file_block -= NDADDR;
    334   1.1    brezak 
    335   1.1    brezak 	/*
    336   1.1    brezak 	 * nindir[0] = NINDIR
    337   1.1    brezak 	 * nindir[1] = NINDIR**2
    338   1.1    brezak 	 * nindir[2] = NINDIR**3
    339   1.1    brezak 	 *	etc
    340   1.1    brezak 	 */
    341   1.1    brezak 	for (level = 0; level < NIADDR; level++) {
    342   1.1    brezak 		if (file_block < fp->f_nindir[level])
    343   1.1    brezak 			break;
    344   1.1    brezak 		file_block -= fp->f_nindir[level];
    345   1.1    brezak 	}
    346   1.1    brezak 	if (level == NIADDR) {
    347   1.1    brezak 		/* Block number too high */
    348   1.1    brezak 		return (EFBIG);
    349   1.1    brezak 	}
    350   1.1    brezak 
    351  1.35       dsl 	ind_block_num = fp->f_di.di_ib[level];
    352   1.1    brezak 
    353   1.1    brezak 	for (; level >= 0; level--) {
    354   1.1    brezak 		if (ind_block_num == 0) {
    355   1.1    brezak 			*disk_block_p = 0;	/* missing */
    356   1.1    brezak 			return (0);
    357   1.1    brezak 		}
    358   1.1    brezak 
    359   1.1    brezak 		if (fp->f_blkno[level] != ind_block_num) {
    360   1.1    brezak 			if (fp->f_blk[level] == (char *)0)
    361   1.1    brezak 				fp->f_blk[level] =
    362   1.1    brezak 					alloc(fs->fs_bsize);
    363  1.11   mycroft 			twiddle();
    364  1.23       cgd 			rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
    365  1.35       dsl 				FSBTODB(fp->f_fs, ind_block_num),
    366   1.1    brezak 				fs->fs_bsize,
    367   1.1    brezak 				fp->f_blk[level],
    368  1.13       cgd 				&fp->f_blksize[level]);
    369   1.1    brezak 			if (rc)
    370   1.1    brezak 				return (rc);
    371   1.1    brezak 			if (fp->f_blksize[level] != fs->fs_bsize)
    372   1.1    brezak 				return (EIO);
    373   1.1    brezak 			fp->f_blkno[level] = ind_block_num;
    374   1.1    brezak 		}
    375   1.1    brezak 
    376   1.1    brezak 		if (level > 0) {
    377  1.35       dsl 			idx = file_block >> fp->f_l2indir[level - 1];
    378  1.35       dsl 			file_block &= fp->f_nindir[level - 1] - 1;
    379   1.1    brezak 		} else
    380   1.1    brezak 			idx = file_block;
    381   1.1    brezak 
    382  1.35       dsl 		ind_p = (void *)fp->f_blk[level];
    383  1.35       dsl 		ind_block_num = ind_p[idx];
    384   1.1    brezak 	}
    385   1.1    brezak 
    386   1.1    brezak 	*disk_block_p = ind_block_num;
    387   1.1    brezak 
    388   1.1    brezak 	return (0);
    389   1.1    brezak }
    390   1.1    brezak 
    391   1.1    brezak /*
    392   1.1    brezak  * Read a portion of a file into an internal buffer.  Return
    393   1.1    brezak  * the location in the buffer and the amount in the buffer.
    394   1.1    brezak  */
    395   1.1    brezak static int
    396   1.1    brezak buf_read_file(f, buf_p, size_p)
    397   1.1    brezak 	struct open_file *f;
    398   1.1    brezak 	char **buf_p;		/* out */
    399  1.13       cgd 	size_t *size_p;		/* out */
    400   1.1    brezak {
    401  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    402  1.30  augustss 	struct fs *fs = fp->f_fs;
    403   1.1    brezak 	long off;
    404  1.30  augustss 	daddr_t file_block;
    405   1.1    brezak 	daddr_t	disk_block;
    406  1.13       cgd 	size_t block_size;
    407   1.1    brezak 	int rc;
    408   1.1    brezak 
    409   1.1    brezak 	off = blkoff(fs, fp->f_seekp);
    410   1.1    brezak 	file_block = lblkno(fs, fp->f_seekp);
    411  1.35       dsl #ifdef LIBSA_LFS
    412  1.35       dsl 	block_size = dblksize(fs, &fp->f_di, file_block);
    413  1.35       dsl #else
    414  1.35       dsl 	block_size = sblksize(fs, fp->f_di.di_size, file_block);
    415  1.35       dsl #endif
    416   1.1    brezak 
    417   1.1    brezak 	if (file_block != fp->f_buf_blkno) {
    418   1.1    brezak 		rc = block_map(f, file_block, &disk_block);
    419   1.1    brezak 		if (rc)
    420   1.1    brezak 			return (rc);
    421   1.1    brezak 
    422   1.1    brezak 		if (fp->f_buf == (char *)0)
    423   1.1    brezak 			fp->f_buf = alloc(fs->fs_bsize);
    424   1.1    brezak 
    425   1.1    brezak 		if (disk_block == 0) {
    426   1.1    brezak 			bzero(fp->f_buf, block_size);
    427   1.1    brezak 			fp->f_buf_size = block_size;
    428   1.1    brezak 		} else {
    429  1.11   mycroft 			twiddle();
    430  1.23       cgd 			rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
    431  1.35       dsl 				FSBTODB(fs, disk_block),
    432   1.1    brezak 				block_size, fp->f_buf, &fp->f_buf_size);
    433   1.1    brezak 			if (rc)
    434   1.1    brezak 				return (rc);
    435   1.1    brezak 		}
    436   1.1    brezak 
    437   1.1    brezak 		fp->f_buf_blkno = file_block;
    438   1.1    brezak 	}
    439   1.1    brezak 
    440   1.1    brezak 	/*
    441   1.1    brezak 	 * Return address of byte in buffer corresponding to
    442   1.1    brezak 	 * offset, and size of remainder of buffer after that
    443   1.1    brezak 	 * byte.
    444   1.1    brezak 	 */
    445   1.1    brezak 	*buf_p = fp->f_buf + off;
    446   1.1    brezak 	*size_p = block_size - off;
    447   1.1    brezak 
    448   1.1    brezak 	/*
    449   1.1    brezak 	 * But truncate buffer at end of file.
    450   1.1    brezak 	 */
    451  1.35       dsl 	if (*size_p > fp->f_di.di_size - fp->f_seekp)
    452  1.35       dsl 		*size_p = fp->f_di.di_size - fp->f_seekp;
    453   1.1    brezak 
    454   1.1    brezak 	return (0);
    455   1.1    brezak }
    456   1.1    brezak 
    457   1.1    brezak /*
    458   1.1    brezak  * Search a directory for a name and return its
    459   1.1    brezak  * i_number.
    460   1.1    brezak  */
    461   1.1    brezak static int
    462   1.1    brezak search_directory(name, f, inumber_p)
    463   1.1    brezak 	char *name;
    464   1.1    brezak 	struct open_file *f;
    465   1.1    brezak 	ino_t *inumber_p;		/* out */
    466   1.1    brezak {
    467  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    468  1.30  augustss 	struct direct *dp;
    469   1.1    brezak 	struct direct *edp;
    470   1.1    brezak 	char *buf;
    471  1.13       cgd 	size_t buf_size;
    472   1.1    brezak 	int namlen, length;
    473   1.1    brezak 	int rc;
    474   1.1    brezak 
    475   1.1    brezak 	length = strlen(name);
    476   1.1    brezak 
    477   1.1    brezak 	fp->f_seekp = 0;
    478  1.35       dsl 	while (fp->f_seekp < fp->f_di.di_size) {
    479   1.1    brezak 		rc = buf_read_file(f, &buf, &buf_size);
    480   1.1    brezak 		if (rc)
    481   1.1    brezak 			return (rc);
    482   1.1    brezak 
    483   1.1    brezak 		dp = (struct direct *)buf;
    484   1.1    brezak 		edp = (struct direct *)(buf + buf_size);
    485   1.1    brezak 		while (dp < edp) {
    486   1.1    brezak 			if (dp->d_ino == (ino_t)0)
    487   1.1    brezak 				goto next;
    488   1.1    brezak #if BYTE_ORDER == LITTLE_ENDIAN
    489   1.1    brezak 			if (fp->f_fs->fs_maxsymlinklen <= 0)
    490   1.1    brezak 				namlen = dp->d_type;
    491   1.1    brezak 			else
    492   1.1    brezak #endif
    493   1.1    brezak 				namlen = dp->d_namlen;
    494   1.1    brezak 			if (namlen == length &&
    495   1.1    brezak 			    !strcmp(name, dp->d_name)) {
    496   1.1    brezak 				/* found entry */
    497   1.1    brezak 				*inumber_p = dp->d_ino;
    498   1.1    brezak 				return (0);
    499   1.1    brezak 			}
    500   1.1    brezak 		next:
    501   1.1    brezak 			dp = (struct direct *)((char *)dp + dp->d_reclen);
    502   1.1    brezak 		}
    503   1.1    brezak 		fp->f_seekp += buf_size;
    504   1.1    brezak 	}
    505   1.1    brezak 	return (ENOENT);
    506   1.1    brezak }
    507   1.1    brezak 
    508  1.35       dsl #ifdef LIBSA_FFSv2
    509  1.33      fvdl 
    510  1.33      fvdl daddr_t sblock_try[] = SBLOCKSEARCH;
    511  1.33      fvdl 
    512  1.33      fvdl static int
    513  1.33      fvdl ffs_find_superblock(f, fs)
    514  1.33      fvdl 	struct open_file *f;
    515  1.33      fvdl 	struct fs *fs;
    516  1.33      fvdl {
    517  1.33      fvdl 	int i, rc;
    518  1.33      fvdl 	size_t buf_size;
    519  1.33      fvdl 
    520  1.33      fvdl 	for (i = 0; sblock_try[i] != -1; i++) {
    521  1.33      fvdl 		rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
    522  1.33      fvdl 		    sblock_try[i] / DEV_BSIZE, SBLOCKSIZE, (char *)fs,
    523  1.33      fvdl 		    &buf_size);
    524  1.33      fvdl 		if (rc != 0 || buf_size != SBLOCKSIZE)
    525  1.33      fvdl 			return rc;
    526  1.33      fvdl 		if (fs->fs_magic == FS_UFS2_MAGIC) {
    527  1.33      fvdl 			return 0;
    528  1.33      fvdl 		}
    529  1.33      fvdl 	}
    530  1.33      fvdl 	return EINVAL;
    531  1.33      fvdl }
    532  1.33      fvdl 
    533  1.33      fvdl #endif
    534  1.33      fvdl 
    535   1.1    brezak /*
    536   1.1    brezak  * Open a file.
    537   1.1    brezak  */
    538   1.1    brezak int
    539   1.1    brezak ufs_open(path, f)
    540   1.1    brezak 	char *path;
    541   1.1    brezak 	struct open_file *f;
    542   1.1    brezak {
    543  1.23       cgd #ifndef LIBSA_FS_SINGLECOMPONENT
    544  1.30  augustss 	char *cp, *ncp;
    545  1.30  augustss 	int c;
    546  1.23       cgd #endif
    547  1.23       cgd 	ino_t inumber;
    548   1.1    brezak 	struct file *fp;
    549   1.1    brezak 	struct fs *fs;
    550  1.10        ws 	int rc;
    551  1.23       cgd #ifndef LIBSA_NO_FS_SYMLINK
    552  1.23       cgd 	ino_t parent_inumber;
    553  1.10        ws 	int nlinks = 0;
    554   1.1    brezak 	char namebuf[MAXPATHLEN+1];
    555   1.9        pk 	char *buf = NULL;
    556  1.22    simonb #endif
    557   1.1    brezak 
    558   1.1    brezak 	/* allocate file system specific data structure */
    559   1.1    brezak 	fp = alloc(sizeof(struct file));
    560   1.1    brezak 	bzero(fp, sizeof(struct file));
    561   1.1    brezak 	f->f_fsdata = (void *)fp;
    562   1.1    brezak 
    563   1.1    brezak 	/* allocate space and read super block */
    564  1.33      fvdl 	fs = alloc(SBLOCKSIZE);
    565   1.1    brezak 	fp->f_fs = fs;
    566  1.11   mycroft 	twiddle();
    567  1.33      fvdl 
    568  1.35       dsl #ifdef LIBSA_FFSv2
    569  1.33      fvdl 	rc = ffs_find_superblock(f, fs);
    570  1.33      fvdl 	if (rc)
    571  1.33      fvdl 		goto out;
    572  1.33      fvdl #else
    573  1.35       dsl 	{
    574  1.35       dsl 		size_t buf_size;
    575  1.35       dsl 		rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
    576  1.35       dsl 			SBLOCKOFFSET / DEV_BSIZE,
    577  1.35       dsl 			SBLOCKSIZE, (char *)fs, &buf_size);
    578  1.35       dsl 		if (rc)
    579  1.35       dsl 			goto out;
    580  1.35       dsl 		if (buf_size != SBLOCKSIZE ||
    581  1.35       dsl #ifdef LIBSA_FFS
    582  1.35       dsl 		    fs->lfs_version != REQUIRED_LFS_VERSION ||
    583  1.35       dsl #endif
    584  1.35       dsl 		    fs->fs_magic != FS_MAGIC) {
    585  1.35       dsl 			rc = EINVAL;
    586  1.35       dsl 			goto out;
    587  1.35       dsl 		}
    588  1.33      fvdl 	}
    589  1.35       dsl #if defined(LIBSA_LFS) && REQUIRED_LFS_VERSION == 2
    590  1.35       dsl 	/*
    591  1.35       dsl 	 * XXX	We should check the second superblock and use the eldest
    592  1.35       dsl 	 *	of the two.  See comments near the top of lfs_mountfs()
    593  1.35       dsl 	 *	in sys/ufs/lfs/lfs_vfsops.c.
    594  1.35       dsl 	 *      This may need a LIBSA_LFS_SMALL check as well.
    595  1.35       dsl 	 */
    596  1.35       dsl #endif
    597  1.33      fvdl #endif
    598   1.1    brezak 
    599  1.35       dsl #ifdef LIBSA_FFSv1
    600  1.33      fvdl 	ffs_oldfscompat(fs);
    601  1.35       dsl #endif
    602  1.33      fvdl 
    603  1.33      fvdl 	if (fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {
    604   1.1    brezak 		rc = EINVAL;
    605   1.1    brezak 		goto out;
    606   1.1    brezak 	}
    607   1.1    brezak 
    608   1.1    brezak 	/*
    609   1.1    brezak 	 * Calculate indirect block levels.
    610   1.1    brezak 	 */
    611   1.1    brezak 	{
    612  1.35       dsl 		daddr_t mult;
    613  1.30  augustss 		int level;
    614  1.35       dsl 		int ln2;
    615  1.35       dsl 
    616  1.35       dsl 		/*
    617  1.35       dsl 		 * We note that the number of indirect blocks is always
    618  1.35       dsl 		 * a power of 2.  This lets us use shifts and masks instead
    619  1.35       dsl 		 * of divide and remainder and avoinds pulling in the
    620  1.35       dsl 		 * 64bit division routine into the boot code.
    621  1.35       dsl 		 */
    622  1.35       dsl 		mult = NINDIR(fs);
    623  1.35       dsl #ifdef DEBUG
    624  1.35       dsl 		if (mult & (mult - 1)) {
    625  1.35       dsl 			/* Hummm was't a power of 2 */
    626  1.35       dsl 			rc = EINVAL;
    627  1.35       dsl 			goto out;
    628  1.35       dsl 		}
    629  1.35       dsl #endif
    630  1.35       dsl 		for (ln2 = 0; mult != 1; ln2++)
    631  1.35       dsl 			mult >>= 1;
    632   1.1    brezak 
    633   1.1    brezak 		for (level = 0; level < NIADDR; level++) {
    634   1.1    brezak 			mult *= NINDIR(fs);
    635   1.1    brezak 			fp->f_nindir[level] = mult;
    636  1.35       dsl 			fp->f_l2indir[level] = ln2 * (level + 1);
    637   1.1    brezak 		}
    638   1.1    brezak 	}
    639   1.1    brezak 
    640   1.1    brezak 	inumber = ROOTINO;
    641   1.1    brezak 	if ((rc = read_inode(inumber, f)) != 0)
    642   1.1    brezak 		goto out;
    643   1.1    brezak 
    644  1.23       cgd #ifndef LIBSA_FS_SINGLECOMPONENT
    645   1.1    brezak 	cp = path;
    646   1.1    brezak 	while (*cp) {
    647   1.1    brezak 
    648   1.1    brezak 		/*
    649   1.1    brezak 		 * Remove extra separators
    650   1.1    brezak 		 */
    651   1.1    brezak 		while (*cp == '/')
    652   1.1    brezak 			cp++;
    653   1.1    brezak 		if (*cp == '\0')
    654   1.1    brezak 			break;
    655   1.1    brezak 
    656   1.1    brezak 		/*
    657   1.1    brezak 		 * Check that current node is a directory.
    658   1.1    brezak 		 */
    659  1.35       dsl 		if ((fp->f_di.di_mode & IFMT) != IFDIR) {
    660   1.1    brezak 			rc = ENOTDIR;
    661   1.1    brezak 			goto out;
    662   1.1    brezak 		}
    663   1.1    brezak 
    664   1.1    brezak 		/*
    665   1.1    brezak 		 * Get next component of path name.
    666   1.1    brezak 		 */
    667   1.1    brezak 		{
    668  1.30  augustss 			int len = 0;
    669   1.1    brezak 
    670   1.1    brezak 			ncp = cp;
    671   1.1    brezak 			while ((c = *cp) != '\0' && c != '/') {
    672   1.1    brezak 				if (++len > MAXNAMLEN) {
    673   1.1    brezak 					rc = ENOENT;
    674   1.1    brezak 					goto out;
    675   1.1    brezak 				}
    676   1.1    brezak 				cp++;
    677   1.1    brezak 			}
    678   1.1    brezak 			*cp = '\0';
    679   1.1    brezak 		}
    680   1.1    brezak 
    681   1.1    brezak 		/*
    682   1.1    brezak 		 * Look up component in current directory.
    683   1.1    brezak 		 * Save directory inumber in case we find a
    684   1.1    brezak 		 * symbolic link.
    685   1.1    brezak 		 */
    686  1.23       cgd #ifndef LIBSA_NO_FS_SYMLINK
    687   1.1    brezak 		parent_inumber = inumber;
    688  1.23       cgd #endif
    689   1.1    brezak 		rc = search_directory(ncp, f, &inumber);
    690   1.1    brezak 		*cp = c;
    691   1.1    brezak 		if (rc)
    692   1.1    brezak 			goto out;
    693   1.1    brezak 
    694   1.1    brezak 		/*
    695   1.1    brezak 		 * Open next component.
    696   1.1    brezak 		 */
    697   1.1    brezak 		if ((rc = read_inode(inumber, f)) != 0)
    698   1.1    brezak 			goto out;
    699   1.1    brezak 
    700  1.23       cgd #ifndef LIBSA_NO_FS_SYMLINK
    701   1.1    brezak 		/*
    702   1.1    brezak 		 * Check for symbolic link.
    703   1.1    brezak 		 */
    704  1.35       dsl 		if ((fp->f_di.di_mode & IFMT) == IFLNK) {
    705  1.35       dsl 			int link_len = fp->f_di.di_size;
    706  1.10        ws 			int len;
    707  1.10        ws 
    708  1.10        ws 			len = strlen(cp);
    709   1.1    brezak 
    710  1.10        ws 			if (link_len + len > MAXPATHLEN ||
    711  1.10        ws 			    ++nlinks > MAXSYMLINKS) {
    712   1.1    brezak 				rc = ENOENT;
    713   1.1    brezak 				goto out;
    714   1.1    brezak 			}
    715   1.1    brezak 
    716  1.10        ws 			bcopy(cp, &namebuf[link_len], len + 1);
    717   1.1    brezak 
    718   1.9        pk 			if (link_len < fs->fs_maxsymlinklen) {
    719  1.35       dsl 				bcopy(fp->f_di.di_db, namebuf,
    720  1.35       dsl 				      (unsigned)link_len);
    721   1.1    brezak 			} else {
    722   1.1    brezak 				/*
    723   1.1    brezak 				 * Read file for symbolic link
    724   1.1    brezak 				 */
    725  1.13       cgd 				size_t buf_size;
    726  1.10        ws 				daddr_t	disk_block;
    727   1.9        pk 
    728   1.9        pk 				if (!buf)
    729  1.10        ws 					buf = alloc(fs->fs_bsize);
    730  1.10        ws 				rc = block_map(f, (daddr_t)0, &disk_block);
    731   1.9        pk 				if (rc)
    732   1.9        pk 					goto out;
    733  1.22    simonb 
    734  1.11   mycroft 				twiddle();
    735  1.23       cgd 				rc = DEV_STRATEGY(f->f_dev)(f->f_devdata,
    736  1.35       dsl 					F_READ, FSBTODB(fs, disk_block),
    737   1.9        pk 					fs->fs_bsize, buf, &buf_size);
    738   1.1    brezak 				if (rc)
    739   1.1    brezak 					goto out;
    740   1.1    brezak 
    741  1.35       dsl 				bcopy(buf, namebuf, (unsigned)link_len);
    742   1.1    brezak 			}
    743   1.1    brezak 
    744   1.1    brezak 			/*
    745   1.1    brezak 			 * If relative pathname, restart at parent directory.
    746   1.1    brezak 			 * If absolute pathname, restart at root.
    747   1.1    brezak 			 */
    748   1.1    brezak 			cp = namebuf;
    749   1.1    brezak 			if (*cp != '/')
    750   1.1    brezak 				inumber = parent_inumber;
    751   1.1    brezak 			else
    752   1.1    brezak 				inumber = (ino_t)ROOTINO;
    753   1.1    brezak 
    754   1.9        pk 			if ((rc = read_inode(inumber, f)) != 0)
    755   1.1    brezak 				goto out;
    756   1.1    brezak 		}
    757  1.23       cgd #endif	/* !LIBSA_NO_FS_SYMLINK */
    758   1.1    brezak 	}
    759   1.1    brezak 
    760   1.1    brezak 	/*
    761   1.1    brezak 	 * Found terminal component.
    762   1.1    brezak 	 */
    763   1.1    brezak 	rc = 0;
    764  1.23       cgd 
    765  1.23       cgd #else /* !LIBSA_FS_SINGLECOMPONENT */
    766  1.23       cgd 
    767  1.23       cgd 	/* look up component in the current (root) directory */
    768  1.23       cgd 	rc = search_directory(path, f, &inumber);
    769  1.23       cgd 	if (rc)
    770  1.23       cgd 		goto out;
    771  1.23       cgd 
    772  1.23       cgd 	/* open it */
    773  1.23       cgd 	rc = read_inode(inumber, f);
    774  1.23       cgd 
    775  1.23       cgd #endif /* !LIBSA_FS_SINGLECOMPONENT */
    776  1.26       cgd 
    777  1.26       cgd         fp->f_seekp = 0;		/* reset seek pointer */
    778  1.23       cgd 
    779   1.1    brezak out:
    780  1.23       cgd #ifndef LIBSA_NO_FS_SYMLINK
    781   1.9        pk 	if (buf)
    782   1.9        pk 		free(buf, fs->fs_bsize);
    783  1.22    simonb #endif
    784  1.16        ws 	if (rc) {
    785  1.17       cgd 		if (fp->f_buf)
    786  1.17       cgd 			free(fp->f_buf, fp->f_fs->fs_bsize);
    787  1.33      fvdl 		free(fp->f_fs, SBLOCKSIZE);
    788   1.1    brezak 		free(fp, sizeof(struct file));
    789  1.16        ws 	}
    790   1.1    brezak 	return (rc);
    791   1.1    brezak }
    792   1.1    brezak 
    793  1.23       cgd #ifndef LIBSA_NO_FS_CLOSE
    794   1.1    brezak int
    795   1.1    brezak ufs_close(f)
    796   1.1    brezak 	struct open_file *f;
    797   1.1    brezak {
    798  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    799   1.1    brezak 	int level;
    800   1.1    brezak 
    801   1.1    brezak 	f->f_fsdata = (void *)0;
    802   1.1    brezak 	if (fp == (struct file *)0)
    803   1.1    brezak 		return (0);
    804   1.1    brezak 
    805   1.1    brezak 	for (level = 0; level < NIADDR; level++) {
    806   1.1    brezak 		if (fp->f_blk[level])
    807   1.1    brezak 			free(fp->f_blk[level], fp->f_fs->fs_bsize);
    808   1.1    brezak 	}
    809   1.1    brezak 	if (fp->f_buf)
    810   1.1    brezak 		free(fp->f_buf, fp->f_fs->fs_bsize);
    811  1.33      fvdl 	free(fp->f_fs, SBLOCKSIZE);
    812   1.1    brezak 	free(fp, sizeof(struct file));
    813   1.1    brezak 	return (0);
    814   1.1    brezak }
    815  1.23       cgd #endif /* !LIBSA_NO_FS_CLOSE */
    816   1.1    brezak 
    817   1.1    brezak /*
    818   1.1    brezak  * Copy a portion of a file into kernel memory.
    819   1.1    brezak  * Cross block boundaries when necessary.
    820   1.1    brezak  */
    821   1.1    brezak int
    822   1.1    brezak ufs_read(f, start, size, resid)
    823   1.1    brezak 	struct open_file *f;
    824  1.12        pk 	void *start;
    825  1.12        pk 	size_t size;
    826  1.12        pk 	size_t *resid;	/* out */
    827   1.1    brezak {
    828  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    829  1.30  augustss 	size_t csize;
    830   1.1    brezak 	char *buf;
    831  1.13       cgd 	size_t buf_size;
    832   1.1    brezak 	int rc = 0;
    833  1.30  augustss 	char *addr = start;
    834   1.1    brezak 
    835   1.1    brezak 	while (size != 0) {
    836  1.35       dsl 		if (fp->f_seekp >= fp->f_di.di_size)
    837   1.1    brezak 			break;
    838   1.1    brezak 
    839   1.1    brezak 		rc = buf_read_file(f, &buf, &buf_size);
    840   1.1    brezak 		if (rc)
    841   1.1    brezak 			break;
    842   1.1    brezak 
    843   1.1    brezak 		csize = size;
    844   1.1    brezak 		if (csize > buf_size)
    845   1.1    brezak 			csize = buf_size;
    846   1.1    brezak 
    847  1.12        pk 		bcopy(buf, addr, csize);
    848   1.1    brezak 
    849   1.1    brezak 		fp->f_seekp += csize;
    850  1.12        pk 		addr += csize;
    851   1.1    brezak 		size -= csize;
    852   1.1    brezak 	}
    853   1.1    brezak 	if (resid)
    854   1.1    brezak 		*resid = size;
    855   1.1    brezak 	return (rc);
    856   1.1    brezak }
    857   1.1    brezak 
    858   1.1    brezak /*
    859   1.1    brezak  * Not implemented.
    860   1.1    brezak  */
    861  1.23       cgd #ifndef LIBSA_NO_FS_WRITE
    862   1.1    brezak int
    863   1.1    brezak ufs_write(f, start, size, resid)
    864   1.1    brezak 	struct open_file *f;
    865  1.12        pk 	void *start;
    866  1.12        pk 	size_t size;
    867  1.12        pk 	size_t *resid;	/* out */
    868   1.1    brezak {
    869   1.1    brezak 
    870   1.1    brezak 	return (EROFS);
    871   1.1    brezak }
    872  1.23       cgd #endif /* !LIBSA_NO_FS_WRITE */
    873   1.1    brezak 
    874  1.23       cgd #ifndef LIBSA_NO_FS_SEEK
    875   1.1    brezak off_t
    876   1.1    brezak ufs_seek(f, offset, where)
    877   1.1    brezak 	struct open_file *f;
    878   1.1    brezak 	off_t offset;
    879   1.1    brezak 	int where;
    880   1.1    brezak {
    881  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    882   1.1    brezak 
    883   1.1    brezak 	switch (where) {
    884   1.1    brezak 	case SEEK_SET:
    885   1.1    brezak 		fp->f_seekp = offset;
    886   1.1    brezak 		break;
    887   1.1    brezak 	case SEEK_CUR:
    888   1.1    brezak 		fp->f_seekp += offset;
    889   1.1    brezak 		break;
    890   1.1    brezak 	case SEEK_END:
    891  1.35       dsl 		fp->f_seekp = fp->f_di.di_size - offset;
    892   1.1    brezak 		break;
    893   1.1    brezak 	default:
    894   1.1    brezak 		return (-1);
    895   1.1    brezak 	}
    896   1.1    brezak 	return (fp->f_seekp);
    897   1.1    brezak }
    898  1.23       cgd #endif /* !LIBSA_NO_FS_SEEK */
    899   1.1    brezak 
    900   1.1    brezak int
    901   1.1    brezak ufs_stat(f, sb)
    902   1.1    brezak 	struct open_file *f;
    903   1.1    brezak 	struct stat *sb;
    904   1.1    brezak {
    905  1.30  augustss 	struct file *fp = (struct file *)f->f_fsdata;
    906   1.1    brezak 
    907   1.1    brezak 	/* only important stuff */
    908  1.35       dsl 	sb->st_mode = fp->f_di.di_mode;
    909  1.35       dsl 	sb->st_uid = fp->f_di.di_uid;
    910  1.35       dsl 	sb->st_gid = fp->f_di.di_gid;
    911  1.35       dsl 	sb->st_size = fp->f_di.di_size;
    912   1.4        pk 	return (0);
    913   1.4        pk }
    914   1.4        pk 
    915  1.35       dsl #ifdef LIBSA_FFSv1
    916   1.4        pk /*
    917   1.4        pk  * Sanity checks for old file systems.
    918   1.4        pk  *
    919   1.4        pk  * XXX - goes away some day.
    920   1.4        pk  */
    921  1.13       cgd static void
    922   1.4        pk ffs_oldfscompat(fs)
    923   1.4        pk 	struct fs *fs;
    924   1.4        pk {
    925  1.34        he #ifdef COMPAT_UFS
    926   1.4        pk 	int i;
    927  1.34        he #endif
    928   1.4        pk 
    929  1.33      fvdl 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_size != fs->fs_old_size) {
    930  1.33      fvdl 		fs->fs_maxbsize = fs->fs_bsize;
    931  1.33      fvdl 		fs->fs_time = fs->fs_old_time;
    932  1.33      fvdl 		fs->fs_size = fs->fs_old_size;
    933  1.33      fvdl 		fs->fs_dsize = fs->fs_old_dsize;
    934  1.33      fvdl 		fs->fs_csaddr = fs->fs_old_csaddr;
    935  1.33      fvdl 		fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
    936  1.33      fvdl 		fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
    937  1.33      fvdl 		fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
    938  1.33      fvdl 		fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
    939  1.33      fvdl 	}
    940  1.33      fvdl #ifdef COMPAT_UFS
    941  1.33      fvdl 	if (fs->fs_magic == FS_UFS1_MAGIC &&
    942  1.33      fvdl 	    fs->fs_old_inodefmt < FS_44INODEFMT) {
    943  1.33      fvdl 		quad_t sizepb = fs->fs_bsize;
    944  1.33      fvdl 		fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1;
    945  1.33      fvdl 		for (i = 0; i < NIADDR; i++) {
    946  1.33      fvdl 			sizepb *= NINDIR(fs);
    947  1.33      fvdl 			fs->fs_maxfilesize += sizepb;
    948  1.33      fvdl 		}
    949  1.33      fvdl 		fs->fs_qbmask = ~fs->fs_bmask;
    950  1.33      fvdl 		fs->fs_qfmask = ~fs->fs_fmask;
    951  1.33      fvdl 	}
    952  1.33      fvdl #endif
    953   1.1    brezak }
    954  1.35       dsl #endif
    955