xref: /illumos-gate/usr/src/boot/libsa/ext2fs.c (revision 55fea89d)
1199767f8SToomas Soome /*-
2199767f8SToomas Soome  * Copyright (c) 1999,2000 Jonathan Lemon <jlemon@freebsd.org>
3199767f8SToomas Soome  * All rights reserved.
4199767f8SToomas Soome  *
5199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
6199767f8SToomas Soome  * modification, are permitted provided that the following conditions
7199767f8SToomas Soome  * are met:
8199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
9199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
10199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
11199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
12199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
13199767f8SToomas Soome  *
14199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24199767f8SToomas Soome  * SUCH DAMAGE.
25199767f8SToomas Soome  */
26199767f8SToomas Soome 
27199767f8SToomas Soome #include <sys/cdefs.h>
28199767f8SToomas Soome __FBSDID("$FreeBSD$");
29199767f8SToomas Soome 
30199767f8SToomas Soome /*-
31199767f8SToomas Soome  * Copyright (c) 1993
32199767f8SToomas Soome  *	The Regents of the University of California.  All rights reserved.
33199767f8SToomas Soome  *
34199767f8SToomas Soome  * This code is derived from software contributed to Berkeley by
35199767f8SToomas Soome  * The Mach Operating System project at Carnegie-Mellon University.
36199767f8SToomas Soome  *
37199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
38199767f8SToomas Soome  * modification, are permitted provided that the following conditions
39199767f8SToomas Soome  * are met:
40199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
41199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
42199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
43199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
44199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
45199767f8SToomas Soome  * 3. All advertising materials mentioning features or use of this software
46199767f8SToomas Soome  *    must display the following acknowledgement:
47199767f8SToomas Soome  *	This product includes software developed by the University of
48199767f8SToomas Soome  *	California, Berkeley and its contributors.
49199767f8SToomas Soome  * 4. Neither the name of the University nor the names of its contributors
50199767f8SToomas Soome  *    may be used to endorse or promote products derived from this software
51199767f8SToomas Soome  *    without specific prior written permission.
52199767f8SToomas Soome  *
53199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63199767f8SToomas Soome  * SUCH DAMAGE.
64*55fea89dSDan Cross  *
65199767f8SToomas Soome  *
66199767f8SToomas Soome  * Copyright (c) 1990, 1991 Carnegie Mellon University
67199767f8SToomas Soome  * All Rights Reserved.
68199767f8SToomas Soome  *
69199767f8SToomas Soome  * Author: David Golub
70*55fea89dSDan Cross  *
71199767f8SToomas Soome  * Permission to use, copy, modify and distribute this software and its
72199767f8SToomas Soome  * documentation is hereby granted, provided that both the copyright
73199767f8SToomas Soome  * notice and this permission notice appear in all copies of the
74199767f8SToomas Soome  * software, derivative works or modified versions, and any portions
75199767f8SToomas Soome  * thereof, and that both notices appear in supporting documentation.
76*55fea89dSDan Cross  *
77199767f8SToomas Soome  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
78199767f8SToomas Soome  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
79199767f8SToomas Soome  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
80*55fea89dSDan Cross  *
81199767f8SToomas Soome  * Carnegie Mellon requests users of this software to return to
82*55fea89dSDan Cross  *
83199767f8SToomas Soome  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
84199767f8SToomas Soome  *  School of Computer Science
85199767f8SToomas Soome  *  Carnegie Mellon University
86199767f8SToomas Soome  *  Pittsburgh PA 15213-3890
87*55fea89dSDan Cross  *
88199767f8SToomas Soome  * any improvements or extensions that they make and grant Carnegie the
89199767f8SToomas Soome  * rights to redistribute these changes.
90199767f8SToomas Soome  */
91199767f8SToomas Soome 
92199767f8SToomas Soome #include <sys/param.h>
93199767f8SToomas Soome #include <sys/time.h>
94199767f8SToomas Soome #include "stand.h"
95199767f8SToomas Soome #include "string.h"
96199767f8SToomas Soome 
97199767f8SToomas Soome static int	ext2fs_open(const char *path, struct open_file *f);
98199767f8SToomas Soome static int	ext2fs_close(struct open_file *f);
99199767f8SToomas Soome static int	ext2fs_read(struct open_file *f, void *buf,
100199767f8SToomas Soome 			 size_t size, size_t *resid);
101199767f8SToomas Soome static off_t	ext2fs_seek(struct open_file *f, off_t offset, int where);
102199767f8SToomas Soome static int	ext2fs_stat(struct open_file *f, struct stat *sb);
103199767f8SToomas Soome static int	ext2fs_readdir(struct open_file *f, struct dirent *d);
104199767f8SToomas Soome 
105199767f8SToomas Soome static int dtmap[] = { DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR,
106199767f8SToomas Soome 			 DT_BLK, DT_FIFO, DT_SOCK, DT_LNK };
107199767f8SToomas Soome #define EXTFTODT(x)	(x) > sizeof(dtmap) / sizeof(dtmap[0]) ? \
108199767f8SToomas Soome 			DT_UNKNOWN : dtmap[x]
109199767f8SToomas Soome 
110199767f8SToomas Soome struct fs_ops ext2fs_fsops = {
111199767f8SToomas Soome 	"ext2fs",
112199767f8SToomas Soome 	ext2fs_open,
113199767f8SToomas Soome 	ext2fs_close,
114199767f8SToomas Soome 	ext2fs_read,
115199767f8SToomas Soome 	null_write,
116199767f8SToomas Soome 	ext2fs_seek,
117199767f8SToomas Soome 	ext2fs_stat,
118199767f8SToomas Soome 	ext2fs_readdir
119199767f8SToomas Soome };
120199767f8SToomas Soome 
121199767f8SToomas Soome #define	EXT2_SBSIZE	1024
122199767f8SToomas Soome #define	EXT2_SBLOCK	(1024 / DEV_BSIZE)	/* block offset of superblock */
123199767f8SToomas Soome #define EXT2_MAGIC	0xef53
124199767f8SToomas Soome #define EXT2_ROOTINO	2
125199767f8SToomas Soome 
126199767f8SToomas Soome #define EXT2_REV0		0	/* original revision of ext2 */
127199767f8SToomas Soome #define EXT2_R0_ISIZE		128	/* inode size */
128199767f8SToomas Soome #define EXT2_R0_FIRSTINO	11	/* first inode */
129199767f8SToomas Soome 
130199767f8SToomas Soome #define EXT2_MINBSHIFT		10	/* mininum block shift */
131199767f8SToomas Soome #define EXT2_MINFSHIFT		10	/* mininum frag shift */
132199767f8SToomas Soome 
133199767f8SToomas Soome #define NDADDR		12		/* # of direct blocks */
134199767f8SToomas Soome #define NIADDR		3		/* # of indirect blocks */
135199767f8SToomas Soome 
136199767f8SToomas Soome /*
137199767f8SToomas Soome  * file system block to disk address
138199767f8SToomas Soome  */
139199767f8SToomas Soome #define fsb_to_db(fs, blk)	((blk) << (fs)->fs_fsbtodb)
140199767f8SToomas Soome 
141199767f8SToomas Soome /*
142199767f8SToomas Soome  * inode to block group offset
143199767f8SToomas Soome  * inode to block group
144199767f8SToomas Soome  * inode to disk address
145199767f8SToomas Soome  * inode to block offset
146199767f8SToomas Soome  */
147199767f8SToomas Soome #define ino_to_bgo(fs, ino)	(((ino) - 1) % (fs)->fs_ipg)
148199767f8SToomas Soome #define ino_to_bg(fs, ino)	(((ino) - 1) / (fs)->fs_ipg)
149199767f8SToomas Soome #define ino_to_db(fs, bg, ino) \
150199767f8SToomas Soome 	fsb_to_db(fs, ((bg)[ino_to_bg(fs, ino)].bg_inotbl + \
151199767f8SToomas Soome 	    ino_to_bgo(fs, ino) / (fs)->fs_ipb))
152199767f8SToomas Soome #define ino_to_bo(fs, ino)	(ino_to_bgo(fs, ino) % (fs)->fs_ipb)
153199767f8SToomas Soome 
154199767f8SToomas Soome #define nindir(fs) \
155199767f8SToomas Soome 	((fs)->fs_bsize / sizeof(u_int32_t))
156199767f8SToomas Soome #define lblkno(fs, loc)				/* loc / bsize */ \
157199767f8SToomas Soome 	((loc) >> (fs)->fs_bshift)
158199767f8SToomas Soome #define smalllblktosize(fs, blk)		/* blk * bsize */ \
159199767f8SToomas Soome 	((blk) << (fs)->fs_bshift)
160199767f8SToomas Soome #define blkoff(fs, loc)				/* loc % bsize */ \
161199767f8SToomas Soome 	((loc) & (fs)->fs_bmask)
162199767f8SToomas Soome #define fragroundup(fs, size)			/* roundup(size, fsize) */ \
163199767f8SToomas Soome 	(((size) + (fs)->fs_fmask) & ~(fs)->fs_fmask)
164199767f8SToomas Soome #define dblksize(fs, dip, lbn) \
165199767f8SToomas Soome 	(((lbn) >= NDADDR || (dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \
166199767f8SToomas Soome 	    ? (fs)->fs_bsize \
167199767f8SToomas Soome 	    : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
168199767f8SToomas Soome 
169199767f8SToomas Soome /*
170199767f8SToomas Soome  * superblock describing ext2fs
171199767f8SToomas Soome  */
172199767f8SToomas Soome struct ext2fs_disk {
173199767f8SToomas Soome 	u_int32_t	fd_inodes;	/* # of inodes */
174199767f8SToomas Soome 	u_int32_t	fd_blocks;	/* # of blocks */
175199767f8SToomas Soome 	u_int32_t	fd_resblk;	/* # of reserved blocks */
176199767f8SToomas Soome 	u_int32_t	fd_freeblk;	/* # of free blocks */
177199767f8SToomas Soome 	u_int32_t	fd_freeino;	/* # of free inodes */
178199767f8SToomas Soome 	u_int32_t	fd_firstblk;	/* first data block */
179199767f8SToomas Soome 	u_int32_t	fd_bsize;	/* block size */
180199767f8SToomas Soome 	u_int32_t	fd_fsize;	/* frag size */
181199767f8SToomas Soome 	u_int32_t	fd_bpg;		/* blocks per group */
182199767f8SToomas Soome 	u_int32_t	fd_fpg;		/* frags per group */
183199767f8SToomas Soome 	u_int32_t	fd_ipg;		/* inodes per group */
184199767f8SToomas Soome 	u_int32_t	fd_mtime;	/* mount time */
185199767f8SToomas Soome 	u_int32_t	fd_wtime;	/* write time */
186199767f8SToomas Soome 	u_int16_t	fd_mount;	/* # of mounts */
187199767f8SToomas Soome 	int16_t		fd_maxmount;	/* max # of mounts */
188199767f8SToomas Soome 	u_int16_t	fd_magic;	/* magic number */
189199767f8SToomas Soome 	u_int16_t	fd_state;	/* state */
190199767f8SToomas Soome 	u_int16_t	fd_eflag;	/* error flags */
191199767f8SToomas Soome 	u_int16_t	fd_mnrrev;	/* minor revision */
192199767f8SToomas Soome 	u_int32_t	fd_lastchk;	/* last check */
193199767f8SToomas Soome 	u_int32_t	fd_chkintvl;	/* maximum check interval */
194199767f8SToomas Soome 	u_int32_t	fd_os;		/* os */
195199767f8SToomas Soome 	u_int32_t	fd_revision;	/* revision */
196199767f8SToomas Soome 	u_int16_t	fd_uid;		/* uid for reserved blocks */
197199767f8SToomas Soome 	u_int16_t	fd_gid;		/* gid for reserved blocks */
198199767f8SToomas Soome 
199199767f8SToomas Soome 	u_int32_t	fd_firstino;	/* first non-reserved inode */
200199767f8SToomas Soome 	u_int16_t	fd_isize;	/* inode size */
201199767f8SToomas Soome 	u_int16_t	fd_nblkgrp;	/* block group # of superblock */
202199767f8SToomas Soome 	u_int32_t	fd_fcompat;	/* compatible features */
203199767f8SToomas Soome 	u_int32_t	fd_fincompat;	/* incompatible features */
204199767f8SToomas Soome 	u_int32_t	fd_frocompat;	/* read-only compatibilties */
205199767f8SToomas Soome 	u_int8_t	fd_uuid[16];	/* volume uuid */
206199767f8SToomas Soome 	char 		fd_volname[16];	/* volume name */
207199767f8SToomas Soome 	char 		fd_fsmnt[64];	/* name last mounted on */
208199767f8SToomas Soome 	u_int32_t	fd_bitmap;	/* compression bitmap */
209199767f8SToomas Soome 
210*55fea89dSDan Cross 	u_int8_t	fd_nblkpa;	/* # of blocks to preallocate */
211199767f8SToomas Soome 	u_int8_t	fd_ndblkpa;	/* # of dir blocks to preallocate */
212199767f8SToomas Soome };
213199767f8SToomas Soome 
214199767f8SToomas Soome struct ext2fs_core {
215199767f8SToomas Soome 	int		fc_bsize;	/* block size */
216199767f8SToomas Soome 	int		fc_bshift;	/* block shift amount */
217199767f8SToomas Soome 	int		fc_bmask;	/* block mask */
218199767f8SToomas Soome 	int		fc_fsize;	/* frag size */
219199767f8SToomas Soome 	int		fc_fshift;	/* frag shift amount */
220199767f8SToomas Soome 	int		fc_fmask;	/* frag mask */
221199767f8SToomas Soome 	int		fc_isize;	/* inode size */
222199767f8SToomas Soome 	int		fc_imask;	/* inode mask */
223199767f8SToomas Soome 	int		fc_firstino;	/* first non-reserved inode */
224199767f8SToomas Soome 	int		fc_ipb;		/* inodes per block */
225199767f8SToomas Soome 	int		fc_fsbtodb;	/* fsb to ds shift */
226199767f8SToomas Soome };
227199767f8SToomas Soome 
228199767f8SToomas Soome struct ext2fs {
229199767f8SToomas Soome 	struct		ext2fs_disk fs_fd;
230199767f8SToomas Soome 	char		fs_pad[EXT2_SBSIZE - sizeof(struct ext2fs_disk)];
231199767f8SToomas Soome 	struct		ext2fs_core fs_fc;
232199767f8SToomas Soome 
233199767f8SToomas Soome #define fs_magic	fs_fd.fd_magic
234199767f8SToomas Soome #define fs_revision	fs_fd.fd_revision
235199767f8SToomas Soome #define fs_blocks	fs_fd.fd_blocks
236199767f8SToomas Soome #define fs_firstblk	fs_fd.fd_firstblk
237199767f8SToomas Soome #define fs_bpg		fs_fd.fd_bpg
238199767f8SToomas Soome #define fs_ipg		fs_fd.fd_ipg
239*55fea89dSDan Cross 
240199767f8SToomas Soome #define fs_bsize	fs_fc.fc_bsize
241199767f8SToomas Soome #define fs_bshift	fs_fc.fc_bshift
242199767f8SToomas Soome #define fs_bmask	fs_fc.fc_bmask
243199767f8SToomas Soome #define fs_fsize	fs_fc.fc_fsize
244199767f8SToomas Soome #define fs_fshift	fs_fc.fc_fshift
245199767f8SToomas Soome #define fs_fmask	fs_fc.fc_fmask
246199767f8SToomas Soome #define fs_isize	fs_fc.fc_isize
247199767f8SToomas Soome #define fs_imask	fs_fc.fc_imask
248199767f8SToomas Soome #define fs_firstino	fs_fc.fc_firstino
249199767f8SToomas Soome #define fs_ipb		fs_fc.fc_ipb
250199767f8SToomas Soome #define fs_fsbtodb	fs_fc.fc_fsbtodb
251199767f8SToomas Soome };
252199767f8SToomas Soome 
253199767f8SToomas Soome struct ext2blkgrp {
254199767f8SToomas Soome 	u_int32_t	bg_blkmap;	/* block bitmap */
255199767f8SToomas Soome 	u_int32_t	bg_inomap;	/* inode bitmap */
256199767f8SToomas Soome 	u_int32_t	bg_inotbl;	/* inode table */
257199767f8SToomas Soome 	u_int16_t	bg_nfblk;	/* # of free blocks */
258199767f8SToomas Soome 	u_int16_t	bg_nfino;	/* # of free inodes */
259199767f8SToomas Soome 	u_int16_t	bg_ndirs;	/* # of dirs */
260199767f8SToomas Soome 	char		bg_pad[14];
261199767f8SToomas Soome };
262199767f8SToomas Soome 
263199767f8SToomas Soome struct ext2dinode {
264199767f8SToomas Soome 	u_int16_t	di_mode;	/* mode */
265199767f8SToomas Soome 	u_int16_t	di_uid;		/* uid */
266199767f8SToomas Soome 	u_int32_t	di_size;	/* byte size */
267199767f8SToomas Soome 	u_int32_t	di_atime;	/* access time */
268199767f8SToomas Soome 	u_int32_t	di_ctime;	/* creation time */
269199767f8SToomas Soome 	u_int32_t	di_mtime;	/* modification time */
270199767f8SToomas Soome 	u_int32_t	di_dtime;	/* deletion time */
271199767f8SToomas Soome 	u_int16_t	di_gid;		/* gid */
272199767f8SToomas Soome 	u_int16_t	di_nlink;	/* link count */
273199767f8SToomas Soome 	u_int32_t	di_nblk;	/* block count */
274199767f8SToomas Soome 	u_int32_t	di_flags;	/* file flags */
275199767f8SToomas Soome 
276199767f8SToomas Soome 	u_int32_t	di_osdep1;	/* os dependent stuff */
277199767f8SToomas Soome 
278199767f8SToomas Soome 	u_int32_t	di_db[NDADDR];	/* direct blocks */
279199767f8SToomas Soome 	u_int32_t	di_ib[NIADDR];	/* indirect blocks */
280199767f8SToomas Soome 	u_int32_t	di_version;	/* version */
281199767f8SToomas Soome 	u_int32_t	di_facl;	/* file acl */
282199767f8SToomas Soome 	u_int32_t	di_dacl;	/* dir acl */
283199767f8SToomas Soome 	u_int32_t	di_faddr;	/* fragment addr */
284199767f8SToomas Soome 
285199767f8SToomas Soome 	u_int8_t	di_frag;	/* fragment number */
286199767f8SToomas Soome 	u_int8_t	di_fsize;	/* fragment size */
287199767f8SToomas Soome 
288199767f8SToomas Soome 	char		di_pad[10];
289199767f8SToomas Soome 
290199767f8SToomas Soome #define di_shortlink	di_db
291199767f8SToomas Soome };
292199767f8SToomas Soome 
293199767f8SToomas Soome #define EXT2_MAXNAMLEN       255
294199767f8SToomas Soome 
295199767f8SToomas Soome struct ext2dirent {
296199767f8SToomas Soome 	u_int32_t	d_ino;		/* inode */
297199767f8SToomas Soome 	u_int16_t	d_reclen;	/* directory entry length */
298199767f8SToomas Soome 	u_int8_t	d_namlen;	/* name length */
299199767f8SToomas Soome 	u_int8_t	d_type;		/* file type */
300199767f8SToomas Soome 	char		d_name[EXT2_MAXNAMLEN];
301199767f8SToomas Soome };
302199767f8SToomas Soome 
303199767f8SToomas Soome struct file {
304199767f8SToomas Soome 	off_t		f_seekp;		/* seek pointer */
305199767f8SToomas Soome 	struct 		ext2fs *f_fs;		/* pointer to super-block */
306199767f8SToomas Soome 	struct 		ext2blkgrp *f_bg;	/* pointer to blkgrp map */
307199767f8SToomas Soome 	struct 		ext2dinode f_di;	/* copy of on-disk inode */
308199767f8SToomas Soome 	int		f_nindir[NIADDR];	/* number of blocks mapped by
309199767f8SToomas Soome 						   indirect block at level i */
310199767f8SToomas Soome 	char		*f_blk[NIADDR];		/* buffer for indirect block
311199767f8SToomas Soome 						   at level i */
312199767f8SToomas Soome 	size_t		f_blksize[NIADDR];	/* size of buffer */
313199767f8SToomas Soome 	daddr_t		f_blkno[NIADDR];	/* disk address of block in
314199767f8SToomas Soome 						   buffer */
315199767f8SToomas Soome 	char		*f_buf;			/* buffer for data block */
316199767f8SToomas Soome 	size_t		f_buf_size;		/* size of data block */
317199767f8SToomas Soome 	daddr_t		f_buf_blkno;		/* block number of data block */
318199767f8SToomas Soome };
319199767f8SToomas Soome 
320199767f8SToomas Soome /* forward decls */
321199767f8SToomas Soome static int 	read_inode(ino_t inumber, struct open_file *f);
322199767f8SToomas Soome static int	block_map(struct open_file *f, daddr_t file_block,
323199767f8SToomas Soome 		    daddr_t *disk_block_p);
324199767f8SToomas Soome static int	buf_read_file(struct open_file *f, char **buf_p,
325199767f8SToomas Soome 		    size_t *size_p);
326199767f8SToomas Soome static int	search_directory(char *name, struct open_file *f,
327199767f8SToomas Soome 		    ino_t *inumber_p);
328199767f8SToomas Soome 
329199767f8SToomas Soome /*
330199767f8SToomas Soome  * Open a file.
331199767f8SToomas Soome  */
332199767f8SToomas Soome static int
ext2fs_open(const char * upath,struct open_file * f)333199767f8SToomas Soome ext2fs_open(const char *upath, struct open_file *f)
334199767f8SToomas Soome {
335199767f8SToomas Soome 	struct file *fp;
336199767f8SToomas Soome 	struct ext2fs *fs;
337199767f8SToomas Soome 	size_t buf_size;
338199767f8SToomas Soome 	ino_t inumber, parent_inumber;
339199767f8SToomas Soome 	int i, len, groups, bg_per_blk, blkgrps, mult;
340199767f8SToomas Soome 	int nlinks = 0;
341199767f8SToomas Soome 	int error = 0;
342199767f8SToomas Soome 	char *cp, *ncp, *path = NULL, *buf = NULL;
343199767f8SToomas Soome 	char namebuf[MAXPATHLEN+1];
344199767f8SToomas Soome 	char c;
345199767f8SToomas Soome 
346199767f8SToomas Soome 	/* allocate file system specific data structure */
347199767f8SToomas Soome 	fp = malloc(sizeof(struct file));
348199767f8SToomas Soome 	if (fp == NULL)
349199767f8SToomas Soome 		return (ENOMEM);
350199767f8SToomas Soome 	bzero(fp, sizeof(struct file));
351199767f8SToomas Soome 	f->f_fsdata = (void *)fp;
352199767f8SToomas Soome 
353199767f8SToomas Soome 	/* allocate space and read super block */
354199767f8SToomas Soome 	fs = (struct ext2fs *)malloc(sizeof(*fs));
355199767f8SToomas Soome 	fp->f_fs = fs;
356199767f8SToomas Soome 	twiddle(1);
357199767f8SToomas Soome 	error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
358199767f8SToomas Soome 	    EXT2_SBLOCK, EXT2_SBSIZE, (char *)fs, &buf_size);
359199767f8SToomas Soome 	if (error)
360199767f8SToomas Soome 		goto out;
361199767f8SToomas Soome 
362199767f8SToomas Soome 	if (buf_size != EXT2_SBSIZE || fs->fs_magic != EXT2_MAGIC) {
363199767f8SToomas Soome 		error = EINVAL;
364199767f8SToomas Soome 		goto out;
365199767f8SToomas Soome 	}
366199767f8SToomas Soome 
367199767f8SToomas Soome 	/*
368199767f8SToomas Soome 	 * compute in-core values for the superblock
369199767f8SToomas Soome 	 */
370199767f8SToomas Soome 	fs->fs_bshift = EXT2_MINBSHIFT + fs->fs_fd.fd_bsize;
371199767f8SToomas Soome 	fs->fs_bsize = 1 << fs->fs_bshift;
372199767f8SToomas Soome 	fs->fs_bmask = fs->fs_bsize - 1;
373199767f8SToomas Soome 
374199767f8SToomas Soome 	fs->fs_fshift = EXT2_MINFSHIFT + fs->fs_fd.fd_fsize;
375199767f8SToomas Soome 	fs->fs_fsize = 1 << fs->fs_fshift;
376199767f8SToomas Soome 	fs->fs_fmask = fs->fs_fsize - 1;
377199767f8SToomas Soome 
378199767f8SToomas Soome 	if (fs->fs_revision == EXT2_REV0) {
379199767f8SToomas Soome 		fs->fs_isize = EXT2_R0_ISIZE;
380199767f8SToomas Soome 		fs->fs_firstino = EXT2_R0_FIRSTINO;
381199767f8SToomas Soome 	} else {
382199767f8SToomas Soome 		fs->fs_isize = fs->fs_fd.fd_isize;
383199767f8SToomas Soome 		fs->fs_firstino = fs->fs_fd.fd_firstino;
384199767f8SToomas Soome 	}
385199767f8SToomas Soome 	fs->fs_imask = fs->fs_isize - 1;
386199767f8SToomas Soome 	fs->fs_ipb = fs->fs_bsize / fs->fs_isize;
387199767f8SToomas Soome 	fs->fs_fsbtodb = (fs->fs_bsize / DEV_BSIZE) - 1;
388199767f8SToomas Soome 
389199767f8SToomas Soome 	/*
390199767f8SToomas Soome 	 * we have to load in the "group descriptors" here
391199767f8SToomas Soome 	 */
392199767f8SToomas Soome 	groups = howmany(fs->fs_blocks - fs->fs_firstblk, fs->fs_bpg);
393199767f8SToomas Soome 	bg_per_blk = fs->fs_bsize / sizeof(struct ext2blkgrp);
394199767f8SToomas Soome 	blkgrps = howmany(groups, bg_per_blk);
395199767f8SToomas Soome 	len = blkgrps * fs->fs_bsize;
396199767f8SToomas Soome 
397199767f8SToomas Soome 	fp->f_bg = malloc(len);
398199767f8SToomas Soome 	twiddle(1);
399199767f8SToomas Soome 	error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
400199767f8SToomas Soome 	    EXT2_SBLOCK + EXT2_SBSIZE / DEV_BSIZE, len,
401199767f8SToomas Soome 	    (char *)fp->f_bg, &buf_size);
402199767f8SToomas Soome 	if (error)
403199767f8SToomas Soome 		goto out;
404199767f8SToomas Soome 
405199767f8SToomas Soome 	/*
406199767f8SToomas Soome 	 * XXX
407199767f8SToomas Soome 	 * validation of values?  (blocksize, descriptors, etc?)
408199767f8SToomas Soome 	 */
409199767f8SToomas Soome 
410199767f8SToomas Soome 	/*
411199767f8SToomas Soome 	 * Calculate indirect block levels.
412199767f8SToomas Soome 	 */
413199767f8SToomas Soome 	mult = 1;
414199767f8SToomas Soome 	for (i = 0; i < NIADDR; i++) {
415199767f8SToomas Soome 		mult *= nindir(fs);
416199767f8SToomas Soome 		fp->f_nindir[i] = mult;
417199767f8SToomas Soome 	}
418199767f8SToomas Soome 
419199767f8SToomas Soome 	inumber = EXT2_ROOTINO;
420199767f8SToomas Soome 	if ((error = read_inode(inumber, f)) != 0)
421199767f8SToomas Soome 		goto out;
422199767f8SToomas Soome 
423199767f8SToomas Soome 	path = strdup(upath);
424199767f8SToomas Soome 	if (path == NULL) {
425199767f8SToomas Soome 		error = ENOMEM;
426199767f8SToomas Soome 		goto out;
427199767f8SToomas Soome 	}
428199767f8SToomas Soome 	cp = path;
429199767f8SToomas Soome 	while (*cp) {
430199767f8SToomas Soome 		/*
431199767f8SToomas Soome 		 * Remove extra separators
432199767f8SToomas Soome 		 */
433199767f8SToomas Soome 		while (*cp == '/')
434199767f8SToomas Soome 			cp++;
435199767f8SToomas Soome 		if (*cp == '\0')
436199767f8SToomas Soome 			break;
437199767f8SToomas Soome 
438199767f8SToomas Soome 		/*
439199767f8SToomas Soome 		 * Check that current node is a directory.
440199767f8SToomas Soome 		 */
441199767f8SToomas Soome 		if (! S_ISDIR(fp->f_di.di_mode)) {
442199767f8SToomas Soome 			error = ENOTDIR;
443199767f8SToomas Soome 			goto out;
444199767f8SToomas Soome 		}
445199767f8SToomas Soome 
446199767f8SToomas Soome 		/*
447199767f8SToomas Soome 		 * Get next component of path name.
448199767f8SToomas Soome 		 */
449199767f8SToomas Soome 		len = 0;
450199767f8SToomas Soome 
451199767f8SToomas Soome 		ncp = cp;
452199767f8SToomas Soome 		while ((c = *cp) != '\0' && c != '/') {
453199767f8SToomas Soome 			if (++len > EXT2_MAXNAMLEN) {
454199767f8SToomas Soome 				error = ENOENT;
455199767f8SToomas Soome 				goto out;
456199767f8SToomas Soome 			}
457199767f8SToomas Soome 			cp++;
458199767f8SToomas Soome 		}
459199767f8SToomas Soome 		*cp = '\0';
460199767f8SToomas Soome 
461199767f8SToomas Soome 		/*
462199767f8SToomas Soome 		 * Look up component in current directory.
463199767f8SToomas Soome 		 * Save directory inumber in case we find a
464199767f8SToomas Soome 		 * symbolic link.
465199767f8SToomas Soome 		 */
466199767f8SToomas Soome 		parent_inumber = inumber;
467199767f8SToomas Soome 		error = search_directory(ncp, f, &inumber);
468199767f8SToomas Soome 		*cp = c;
469199767f8SToomas Soome 		if (error)
470199767f8SToomas Soome 			goto out;
471199767f8SToomas Soome 
472199767f8SToomas Soome 		/*
473199767f8SToomas Soome 		 * Open next component.
474199767f8SToomas Soome 		 */
475199767f8SToomas Soome 		if ((error = read_inode(inumber, f)) != 0)
476199767f8SToomas Soome 			goto out;
477199767f8SToomas Soome 
478199767f8SToomas Soome 		/*
479199767f8SToomas Soome 		 * Check for symbolic link.
480199767f8SToomas Soome 		 */
481199767f8SToomas Soome 		if (S_ISLNK(fp->f_di.di_mode)) {
482199767f8SToomas Soome 			int link_len = fp->f_di.di_size;
483199767f8SToomas Soome 			int len;
484199767f8SToomas Soome 
485199767f8SToomas Soome 			len = strlen(cp);
486199767f8SToomas Soome 			if (link_len + len > MAXPATHLEN ||
487199767f8SToomas Soome 			    ++nlinks > MAXSYMLINKS) {
488199767f8SToomas Soome 				error = ENOENT;
489199767f8SToomas Soome 				goto out;
490199767f8SToomas Soome 			}
491199767f8SToomas Soome 
492199767f8SToomas Soome 			bcopy(cp, &namebuf[link_len], len + 1);
493199767f8SToomas Soome 			if (fp->f_di.di_nblk == 0) {
494199767f8SToomas Soome 				bcopy(fp->f_di.di_shortlink,
495199767f8SToomas Soome 				    namebuf, link_len);
496199767f8SToomas Soome 			} else {
497199767f8SToomas Soome 				/*
498199767f8SToomas Soome 				 * Read file for symbolic link
499199767f8SToomas Soome 				 */
500199767f8SToomas Soome 				struct ext2fs *fs = fp->f_fs;
501199767f8SToomas Soome 				daddr_t	disk_block;
502199767f8SToomas Soome 				size_t buf_size;
503199767f8SToomas Soome 
504199767f8SToomas Soome 				if (! buf)
505199767f8SToomas Soome 					buf = malloc(fs->fs_bsize);
506199767f8SToomas Soome 				error = block_map(f, (daddr_t)0, &disk_block);
507199767f8SToomas Soome 				if (error)
508199767f8SToomas Soome 					goto out;
509*55fea89dSDan Cross 
510199767f8SToomas Soome 				twiddle(1);
511199767f8SToomas Soome 				error = (f->f_dev->dv_strategy)(f->f_devdata,
512199767f8SToomas Soome 				    F_READ, fsb_to_db(fs, disk_block),
513199767f8SToomas Soome 				    fs->fs_bsize, buf, &buf_size);
514199767f8SToomas Soome 				if (error)
515199767f8SToomas Soome 					goto out;
516199767f8SToomas Soome 
517199767f8SToomas Soome 				bcopy((char *)buf, namebuf, link_len);
518199767f8SToomas Soome 			}
519199767f8SToomas Soome 
520199767f8SToomas Soome 			/*
521199767f8SToomas Soome 			 * If relative pathname, restart at parent directory.
522199767f8SToomas Soome 			 * If absolute pathname, restart at root.
523199767f8SToomas Soome 			 */
524199767f8SToomas Soome 			cp = namebuf;
525199767f8SToomas Soome 			if (*cp != '/')
526199767f8SToomas Soome 				inumber = parent_inumber;
527199767f8SToomas Soome 			else
528199767f8SToomas Soome 				inumber = (ino_t)EXT2_ROOTINO;
529199767f8SToomas Soome 
530199767f8SToomas Soome 			if ((error = read_inode(inumber, f)) != 0)
531199767f8SToomas Soome 				goto out;
532199767f8SToomas Soome 		}
533199767f8SToomas Soome 	}
534199767f8SToomas Soome 
535199767f8SToomas Soome 	/*
536199767f8SToomas Soome 	 * Found terminal component.
537199767f8SToomas Soome 	 */
538199767f8SToomas Soome 	error = 0;
539199767f8SToomas Soome 	fp->f_seekp = 0;
540199767f8SToomas Soome out:
541199767f8SToomas Soome 	if (buf)
542199767f8SToomas Soome 		free(buf);
543199767f8SToomas Soome 	if (path)
544199767f8SToomas Soome 		free(path);
545199767f8SToomas Soome 	if (error) {
546199767f8SToomas Soome 		if (fp->f_buf)
547199767f8SToomas Soome 			free(fp->f_buf);
548199767f8SToomas Soome 		free(fp->f_fs);
549199767f8SToomas Soome 		free(fp);
550199767f8SToomas Soome 	}
551199767f8SToomas Soome 	return (error);
552199767f8SToomas Soome }
553199767f8SToomas Soome 
554199767f8SToomas Soome /*
555199767f8SToomas Soome  * Read a new inode into a file structure.
556199767f8SToomas Soome  */
557199767f8SToomas Soome static int
read_inode(ino_t inumber,struct open_file * f)558199767f8SToomas Soome read_inode(ino_t inumber, struct open_file *f)
559199767f8SToomas Soome {
560199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
561199767f8SToomas Soome 	struct ext2fs *fs = fp->f_fs;
562199767f8SToomas Soome 	struct ext2dinode *dp;
563199767f8SToomas Soome 	char *buf;
564199767f8SToomas Soome 	size_t rsize;
565199767f8SToomas Soome 	int level, error = 0;
566199767f8SToomas Soome 
567199767f8SToomas Soome 	/*
568199767f8SToomas Soome 	 * Read inode and save it.
569199767f8SToomas Soome 	 */
570199767f8SToomas Soome 	buf = malloc(fs->fs_bsize);
571199767f8SToomas Soome 	twiddle(1);
572199767f8SToomas Soome 	error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
573199767f8SToomas Soome 	    ino_to_db(fs, fp->f_bg, inumber), fs->fs_bsize, buf, &rsize);
574199767f8SToomas Soome 	if (error)
575199767f8SToomas Soome 		goto out;
576199767f8SToomas Soome 	if (rsize != fs->fs_bsize) {
577199767f8SToomas Soome 		error = EIO;
578199767f8SToomas Soome 		goto out;
579199767f8SToomas Soome 	}
580199767f8SToomas Soome 
581199767f8SToomas Soome 	dp = (struct ext2dinode *)buf;
582199767f8SToomas Soome 	fp->f_di = dp[ino_to_bo(fs, inumber)];
583199767f8SToomas Soome 
584199767f8SToomas Soome 	/* clear out old buffers */
585199767f8SToomas Soome 	for (level = 0; level < NIADDR; level++)
586199767f8SToomas Soome 		fp->f_blkno[level] = -1;
587199767f8SToomas Soome 	fp->f_buf_blkno = -1;
588199767f8SToomas Soome 	fp->f_seekp = 0;
589199767f8SToomas Soome 
590199767f8SToomas Soome out:
591199767f8SToomas Soome 	free(buf);
592*55fea89dSDan Cross 	return (error);
593199767f8SToomas Soome }
594199767f8SToomas Soome 
595199767f8SToomas Soome /*
596199767f8SToomas Soome  * Given an offset in a file, find the disk block number that
597199767f8SToomas Soome  * contains that block.
598199767f8SToomas Soome  */
599199767f8SToomas Soome static int
block_map(struct open_file * f,daddr_t file_block,daddr_t * disk_block_p)600199767f8SToomas Soome block_map(struct open_file *f, daddr_t file_block, daddr_t *disk_block_p)
601199767f8SToomas Soome {
602199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
603199767f8SToomas Soome 	struct ext2fs *fs = fp->f_fs;
604199767f8SToomas Soome 	daddr_t ind_block_num;
605199767f8SToomas Soome 	int32_t *ind_p;
606199767f8SToomas Soome 	int idx, level;
607199767f8SToomas Soome 	int error;
608199767f8SToomas Soome 
609199767f8SToomas Soome 	/*
610199767f8SToomas Soome 	 * Index structure of an inode:
611199767f8SToomas Soome 	 *
612199767f8SToomas Soome 	 * di_db[0..NDADDR-1]	hold block numbers for blocks
613199767f8SToomas Soome 	 *			0..NDADDR-1
614199767f8SToomas Soome 	 *
615199767f8SToomas Soome 	 * di_ib[0]		index block 0 is the single indirect block
616199767f8SToomas Soome 	 *			holds block numbers for blocks
617199767f8SToomas Soome 	 *			NDADDR .. NDADDR + NINDIR(fs)-1
618199767f8SToomas Soome 	 *
619199767f8SToomas Soome 	 * di_ib[1]		index block 1 is the double indirect block
620199767f8SToomas Soome 	 *			holds block numbers for INDEX blocks for blocks
621199767f8SToomas Soome 	 *			NDADDR + NINDIR(fs) ..
622199767f8SToomas Soome 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
623199767f8SToomas Soome 	 *
624199767f8SToomas Soome 	 * di_ib[2]		index block 2 is the triple indirect block
625199767f8SToomas Soome 	 *			holds block numbers for double-indirect
626199767f8SToomas Soome 	 *			blocks for blocks
627199767f8SToomas Soome 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
628199767f8SToomas Soome 	 *			NDADDR + NINDIR(fs) + NINDIR(fs)**2
629199767f8SToomas Soome 	 *				+ NINDIR(fs)**3 - 1
630199767f8SToomas Soome 	 */
631199767f8SToomas Soome 
632199767f8SToomas Soome 	if (file_block < NDADDR) {
633199767f8SToomas Soome 		/* Direct block. */
634199767f8SToomas Soome 		*disk_block_p = fp->f_di.di_db[file_block];
635199767f8SToomas Soome 		return (0);
636199767f8SToomas Soome 	}
637199767f8SToomas Soome 
638199767f8SToomas Soome 	file_block -= NDADDR;
639199767f8SToomas Soome 
640199767f8SToomas Soome 	/*
641199767f8SToomas Soome 	 * nindir[0] = NINDIR
642199767f8SToomas Soome 	 * nindir[1] = NINDIR**2
643199767f8SToomas Soome 	 * nindir[2] = NINDIR**3
644199767f8SToomas Soome 	 *	etc
645199767f8SToomas Soome 	 */
646199767f8SToomas Soome 	for (level = 0; level < NIADDR; level++) {
647199767f8SToomas Soome 		if (file_block < fp->f_nindir[level])
648199767f8SToomas Soome 			break;
649199767f8SToomas Soome 		file_block -= fp->f_nindir[level];
650199767f8SToomas Soome 	}
651199767f8SToomas Soome 	if (level == NIADDR) {
652199767f8SToomas Soome 		/* Block number too high */
653199767f8SToomas Soome 		return (EFBIG);
654199767f8SToomas Soome 	}
655199767f8SToomas Soome 
656199767f8SToomas Soome 	ind_block_num = fp->f_di.di_ib[level];
657199767f8SToomas Soome 
658199767f8SToomas Soome 	for (; level >= 0; level--) {
659199767f8SToomas Soome 		if (ind_block_num == 0) {
660199767f8SToomas Soome 			*disk_block_p = 0;	/* missing */
661199767f8SToomas Soome 			return (0);
662199767f8SToomas Soome 		}
663199767f8SToomas Soome 
664199767f8SToomas Soome 		if (fp->f_blkno[level] != ind_block_num) {
665199767f8SToomas Soome 			if (fp->f_blk[level] == (char *)0)
666199767f8SToomas Soome 				fp->f_blk[level] =
667199767f8SToomas Soome 					malloc(fs->fs_bsize);
668199767f8SToomas Soome 			twiddle(1);
669199767f8SToomas Soome 			error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
670199767f8SToomas Soome 			    fsb_to_db(fp->f_fs, ind_block_num), fs->fs_bsize,
671199767f8SToomas Soome 			    fp->f_blk[level], &fp->f_blksize[level]);
672199767f8SToomas Soome 			if (error)
673199767f8SToomas Soome 				return (error);
674199767f8SToomas Soome 			if (fp->f_blksize[level] != fs->fs_bsize)
675199767f8SToomas Soome 				return (EIO);
676199767f8SToomas Soome 			fp->f_blkno[level] = ind_block_num;
677199767f8SToomas Soome 		}
678199767f8SToomas Soome 
679199767f8SToomas Soome 		ind_p = (int32_t *)fp->f_blk[level];
680199767f8SToomas Soome 
681199767f8SToomas Soome 		if (level > 0) {
682199767f8SToomas Soome 			idx = file_block / fp->f_nindir[level - 1];
683199767f8SToomas Soome 			file_block %= fp->f_nindir[level - 1];
684199767f8SToomas Soome 		} else {
685199767f8SToomas Soome 			idx = file_block;
686199767f8SToomas Soome 		}
687199767f8SToomas Soome 		ind_block_num = ind_p[idx];
688199767f8SToomas Soome 	}
689199767f8SToomas Soome 
690199767f8SToomas Soome 	*disk_block_p = ind_block_num;
691199767f8SToomas Soome 
692199767f8SToomas Soome 	return (0);
693199767f8SToomas Soome }
694199767f8SToomas Soome 
695199767f8SToomas Soome /*
696199767f8SToomas Soome  * Read a portion of a file into an internal buffer.  Return
697199767f8SToomas Soome  * the location in the buffer and the amount in the buffer.
698199767f8SToomas Soome  */
699199767f8SToomas Soome static int
buf_read_file(struct open_file * f,char ** buf_p,size_t * size_p)700199767f8SToomas Soome buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
701199767f8SToomas Soome {
702199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
703199767f8SToomas Soome 	struct ext2fs *fs = fp->f_fs;
704199767f8SToomas Soome 	long off;
705199767f8SToomas Soome 	daddr_t file_block;
706199767f8SToomas Soome 	daddr_t	disk_block;
707199767f8SToomas Soome 	size_t block_size;
708199767f8SToomas Soome 	int error = 0;
709199767f8SToomas Soome 
710199767f8SToomas Soome 	off = blkoff(fs, fp->f_seekp);
711199767f8SToomas Soome 	file_block = lblkno(fs, fp->f_seekp);
712199767f8SToomas Soome 	block_size = dblksize(fs, &fp->f_di, file_block);
713199767f8SToomas Soome 
714199767f8SToomas Soome 	if (file_block != fp->f_buf_blkno) {
715199767f8SToomas Soome 		error = block_map(f, file_block, &disk_block);
716199767f8SToomas Soome 		if (error)
717199767f8SToomas Soome 			goto done;
718199767f8SToomas Soome 
719199767f8SToomas Soome 		if (fp->f_buf == (char *)0)
720199767f8SToomas Soome 			fp->f_buf = malloc(fs->fs_bsize);
721199767f8SToomas Soome 
722199767f8SToomas Soome 		if (disk_block == 0) {
723199767f8SToomas Soome 			bzero(fp->f_buf, block_size);
724199767f8SToomas Soome 			fp->f_buf_size = block_size;
725199767f8SToomas Soome 		} else {
726199767f8SToomas Soome 			twiddle(4);
727199767f8SToomas Soome 			error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
728199767f8SToomas Soome 			    fsb_to_db(fs, disk_block), block_size,
729199767f8SToomas Soome 			    fp->f_buf, &fp->f_buf_size);
730199767f8SToomas Soome 			if (error)
731199767f8SToomas Soome 				goto done;
732199767f8SToomas Soome 		}
733199767f8SToomas Soome 		fp->f_buf_blkno = file_block;
734199767f8SToomas Soome 	}
735199767f8SToomas Soome 
736199767f8SToomas Soome 	/*
737199767f8SToomas Soome 	 * Return address of byte in buffer corresponding to
738199767f8SToomas Soome 	 * offset, and size of remainder of buffer after that
739199767f8SToomas Soome 	 * byte.
740199767f8SToomas Soome 	 */
741199767f8SToomas Soome 	*buf_p = fp->f_buf + off;
742199767f8SToomas Soome 	*size_p = block_size - off;
743199767f8SToomas Soome 
744199767f8SToomas Soome 	/*
745199767f8SToomas Soome 	 * But truncate buffer at end of file.
746199767f8SToomas Soome 	 */
747199767f8SToomas Soome 	if (*size_p > fp->f_di.di_size - fp->f_seekp)
748199767f8SToomas Soome 		*size_p = fp->f_di.di_size - fp->f_seekp;
749199767f8SToomas Soome done:
750199767f8SToomas Soome 	return (error);
751199767f8SToomas Soome }
752199767f8SToomas Soome 
753199767f8SToomas Soome /*
754199767f8SToomas Soome  * Search a directory for a name and return its
755199767f8SToomas Soome  * i_number.
756199767f8SToomas Soome  */
757199767f8SToomas Soome static int
search_directory(char * name,struct open_file * f,ino_t * inumber_p)758199767f8SToomas Soome search_directory(char *name, struct open_file *f, ino_t *inumber_p)
759199767f8SToomas Soome {
760199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
761199767f8SToomas Soome 	struct ext2dirent *dp, *edp;
762199767f8SToomas Soome 	char *buf;
763199767f8SToomas Soome 	size_t buf_size;
764199767f8SToomas Soome 	int namlen, length;
765199767f8SToomas Soome 	int error;
766199767f8SToomas Soome 
767199767f8SToomas Soome 	length = strlen(name);
768199767f8SToomas Soome 	fp->f_seekp = 0;
769199767f8SToomas Soome 	while (fp->f_seekp < fp->f_di.di_size) {
770199767f8SToomas Soome 		error = buf_read_file(f, &buf, &buf_size);
771199767f8SToomas Soome 		if (error)
772199767f8SToomas Soome 			return (error);
773199767f8SToomas Soome 		dp = (struct ext2dirent *)buf;
774199767f8SToomas Soome 		edp = (struct ext2dirent *)(buf + buf_size);
775199767f8SToomas Soome 		while (dp < edp) {
776199767f8SToomas Soome 			if (dp->d_ino == (ino_t)0)
777199767f8SToomas Soome 				goto next;
778199767f8SToomas Soome 			namlen = dp->d_namlen;
779199767f8SToomas Soome 			if (namlen == length &&
780199767f8SToomas Soome 			    strncmp(name, dp->d_name, length) == 0) {
781199767f8SToomas Soome 				/* found entry */
782199767f8SToomas Soome 				*inumber_p = dp->d_ino;
783199767f8SToomas Soome 				return (0);
784199767f8SToomas Soome 			}
785199767f8SToomas Soome 		next:
786199767f8SToomas Soome 			dp = (struct ext2dirent *)((char *)dp + dp->d_reclen);
787199767f8SToomas Soome 		}
788199767f8SToomas Soome 		fp->f_seekp += buf_size;
789199767f8SToomas Soome 	}
790199767f8SToomas Soome 	return (ENOENT);
791199767f8SToomas Soome }
792199767f8SToomas Soome 
793199767f8SToomas Soome static int
ext2fs_close(struct open_file * f)794199767f8SToomas Soome ext2fs_close(struct open_file *f)
795199767f8SToomas Soome {
796199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
797199767f8SToomas Soome 	int level;
798199767f8SToomas Soome 
799199767f8SToomas Soome 	f->f_fsdata = (void *)0;
800199767f8SToomas Soome 	if (fp == (struct file *)0)
801199767f8SToomas Soome 		return (0);
802199767f8SToomas Soome 
803199767f8SToomas Soome 	for (level = 0; level < NIADDR; level++) {
804199767f8SToomas Soome 		if (fp->f_blk[level])
805199767f8SToomas Soome 			free(fp->f_blk[level]);
806199767f8SToomas Soome 	}
807199767f8SToomas Soome 	if (fp->f_buf)
808199767f8SToomas Soome 		free(fp->f_buf);
809199767f8SToomas Soome 	if (fp->f_bg)
810199767f8SToomas Soome 		free(fp->f_bg);
811199767f8SToomas Soome 	free(fp->f_fs);
812199767f8SToomas Soome 	free(fp);
813199767f8SToomas Soome 	return (0);
814199767f8SToomas Soome }
815199767f8SToomas Soome 
816199767f8SToomas Soome static int
ext2fs_read(struct open_file * f,void * addr,size_t size,size_t * resid)817199767f8SToomas Soome ext2fs_read(struct open_file *f, void *addr, size_t size, size_t *resid)
818199767f8SToomas Soome {
819199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
820199767f8SToomas Soome 	size_t csize, buf_size;
821199767f8SToomas Soome 	char *buf;
822199767f8SToomas Soome 	int error = 0;
823199767f8SToomas Soome 
824199767f8SToomas Soome 	while (size != 0) {
825199767f8SToomas Soome 		if (fp->f_seekp >= fp->f_di.di_size)
826199767f8SToomas Soome 			break;
827199767f8SToomas Soome 
828199767f8SToomas Soome 		error = buf_read_file(f, &buf, &buf_size);
829199767f8SToomas Soome 		if (error)
830199767f8SToomas Soome 			break;
831199767f8SToomas Soome 
832199767f8SToomas Soome 		csize = size;
833199767f8SToomas Soome 		if (csize > buf_size)
834199767f8SToomas Soome 			csize = buf_size;
835199767f8SToomas Soome 
836199767f8SToomas Soome 		bcopy(buf, addr, csize);
837199767f8SToomas Soome 
838199767f8SToomas Soome 		fp->f_seekp += csize;
839199767f8SToomas Soome 		addr = (char *)addr + csize;
840199767f8SToomas Soome 		size -= csize;
841199767f8SToomas Soome 	}
842199767f8SToomas Soome 	if (resid)
843199767f8SToomas Soome 		*resid = size;
844199767f8SToomas Soome 	return (error);
845199767f8SToomas Soome }
846199767f8SToomas Soome 
847199767f8SToomas Soome static off_t
ext2fs_seek(struct open_file * f,off_t offset,int where)848199767f8SToomas Soome ext2fs_seek(struct open_file *f, off_t offset, int where)
849199767f8SToomas Soome {
850199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
851199767f8SToomas Soome 
852199767f8SToomas Soome 	switch (where) {
853199767f8SToomas Soome 	case SEEK_SET:
854199767f8SToomas Soome 		fp->f_seekp = offset;
855199767f8SToomas Soome 		break;
856199767f8SToomas Soome 	case SEEK_CUR:
857199767f8SToomas Soome 		fp->f_seekp += offset;
858199767f8SToomas Soome 		break;
859199767f8SToomas Soome 	case SEEK_END:
860199767f8SToomas Soome 		fp->f_seekp = fp->f_di.di_size - offset;
861199767f8SToomas Soome 		break;
862199767f8SToomas Soome 	default:
863199767f8SToomas Soome 		errno = EINVAL;
864199767f8SToomas Soome 		return (-1);
865199767f8SToomas Soome 	}
866199767f8SToomas Soome 	return (fp->f_seekp);
867199767f8SToomas Soome }
868199767f8SToomas Soome 
869199767f8SToomas Soome static int
ext2fs_stat(struct open_file * f,struct stat * sb)870199767f8SToomas Soome ext2fs_stat(struct open_file *f, struct stat *sb)
871199767f8SToomas Soome {
872199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
873199767f8SToomas Soome 
874199767f8SToomas Soome 	/* only important stuff */
875199767f8SToomas Soome 	sb->st_mode = fp->f_di.di_mode;
876199767f8SToomas Soome 	sb->st_uid = fp->f_di.di_uid;
877199767f8SToomas Soome 	sb->st_gid = fp->f_di.di_gid;
878199767f8SToomas Soome 	sb->st_size = fp->f_di.di_size;
879199767f8SToomas Soome 	return (0);
880199767f8SToomas Soome }
881199767f8SToomas Soome 
882199767f8SToomas Soome static int
ext2fs_readdir(struct open_file * f,struct dirent * d)883199767f8SToomas Soome ext2fs_readdir(struct open_file *f, struct dirent *d)
884199767f8SToomas Soome {
885199767f8SToomas Soome 	struct file *fp = (struct file *)f->f_fsdata;
886199767f8SToomas Soome 	struct ext2dirent *ed;
887199767f8SToomas Soome 	char *buf;
888199767f8SToomas Soome 	size_t buf_size;
889199767f8SToomas Soome 	int error;
890199767f8SToomas Soome 
891199767f8SToomas Soome 	/*
892199767f8SToomas Soome 	 * assume that a directory entry will not be split across blocks
893199767f8SToomas Soome 	 */
894199767f8SToomas Soome again:
895199767f8SToomas Soome 	if (fp->f_seekp >= fp->f_di.di_size)
896199767f8SToomas Soome 		return (ENOENT);
897199767f8SToomas Soome 	error = buf_read_file(f, &buf, &buf_size);
898199767f8SToomas Soome 	if (error)
899199767f8SToomas Soome 		return (error);
900199767f8SToomas Soome 	ed = (struct ext2dirent *)buf;
901199767f8SToomas Soome 	fp->f_seekp += ed->d_reclen;
902199767f8SToomas Soome 	if (ed->d_ino == (ino_t)0)
903199767f8SToomas Soome 		goto again;
904199767f8SToomas Soome 	d->d_type = EXTFTODT(ed->d_type);
905199767f8SToomas Soome 	strncpy(d->d_name, ed->d_name, ed->d_namlen);
906199767f8SToomas Soome 	d->d_name[ed->d_namlen] = '\0';
907199767f8SToomas Soome 	return (0);
908199767f8SToomas Soome }
909