2 * Copyright (c) 2002 Networks Associates Technology, Inc.
5 * This software was developed for the FreeBSD Project by Marshall
6 * Kirk McKusick and Network Associates Laboratories, the Security
7 * Research Division of Network Associates, Inc. under DARPA/SPAWAR
8 * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
11 * Copyright (c) 1998 Robert Nordier
12 * All rights reserved.
14 * Redistribution and use in source and binary forms are freely
15 * permitted provided that the above copyright notice and this
16 * paragraph and the following disclaimer are duplicated in all
19 * This software is provided "AS IS" and without any express or
20 * implied warranties, including, without limitation, the implied
21 * warranties of merchantability and fitness for a particular
24 * $FreeBSD: src/sys/boot/common/ufsread.c,v 1.12 2003/08/25 23:30:41 obrien Exp $
25 * $DragonFly: src/sys/boot/common/ufsread.c,v 1.1 2003/11/10 06:08:31 dillon Exp $
31 /* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase
32 (see sys/ufs/ffs/fs.h rev 1.39) so that i386 boot loader (boot2) can
33 support both UFS1 and UFS2 again. */
35 #define cgbase(fs, c) ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
39 * We use 4k `virtual' blocks for filesystem data, whatever the actual
40 * filesystem block size. FFS blocks are always a multiple of 4k.
43 #define VBLKSIZE (1 << VBLKSHIFT)
44 #define VBLKMASK (VBLKSIZE - 1)
45 #define DBPERVBLK (VBLKSIZE / DEV_BSIZE)
46 #define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
47 #define IPERVBLK(fs) (INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
48 #define INO_TO_VBA(fs, ipervblk, x) \
49 (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \
50 (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))
51 #define INO_TO_VBO(ipervblk, x) ((x) % ipervblk)
52 #define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \
53 ((off) / VBLKSIZE) * DBPERVBLK)
54 #define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)
56 /* Buffers that must not span a 64k boundary. */
58 char blkbuf[VBLKSIZE]; /* filesystem blocks */
59 char indbuf[VBLKSIZE]; /* indir blocks */
60 char sbbuf[SBLOCKSIZE]; /* superblock */
61 char secbuf[DEV_BSIZE]; /* for MBR/disklabel */
63 static struct dmadat *dmadat;
65 static ino_t lookup(const char *);
66 static ssize_t fsread(ino_t, void *, size_t);
68 static int ls, dsk_meta;
69 static uint32_t fs_off;
72 fsfind(const char *name, ino_t * ino)
80 while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
81 for (s = buf; s < buf + DEV_BSIZE;) {
84 printf("%s ", d->d_name);
85 else if (!strcmp(name, d->d_name)) {
97 lookup(const char *path)
99 char name[MAXNAMLEN + 1];
114 for (s = path; *s && *s != '/'; s++);
115 if ((n = s - path) > MAXNAMLEN)
117 ls = *path == '?' && n == 1 && !*s;
118 memcpy(name, path, n);
121 printf("%s: not a directory.\n", name);
124 if ((dt = fsfind(name, &ino)) <= 0)
128 return dt == DT_REG ? ino : 0;
132 * Possible superblock locations ordered from most to least likely.
134 static int sblock_try[] = SBLOCKSEARCH;
136 #if defined(UFS2_ONLY)
137 #define DIP(field) dp2.field
138 #elif defined(UFS1_ONLY)
139 #define DIP(field) dp1.field
141 #define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
145 fsread(ino_t inode, void *buf, size_t nbyte)
148 static struct ufs1_dinode dp1;
151 static struct ufs2_dinode dp2;
158 size_t n, nb, size, off, vboff;
160 ufs2_daddr_t addr, vbaddr;
161 static ufs2_daddr_t blkmap, indmap;
165 blkbuf = dmadat->blkbuf;
166 indbuf = dmadat->indbuf;
167 fs = (struct fs *)dmadat->sbbuf;
170 for (n = 0; sblock_try[n] != -1; n++) {
171 if (dskread(fs, sblock_try[n] / DEV_BSIZE,
172 SBLOCKSIZE / DEV_BSIZE))
175 #if defined(UFS1_ONLY)
176 fs->fs_magic == FS_UFS1_MAGIC
177 #elif defined(UFS2_ONLY)
178 (fs->fs_magic == FS_UFS2_MAGIC &&
179 fs->fs_sblockloc == sblock_try[n])
181 fs->fs_magic == FS_UFS1_MAGIC ||
182 (fs->fs_magic == FS_UFS2_MAGIC &&
183 fs->fs_sblockloc == sblock_try[n])
186 fs->fs_bsize <= MAXBSIZE &&
187 fs->fs_bsize >= sizeof(struct fs))
190 if (sblock_try[n] == -1) {
198 if (inomap != inode) {
200 if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK))
202 n = INO_TO_VBO(n, inode);
203 #if defined(UFS1_ONLY)
204 dp1 = ((struct ufs1_dinode *)blkbuf)[n];
205 #elif defined(UFS2_ONLY)
206 dp2 = ((struct ufs2_dinode *)blkbuf)[n];
208 if (fs->fs_magic == FS_UFS1_MAGIC)
209 dp1 = ((struct ufs1_dinode *)blkbuf)[n];
211 dp2 = ((struct ufs2_dinode *)blkbuf)[n];
224 lbn = lblkno(fs, fs_off);
225 off = blkoff(fs, fs_off);
227 addr = DIP(di_db[lbn]);
228 } else if (lbn < NDADDR + NINDIR(fs)) {
229 n = INDIRPERVBLK(fs);
230 addr = DIP(di_ib[0]);
231 u = (u_int)(lbn - NDADDR) / (n * DBPERVBLK);
232 vbaddr = fsbtodb(fs, addr) + u;
233 if (indmap != vbaddr) {
234 if (dskread(indbuf, vbaddr, DBPERVBLK))
238 n = (lbn - NDADDR) & (n - 1);
239 #if defined(UFS1_ONLY)
240 addr = ((ufs1_daddr_t *)indbuf)[n];
241 #elif defined(UFS2_ONLY)
242 addr = ((ufs2_daddr_t *)indbuf)[n];
244 if (fs->fs_magic == FS_UFS1_MAGIC)
245 addr = ((ufs1_daddr_t *)indbuf)[n];
247 addr = ((ufs2_daddr_t *)indbuf)[n];
252 vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;
253 vboff = off & VBLKMASK;
254 n = sblksize(fs, size, lbn) - (off & ~VBLKMASK);
257 if (blkmap != vbaddr) {
258 if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
265 memcpy(s, blkbuf + vboff, n);