1 /*-
2 * Copyright (c) 1999,2000 Jonathan Lemon <jlemon@freebsd.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: src/lib/libstand/ext2fs.c,v 1.1.2.2 2001/03/05 06:26:07 kris Exp $
27 */
28 /*-
29 * Copyright (c) 1993
30 * The Regents of the University of California. All rights reserved.
31 *
32 * This code is derived from software contributed to Berkeley by
33 * The Mach Operating System project at Carnegie-Mellon University.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. Neither the name of the University nor the names of its contributors
44 * may be used to endorse or promote products derived from this software
45 * without specific prior written permission.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57 * SUCH DAMAGE.
58 *
59 *
60 * Copyright (c) 1990, 1991 Carnegie Mellon University
61 * All Rights Reserved.
62 *
63 * Author: David Golub
64 *
65 * Permission to use, copy, modify and distribute this software and its
66 * documentation is hereby granted, provided that both the copyright
67 * notice and this permission notice appear in all copies of the
68 * software, derivative works or modified versions, and any portions
69 * thereof, and that both notices appear in supporting documentation.
70 *
71 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
72 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
73 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
74 *
75 * Carnegie Mellon requests users of this software to return to
76 *
77 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
78 * School of Computer Science
79 * Carnegie Mellon University
80 * Pittsburgh PA 15213-3890
81 *
82 * any improvements or extensions that they make and grant Carnegie the
83 * rights to redistribute these changes.
84 */
85
86 #include <sys/param.h>
87 #include <sys/time.h>
88 #include "stand.h"
89 #include "string.h"
90
91 static int ext2fs_open(const char *path, struct open_file *f);
92 static int ext2fs_close(struct open_file *f);
93 static int ext2fs_read(struct open_file *f, void *buf,
94 size_t size, size_t *resid);
95 static off_t ext2fs_seek(struct open_file *f, off_t offset, int where);
96 static int ext2fs_stat(struct open_file *f, struct stat *sb);
97 static int ext2fs_readdir(struct open_file *f, struct dirent *d);
98
99 static int dtmap[] = { DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR,
100 DT_BLK, DT_FIFO, DT_SOCK, DT_LNK };
101 #define EXTFTODT(x) (x) > NELEM(dtmap) ? DT_UNKNOWN : dtmap[(x)]
102
103 struct fs_ops ext2fs_fsops = {
104 "ext2fs",
105 ext2fs_open,
106 ext2fs_close,
107 ext2fs_read,
108 null_write,
109 ext2fs_seek,
110 ext2fs_stat,
111 ext2fs_readdir
112 };
113
114 #define EXT2_SBSIZE 1024
115 #define EXT2_SBLOCK (1024 / DEV_BSIZE) /* block offset of superblock */
116 #define EXT2_MAGIC 0xef53
117 #define EXT2_ROOTINO 2
118
119 #define EXT2_REV0 0 /* original revision of ext2 */
120 #define EXT2_R0_ISIZE 128 /* inode size */
121 #define EXT2_R0_FIRSTINO 11 /* first inode */
122
123 #define EXT2_MINBSHIFT 10 /* mininum block shift */
124 #define EXT2_MINFSHIFT 10 /* mininum frag shift */
125
126 #define NDADDR 12 /* # of direct blocks */
127 #define NIADDR 3 /* # of indirect blocks */
128
129 /*
130 * file system block to disk address
131 */
132 #define fsb_to_db(fs, blk) ((blk) << (fs)->fs_fsbtodb)
133
134 /*
135 * inode to block group offset
136 * inode to block group
137 * inode to disk address
138 * inode to block offset
139 */
140 #define ino_to_bgo(fs, ino) (((ino) - 1) % (fs)->fs_ipg)
141 #define ino_to_bg(fs, ino) (((ino) - 1) / (fs)->fs_ipg)
142 #define ino_to_db(fs, bg, ino) \
143 fsb_to_db(fs, ((bg)[ino_to_bg(fs, ino)].bg_inotbl + \
144 ino_to_bgo(fs, ino) / (fs)->fs_ipb))
145 #define ino_to_bo(fs, ino) (ino_to_bgo(fs, ino) % (fs)->fs_ipb)
146
147 #define nindir(fs) \
148 ((fs)->fs_bsize / sizeof(u_int32_t))
149 #define lblkno(fs, loc) /* loc / bsize */ \
150 ((loc) >> (fs)->fs_bshift)
151 #define smalllblktosize(fs, blk) /* blk * bsize */ \
152 ((blk) << (fs)->fs_bshift)
153 #define blkoff(fs, loc) /* loc % bsize */ \
154 ((loc) & (fs)->fs_bmask)
155 #define fragroundup(fs, size) /* roundup(size, fsize) */ \
156 (((size) + (fs)->fs_fmask) & ~(fs)->fs_fmask)
157 #define dblksize(fs, dip, lbn) \
158 (((lbn) >= NDADDR || (dip)->di_size >= smalllblktosize(fs, (lbn) + 1)) \
159 ? (fs)->fs_bsize \
160 : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
161
162 /*
163 * superblock describing ext2fs
164 */
165 struct ext2fs_disk {
166 u_int32_t fd_inodes; /* # of inodes */
167 u_int32_t fd_blocks; /* # of blocks */
168 u_int32_t fd_resblk; /* # of reserved blocks */
169 u_int32_t fd_freeblk; /* # of free blocks */
170 u_int32_t fd_freeino; /* # of free inodes */
171 u_int32_t fd_firstblk; /* first data block */
172 u_int32_t fd_bsize; /* block size */
173 u_int32_t fd_fsize; /* frag size */
174 u_int32_t fd_bpg; /* blocks per group */
175 u_int32_t fd_fpg; /* frags per group */
176 u_int32_t fd_ipg; /* inodes per group */
177 u_int32_t fd_mtime; /* mount time */
178 u_int32_t fd_wtime; /* write time */
179 u_int16_t fd_mount; /* # of mounts */
180 int16_t fd_maxmount; /* max # of mounts */
181 u_int16_t fd_magic; /* magic number */
182 u_int16_t fd_state; /* state */
183 u_int16_t fd_eflag; /* error flags */
184 u_int16_t fd_mnrrev; /* minor revision */
185 u_int32_t fd_lastchk; /* last check */
186 u_int32_t fd_chkintvl; /* maximum check interval */
187 u_int32_t fd_os; /* os */
188 u_int32_t fd_revision; /* revision */
189 u_int16_t fd_uid; /* uid for reserved blocks */
190 u_int16_t fd_gid; /* gid for reserved blocks */
191
192 u_int32_t fd_firstino; /* first non-reserved inode */
193 u_int16_t fd_isize; /* inode size */
194 u_int16_t fd_nblkgrp; /* block group # of superblock */
195 u_int32_t fd_fcompat; /* compatible features */
196 u_int32_t fd_fincompat; /* incompatible features */
197 u_int32_t fd_frocompat; /* read-only compatibilties */
198 u_int8_t fd_uuid[16]; /* volume uuid */
199 char fd_volname[16]; /* volume name */
200 char fd_fsmnt[64]; /* name last mounted on */
201 u_int32_t fd_bitmap; /* compression bitmap */
202
203 u_int8_t fd_nblkpa; /* # of blocks to preallocate */
204 u_int8_t fd_ndblkpa; /* # of dir blocks to preallocate */
205 };
206
207 struct ext2fs_core {
208 int fc_bsize; /* block size */
209 int fc_bshift; /* block shift amount */
210 int fc_bmask; /* block mask */
211 int fc_fsize; /* frag size */
212 int fc_fshift; /* frag shift amount */
213 int fc_fmask; /* frag mask */
214 int fc_isize; /* inode size */
215 int fc_imask; /* inode mask */
216 int fc_firstino; /* first non-reserved inode */
217 int fc_ipb; /* inodes per block */
218 int fc_fsbtodb; /* fsb to ds shift */
219 };
220
221 struct ext2fs {
222 struct ext2fs_disk fs_fd;
223 char fs_pad[EXT2_SBSIZE - sizeof(struct ext2fs_disk)];
224 struct ext2fs_core fs_fc;
225
226 #define fs_magic fs_fd.fd_magic
227 #define fs_revision fs_fd.fd_revision
228 #define fs_blocks fs_fd.fd_blocks
229 #define fs_firstblk fs_fd.fd_firstblk
230 #define fs_bpg fs_fd.fd_bpg
231 #define fs_ipg fs_fd.fd_ipg
232
233 #define fs_bsize fs_fc.fc_bsize
234 #define fs_bshift fs_fc.fc_bshift
235 #define fs_bmask fs_fc.fc_bmask
236 #define fs_fsize fs_fc.fc_fsize
237 #define fs_fshift fs_fc.fc_fshift
238 #define fs_fmask fs_fc.fc_fmask
239 #define fs_isize fs_fc.fc_isize
240 #define fs_imask fs_fc.fc_imask
241 #define fs_firstino fs_fc.fc_firstino
242 #define fs_ipb fs_fc.fc_ipb
243 #define fs_fsbtodb fs_fc.fc_fsbtodb
244 };
245
246 struct ext2blkgrp {
247 u_int32_t bg_blkmap; /* block bitmap */
248 u_int32_t bg_inomap; /* inode bitmap */
249 u_int32_t bg_inotbl; /* inode table */
250 u_int16_t bg_nfblk; /* # of free blocks */
251 u_int16_t bg_nfino; /* # of free inodes */
252 u_int16_t bg_ndirs; /* # of dirs */
253 char bg_pad[14];
254 };
255
256 struct ext2dinode {
257 u_int16_t di_mode; /* mode */
258 u_int16_t di_uid; /* uid */
259 u_int32_t di_size; /* byte size */
260 u_int32_t di_atime; /* access time */
261 u_int32_t di_ctime; /* creation time */
262 u_int32_t di_mtime; /* modification time */
263 u_int32_t di_dtime; /* deletion time */
264 u_int16_t di_gid; /* gid */
265 u_int16_t di_nlink; /* link count */
266 u_int32_t di_nblk; /* block count */
267 u_int32_t di_flags; /* file flags */
268
269 u_int32_t di_osdep1; /* os dependent stuff */
270
271 u_int32_t di_db[NDADDR]; /* direct blocks */
272 u_int32_t di_ib[NIADDR]; /* indirect blocks */
273 u_int32_t di_version; /* version */
274 u_int32_t di_facl; /* file acl */
275 u_int32_t di_dacl; /* dir acl */
276 u_int32_t di_faddr; /* fragment addr */
277
278 u_int8_t di_frag; /* fragment number */
279 u_int8_t di_fsize; /* fragment size */
280
281 char di_pad[10];
282
283 #define di_shortlink di_db
284 };
285
286 #define EXT2_MAXNAMLEN 255
287
288 struct ext2dirent {
289 u_int32_t d_ino; /* inode */
290 u_int16_t d_reclen; /* directory entry length */
291 u_int8_t d_namlen; /* name length */
292 u_int8_t d_type; /* file type */
293 char d_name[EXT2_MAXNAMLEN];
294 };
295
296 struct file {
297 off_t f_seekp; /* seek pointer */
298 struct ext2fs *f_fs; /* pointer to super-block */
299 struct ext2blkgrp *f_bg; /* pointer to blkgrp map */
300 struct ext2dinode f_di; /* copy of on-disk inode */
301 int f_nindir[NIADDR]; /* number of blocks mapped by
302 indirect block at level i */
303 char *f_blk[NIADDR]; /* buffer for indirect block
304 at level i */
305 size_t f_blksize[NIADDR]; /* size of buffer */
306 daddr_t f_blkno[NIADDR]; /* disk address of block in
307 buffer */
308 char *f_buf; /* buffer for data block */
309 size_t f_buf_size; /* size of data block */
310 daddr_t f_buf_blkno; /* block number of data block */
311 };
312
313 /* forward decls */
314 static int read_inode(ino_t inumber, struct open_file *f);
315 static int block_map(struct open_file *f, daddr_t file_block,
316 daddr_t *disk_block_p);
317 static int buf_read_file(struct open_file *f, char **buf_p,
318 size_t *size_p);
319 static int search_directory(char *name, struct open_file *f,
320 ino_t *inumber_p);
321
322 /*
323 * Open a file.
324 */
325 static int
ext2fs_open(const char * upath,struct open_file * f)326 ext2fs_open(const char *upath, struct open_file *f)
327 {
328 struct file *fp;
329 struct ext2fs *fs;
330 size_t buf_size;
331 ino_t inumber, parent_inumber;
332 int i, len, groups, bg_per_blk, blkgrps, mult;
333 int nlinks = 0;
334 int error = 0;
335 char *cp, *ncp, *path = NULL, *buf = NULL;
336 char namebuf[MAXPATHLEN+1];
337 char c;
338
339 /* allocate file system specific data structure */
340 fp = malloc(sizeof(struct file));
341 if (fp == NULL)
342 return (ENOMEM);
343 bzero(fp, sizeof(struct file));
344 f->f_fsdata = (void *)fp;
345
346 /* allocate space and read super block */
347 fs = (struct ext2fs *)malloc(sizeof(*fs));
348 fp->f_fs = fs;
349 twiddle();
350 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
351 EXT2_SBLOCK, EXT2_SBSIZE, (char *)fs, &buf_size);
352 if (error)
353 goto out;
354
355 if (buf_size != EXT2_SBSIZE || fs->fs_magic != EXT2_MAGIC) {
356 error = EINVAL;
357 goto out;
358 }
359
360 /*
361 * compute in-core values for the superblock
362 */
363 fs->fs_bshift = EXT2_MINBSHIFT + fs->fs_fd.fd_bsize;
364 fs->fs_bsize = 1 << fs->fs_bshift;
365 fs->fs_bmask = fs->fs_bsize - 1;
366
367 fs->fs_fshift = EXT2_MINFSHIFT + fs->fs_fd.fd_fsize;
368 fs->fs_fsize = 1 << fs->fs_fshift;
369 fs->fs_fmask = fs->fs_fsize - 1;
370
371 if (fs->fs_revision == EXT2_REV0) {
372 fs->fs_isize = EXT2_R0_ISIZE;
373 fs->fs_firstino = EXT2_R0_FIRSTINO;
374 } else {
375 fs->fs_isize = fs->fs_fd.fd_isize;
376 fs->fs_firstino = fs->fs_fd.fd_firstino;
377 }
378 fs->fs_imask = fs->fs_isize - 1;
379 fs->fs_ipb = fs->fs_bsize / fs->fs_isize;
380 fs->fs_fsbtodb = (fs->fs_bsize / DEV_BSIZE) - 1;
381
382 /*
383 * we have to load in the "group descriptors" here
384 */
385 groups = howmany(fs->fs_blocks - fs->fs_firstblk, fs->fs_bpg);
386 bg_per_blk = fs->fs_bsize / sizeof(struct ext2blkgrp);
387 blkgrps = howmany(groups, bg_per_blk);
388 len = blkgrps * fs->fs_bsize;
389
390 fp->f_bg = malloc(len);
391 twiddle();
392 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
393 EXT2_SBLOCK + EXT2_SBSIZE / DEV_BSIZE, len,
394 (char *)fp->f_bg, &buf_size);
395 if (error)
396 goto out;
397
398 /*
399 * XXX
400 * validation of values? (blocksize, descriptors, etc?)
401 */
402
403 /*
404 * Calculate indirect block levels.
405 */
406 mult = 1;
407 for (i = 0; i < NIADDR; i++) {
408 mult *= nindir(fs);
409 fp->f_nindir[i] = mult;
410 }
411
412 inumber = EXT2_ROOTINO;
413 if ((error = read_inode(inumber, f)) != 0)
414 goto out;
415
416 path = strdup(upath);
417 if (path == NULL) {
418 error = ENOMEM;
419 goto out;
420 }
421 cp = path;
422 while (*cp) {
423 /*
424 * Remove extra separators
425 */
426 while (*cp == '/')
427 cp++;
428 if (*cp == '\0')
429 break;
430
431 /*
432 * Check that current node is a directory.
433 */
434 if (! S_ISDIR(fp->f_di.di_mode)) {
435 error = ENOTDIR;
436 goto out;
437 }
438
439 /*
440 * Get next component of path name.
441 */
442 len = 0;
443
444 ncp = cp;
445 while ((c = *cp) != '\0' && c != '/') {
446 if (++len > EXT2_MAXNAMLEN) {
447 error = ENOENT;
448 goto out;
449 }
450 cp++;
451 }
452 *cp = '\0';
453
454 /*
455 * Look up component in current directory.
456 * Save directory inumber in case we find a
457 * symbolic link.
458 */
459 parent_inumber = inumber;
460 error = search_directory(ncp, f, &inumber);
461 *cp = c;
462 if (error)
463 goto out;
464
465 /*
466 * Open next component.
467 */
468 if ((error = read_inode(inumber, f)) != 0)
469 goto out;
470
471 /*
472 * Check for symbolic link.
473 */
474 if (S_ISLNK(fp->f_di.di_mode)) {
475 int link_len = fp->f_di.di_size;
476 int len;
477
478 len = strlen(cp);
479 if (link_len + len > MAXPATHLEN ||
480 ++nlinks > MAXSYMLINKS) {
481 error = ENOENT;
482 goto out;
483 }
484
485 bcopy(cp, &namebuf[link_len], len + 1);
486 if (fp->f_di.di_nblk == 0) {
487 bcopy(fp->f_di.di_shortlink,
488 namebuf, link_len);
489 } else {
490 /*
491 * Read file for symbolic link
492 */
493 struct ext2fs *fs = fp->f_fs;
494 daddr_t disk_block;
495 size_t buf_size;
496
497 if (! buf)
498 buf = malloc(fs->fs_bsize);
499 error = block_map(f, (daddr_t)0, &disk_block);
500 if (error)
501 goto out;
502
503 twiddle();
504 error = (f->f_dev->dv_strategy)(f->f_devdata,
505 F_READ, fsb_to_db(fs, disk_block),
506 fs->fs_bsize, buf, &buf_size);
507 if (error)
508 goto out;
509
510 bcopy((char *)buf, namebuf, link_len);
511 }
512
513 /*
514 * If relative pathname, restart at parent directory.
515 * If absolute pathname, restart at root.
516 */
517 cp = namebuf;
518 if (*cp != '/')
519 inumber = parent_inumber;
520 else
521 inumber = (ino_t)EXT2_ROOTINO;
522
523 if ((error = read_inode(inumber, f)) != 0)
524 goto out;
525 }
526 }
527
528 /*
529 * Found terminal component.
530 */
531 error = 0;
532 out:
533 if (buf)
534 free(buf);
535 if (path)
536 free(path);
537 if (error) {
538 f->f_fsdata = NULL;
539 if (fp->f_buf)
540 free(fp->f_buf);
541 free(fp->f_fs);
542 free(fp);
543 }
544 return (error);
545 }
546
547 /*
548 * Read a new inode into a file structure.
549 */
550 static int
read_inode(ino_t inumber,struct open_file * f)551 read_inode(ino_t inumber, struct open_file *f)
552 {
553 struct file *fp = (struct file *)f->f_fsdata;
554 struct ext2fs *fs = fp->f_fs;
555 struct ext2dinode *dp;
556 char *buf;
557 size_t rsize;
558 int level, error = 0;
559
560 /*
561 * Read inode and save it.
562 */
563 buf = malloc(fs->fs_bsize);
564 twiddle();
565 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
566 ino_to_db(fs, fp->f_bg, inumber), fs->fs_bsize, buf, &rsize);
567 if (error)
568 goto out;
569 if (rsize != fs->fs_bsize) {
570 error = EIO;
571 goto out;
572 }
573
574 dp = (struct ext2dinode *)buf;
575 fp->f_di = dp[ino_to_bo(fs, inumber)];
576
577 /* clear out old buffers */
578 for (level = 0; level < NIADDR; level++)
579 fp->f_blkno[level] = -1;
580 fp->f_buf_blkno = -1;
581
582 out:
583 free(buf);
584 return (error);
585 }
586
587 /*
588 * Given an offset in a file, find the disk block number that
589 * contains that block.
590 */
591 static int
block_map(struct open_file * f,daddr_t file_block,daddr_t * disk_block_p)592 block_map(struct open_file *f, daddr_t file_block, daddr_t *disk_block_p)
593 {
594 struct file *fp = (struct file *)f->f_fsdata;
595 struct ext2fs *fs = fp->f_fs;
596 daddr_t ind_block_num;
597 daddr_t *ind_p;
598 int idx, level;
599 int error;
600
601 /*
602 * Index structure of an inode:
603 *
604 * di_db[0..NDADDR-1] hold block numbers for blocks
605 * 0..NDADDR-1
606 *
607 * di_ib[0] index block 0 is the single indirect block
608 * holds block numbers for blocks
609 * NDADDR .. NDADDR + NINDIR(fs)-1
610 *
611 * di_ib[1] index block 1 is the double indirect block
612 * holds block numbers for INDEX blocks for blocks
613 * NDADDR + NINDIR(fs) ..
614 * NDADDR + NINDIR(fs) + NINDIR(fs)**2 - 1
615 *
616 * di_ib[2] index block 2 is the triple indirect block
617 * holds block numbers for double-indirect
618 * blocks for blocks
619 * NDADDR + NINDIR(fs) + NINDIR(fs)**2 ..
620 * NDADDR + NINDIR(fs) + NINDIR(fs)**2
621 * + NINDIR(fs)**3 - 1
622 */
623
624 if (file_block < NDADDR) {
625 /* Direct block. */
626 *disk_block_p = fp->f_di.di_db[file_block];
627 return (0);
628 }
629
630 file_block -= NDADDR;
631
632 /*
633 * nindir[0] = NINDIR
634 * nindir[1] = NINDIR**2
635 * nindir[2] = NINDIR**3
636 * etc
637 */
638 for (level = 0; level < NIADDR; level++) {
639 if (file_block < fp->f_nindir[level])
640 break;
641 file_block -= fp->f_nindir[level];
642 }
643 if (level == NIADDR) {
644 /* Block number too high */
645 return (EFBIG);
646 }
647
648 ind_block_num = fp->f_di.di_ib[level];
649
650 for (; level >= 0; level--) {
651 if (ind_block_num == 0) {
652 *disk_block_p = 0; /* missing */
653 return (0);
654 }
655
656 if (fp->f_blkno[level] != ind_block_num) {
657 if (fp->f_blk[level] == NULL)
658 fp->f_blk[level] =
659 malloc(fs->fs_bsize);
660 twiddle();
661 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
662 fsb_to_db(fp->f_fs, ind_block_num), fs->fs_bsize,
663 fp->f_blk[level], &fp->f_blksize[level]);
664 if (error)
665 return (error);
666 if (fp->f_blksize[level] != fs->fs_bsize)
667 return (EIO);
668 fp->f_blkno[level] = ind_block_num;
669 }
670
671 ind_p = (daddr_t *)fp->f_blk[level];
672
673 if (level > 0) {
674 idx = file_block / fp->f_nindir[level - 1];
675 file_block %= fp->f_nindir[level - 1];
676 } else {
677 idx = file_block;
678 }
679 ind_block_num = ind_p[idx];
680 }
681
682 *disk_block_p = ind_block_num;
683
684 return (0);
685 }
686
687 /*
688 * Read a portion of a file into an internal buffer. Return
689 * the location in the buffer and the amount in the buffer.
690 */
691 static int
buf_read_file(struct open_file * f,char ** buf_p,size_t * size_p)692 buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
693 {
694 struct file *fp = (struct file *)f->f_fsdata;
695 struct ext2fs *fs = fp->f_fs;
696 long off;
697 daddr_t file_block;
698 daddr_t disk_block;
699 size_t block_size;
700 int error = 0;
701
702 off = blkoff(fs, fp->f_seekp);
703 file_block = lblkno(fs, fp->f_seekp);
704 block_size = dblksize(fs, &fp->f_di, file_block);
705
706 if (file_block != fp->f_buf_blkno) {
707 error = block_map(f, file_block, &disk_block);
708 if (error)
709 goto done;
710
711 if (fp->f_buf == NULL)
712 fp->f_buf = malloc(fs->fs_bsize);
713
714 if (disk_block == 0) {
715 bzero(fp->f_buf, block_size);
716 fp->f_buf_size = block_size;
717 } else {
718 twiddle();
719 error = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
720 fsb_to_db(fs, disk_block), block_size,
721 fp->f_buf, &fp->f_buf_size);
722 if (error)
723 goto done;
724 }
725 fp->f_buf_blkno = file_block;
726 }
727
728 /*
729 * Return address of byte in buffer corresponding to
730 * offset, and size of remainder of buffer after that
731 * byte.
732 */
733 *buf_p = fp->f_buf + off;
734 *size_p = block_size - off;
735
736 /*
737 * But truncate buffer at end of file.
738 */
739 if (*size_p > fp->f_di.di_size - fp->f_seekp)
740 *size_p = fp->f_di.di_size - fp->f_seekp;
741 done:
742 return (error);
743 }
744
745 /*
746 * Search a directory for a name and return its
747 * i_number.
748 */
749 static int
search_directory(char * name,struct open_file * f,ino_t * inumber_p)750 search_directory(char *name, struct open_file *f, ino_t *inumber_p)
751 {
752 struct file *fp = (struct file *)f->f_fsdata;
753 struct ext2dirent *dp, *edp;
754 char *buf;
755 size_t buf_size;
756 int namlen, length;
757 int error;
758
759 length = strlen(name);
760 fp->f_seekp = 0;
761 while (fp->f_seekp < fp->f_di.di_size) {
762 error = buf_read_file(f, &buf, &buf_size);
763 if (error)
764 return (error);
765 dp = (struct ext2dirent *)buf;
766 edp = (struct ext2dirent *)(buf + buf_size);
767 while (dp < edp) {
768 if (dp->d_ino == (ino_t)0)
769 goto next;
770 namlen = dp->d_namlen;
771 if (namlen == length &&
772 strncmp(name, dp->d_name, length) == 0) {
773 /* found entry */
774 *inumber_p = dp->d_ino;
775 return (0);
776 }
777 next:
778 dp = (struct ext2dirent *)((char *)dp + dp->d_reclen);
779 }
780 fp->f_seekp += buf_size;
781 }
782 return (ENOENT);
783 }
784
785 static int
ext2fs_close(struct open_file * f)786 ext2fs_close(struct open_file *f)
787 {
788 struct file *fp = (struct file *)f->f_fsdata;
789 int level;
790
791 f->f_fsdata = NULL;
792 if (fp == NULL)
793 return (0);
794
795 for (level = 0; level < NIADDR; level++) {
796 if (fp->f_blk[level])
797 free(fp->f_blk[level]);
798 }
799 if (fp->f_buf)
800 free(fp->f_buf);
801 if (fp->f_bg)
802 free(fp->f_bg);
803 free(fp->f_fs);
804 free(fp);
805 return (0);
806 }
807
808 static int
ext2fs_read(struct open_file * f,void * addr,size_t size,size_t * resid)809 ext2fs_read(struct open_file *f, void *addr, size_t size, size_t *resid)
810 {
811 struct file *fp = (struct file *)f->f_fsdata;
812 size_t csize, buf_size;
813 char *buf;
814 int error = 0;
815
816 while (size != 0) {
817 if (fp->f_seekp >= fp->f_di.di_size)
818 break;
819
820 error = buf_read_file(f, &buf, &buf_size);
821 if (error)
822 break;
823
824 csize = size;
825 if (csize > buf_size)
826 csize = buf_size;
827
828 bcopy(buf, addr, csize);
829
830 fp->f_seekp += csize;
831 addr += csize;
832 size -= csize;
833 }
834 if (resid)
835 *resid = size;
836 return (error);
837 }
838
839 static off_t
ext2fs_seek(struct open_file * f,off_t offset,int where)840 ext2fs_seek(struct open_file *f, off_t offset, int where)
841 {
842 struct file *fp = (struct file *)f->f_fsdata;
843
844 switch (where) {
845 case SEEK_SET:
846 fp->f_seekp = offset;
847 break;
848 case SEEK_CUR:
849 fp->f_seekp += offset;
850 break;
851 case SEEK_END:
852 fp->f_seekp = fp->f_di.di_size - offset;
853 break;
854 default:
855 return (-1);
856 }
857 return (fp->f_seekp);
858 }
859
860 static int
ext2fs_stat(struct open_file * f,struct stat * sb)861 ext2fs_stat(struct open_file *f, struct stat *sb)
862 {
863 struct file *fp = (struct file *)f->f_fsdata;
864
865 /* only important stuff */
866 sb->st_mode = fp->f_di.di_mode;
867 sb->st_uid = fp->f_di.di_uid;
868 sb->st_gid = fp->f_di.di_gid;
869 sb->st_size = fp->f_di.di_size;
870 return (0);
871 }
872
873 static int
ext2fs_readdir(struct open_file * f,struct dirent * d)874 ext2fs_readdir(struct open_file *f, struct dirent *d)
875 {
876 struct file *fp = (struct file *)f->f_fsdata;
877 struct ext2dirent *ed;
878 char *buf;
879 size_t buf_size;
880 int error;
881
882 /*
883 * assume that a directory entry will not be split across blocks
884 */
885 again:
886 if (fp->f_seekp >= fp->f_di.di_size)
887 return (ENOENT);
888 error = buf_read_file(f, &buf, &buf_size);
889 if (error)
890 return (error);
891 ed = (struct ext2dirent *)buf;
892 fp->f_seekp += ed->d_reclen;
893 if (ed->d_ino == (ino_t)0)
894 goto again;
895 d->d_type = EXTFTODT(ed->d_type);
896 strncpy(d->d_name, ed->d_name, ed->d_namlen);
897 d->d_name[ed->d_namlen] = '\0';
898 return (0);
899 }
900