2 * Copyright (c) 2002 McAfee, Inc.
5 * This software was developed for the FreeBSD Project by Marshall
6 * Kirk McKusick and McAfee Research,, the Security Research Division of
7 * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as
8 * part of the DARPA CHATS research program
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * Copyright (c) 1998 Robert Nordier
33 * All rights reserved.
35 * Redistribution and use in source and binary forms are freely
36 * permitted provided that the above copyright notice and this
37 * paragraph and the following disclaimer are duplicated in all
40 * This software is provided "AS IS" and without any express or
41 * implied warranties, including, without limitation, the implied
42 * warranties of merchantability and fitness for a particular
46 #include <sys/cdefs.h>
47 __FBSDID("$FreeBSD$");
49 #include <ufs/ufs/dinode.h>
50 #include <ufs/ufs/dir.h>
51 #include <ufs/ffs/fs.h>
53 #ifdef UFS_SMALL_CGBASE
54 /* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase
55 (see sys/ufs/ffs/fs.h rev 1.39) so that small boot loaders (e.g. boot2) can
56 support both UFS1 and UFS2. */
58 #define cgbase(fs, c) ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
61 typedef uint32_t ufs_ino_t;
64 * We use 4k `virtual' blocks for filesystem data, whatever the actual
65 * filesystem block size. FFS blocks are always a multiple of 4k.
68 #define VBLKSIZE (1 << VBLKSHIFT)
69 #define VBLKMASK (VBLKSIZE - 1)
70 #define DBPERVBLK (VBLKSIZE / DEV_BSIZE)
71 #define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
72 #define IPERVBLK(fs) (INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
73 #define INO_TO_VBA(fs, ipervblk, x) \
74 (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \
75 (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))
76 #define INO_TO_VBO(ipervblk, x) ((x) % ipervblk)
77 #define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \
78 ((off) / VBLKSIZE) * DBPERVBLK)
79 #define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)
81 /* Buffers that must not span a 64k boundary. */
83 char blkbuf[VBLKSIZE]; /* filesystem blocks */
84 char indbuf[VBLKSIZE]; /* indir blocks */
85 char sbbuf[SBLOCKSIZE]; /* superblock */
86 char secbuf[DEV_BSIZE]; /* for MBR/disklabel */
88 static struct dmadat *dmadat;
90 static ufs_ino_t lookup(const char *);
91 static ssize_t fsread(ufs_ino_t, void *, size_t);
93 static uint8_t ls, dsk_meta;
94 static uint32_t fs_off;
96 static __inline uint8_t
97 fsfind(const char *name, ufs_ino_t * ino)
99 static char buf[DEV_BSIZE];
105 while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
106 for (s = buf; s < buf + DEV_BSIZE;) {
109 printf("%s ", d->d_name);
110 else if (!strcmp(name, d->d_name)) {
122 lookup(const char *path)
124 static char name[MAXNAMLEN + 1];
137 for (s = path; *s && *s != '/'; s++);
138 if ((n = s - path) > MAXNAMLEN)
140 ls = *path == '?' && n == 1 && !*s;
141 memcpy(name, path, n);
144 printf("%s: not a directory.\n", name);
147 if ((dt = fsfind(name, &ino)) <= 0)
151 return dt == DT_REG ? ino : 0;
155 * Possible superblock locations ordered from most to least likely.
157 static int sblock_try[] = SBLOCKSEARCH;
159 #if defined(UFS2_ONLY)
160 #define DIP(field) dp2.field
161 #elif defined(UFS1_ONLY)
162 #define DIP(field) dp1.field
164 #define DIP(field) fs.fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
168 fsread(ufs_ino_t inode, void *buf, size_t nbyte)
171 static struct ufs1_dinode dp1;
175 static struct ufs2_dinode dp2;
178 static ufs_ino_t inomap;
182 size_t n, nb, size, off, vboff;
184 ufs2_daddr_t addr2, vbaddr;
185 static ufs2_daddr_t blkmap, indmap;
188 blkbuf = dmadat->blkbuf;
189 indbuf = dmadat->indbuf;
192 * Force probe if inode is zero to ensure we have a valid fs, otherwise
193 * when probing multiple paritions, reads from subsequent parititions
194 * will incorrectly succeed.
196 if (!dsk_meta || inode == 0) {
199 for (n = 0; sblock_try[n] != -1; n++) {
200 if (dskread(dmadat->sbbuf, sblock_try[n] / DEV_BSIZE,
201 SBLOCKSIZE / DEV_BSIZE))
203 memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
205 #if defined(UFS1_ONLY)
206 fs.fs_magic == FS_UFS1_MAGIC
207 #elif defined(UFS2_ONLY)
208 (fs.fs_magic == FS_UFS2_MAGIC &&
209 fs.fs_sblockloc == sblock_try[n])
211 fs.fs_magic == FS_UFS1_MAGIC ||
212 (fs.fs_magic == FS_UFS2_MAGIC &&
213 fs.fs_sblockloc == sblock_try[n])
216 fs.fs_bsize <= MAXBSIZE &&
217 fs.fs_bsize >= (int32_t)sizeof(struct fs))
220 if (sblock_try[n] == -1) {
225 memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
228 if (inomap != inode) {
230 if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
232 n = INO_TO_VBO(n, inode);
233 #if defined(UFS1_ONLY)
234 memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
235 sizeof(struct ufs1_dinode));
236 #elif defined(UFS2_ONLY)
237 memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
238 sizeof(struct ufs2_dinode));
240 if (fs.fs_magic == FS_UFS1_MAGIC)
241 memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
242 sizeof(struct ufs1_dinode));
244 memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
245 sizeof(struct ufs2_dinode));
258 lbn = lblkno(&fs, fs_off);
259 off = blkoff(&fs, fs_off);
261 addr2 = DIP(di_db[lbn]);
262 } else if (lbn < NDADDR + NINDIR(&fs)) {
263 n = INDIRPERVBLK(&fs);
264 addr2 = DIP(di_ib[0]);
265 u = (u_int)(lbn - NDADDR) / n * DBPERVBLK;
266 vbaddr = fsbtodb(&fs, addr2) + u;
267 if (indmap != vbaddr) {
268 if (dskread(indbuf, vbaddr, DBPERVBLK))
272 n = (lbn - NDADDR) & (n - 1);
273 #if defined(UFS1_ONLY)
274 memcpy(&addr1, (ufs1_daddr_t *)indbuf + n,
275 sizeof(ufs1_daddr_t));
277 #elif defined(UFS2_ONLY)
278 memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
279 sizeof(ufs2_daddr_t));
281 if (fs.fs_magic == FS_UFS1_MAGIC) {
282 memcpy(&addr1, (ufs1_daddr_t *)indbuf + n,
283 sizeof(ufs1_daddr_t));
286 memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
287 sizeof(ufs2_daddr_t));
291 vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
292 vboff = off & VBLKMASK;
293 n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
296 if (blkmap != vbaddr) {
297 if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
304 memcpy(s, blkbuf + vboff, n);