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