ufsread.c revision 294721
1/*- 2 * Copyright (c) 2002 McAfee, Inc. 3 * All rights reserved. 4 * 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 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 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. 18 * 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 29 * SUCH DAMAGE. 30 */ 31/*- 32 * Copyright (c) 1998 Robert Nordier 33 * All rights reserved. 34 * 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 38 * such forms. 39 * 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 43 * purpose. 44 */ 45 46#include <sys/cdefs.h> 47__FBSDID("$FreeBSD: stable/10/sys/boot/common/ufsread.c 294721 2016-01-25 10:55:52Z smh $"); 48 49#include <ufs/ufs/dinode.h> 50#include <ufs/ufs/dir.h> 51#include <ufs/ffs/fs.h> 52 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. */ 57#undef cgbase 58#define cgbase(fs, c) ((ufs2_daddr_t)((fs)->fs_fpg * (c))) 59#endif 60 61typedef uint32_t ufs_ino_t; 62 63/* 64 * We use 4k `virtual' blocks for filesystem data, whatever the actual 65 * filesystem block size. FFS blocks are always a multiple of 4k. 66 */ 67#define VBLKSHIFT 12 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) 80 81/* Buffers that must not span a 64k boundary. */ 82struct dmadat { 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 */ 87}; 88static struct dmadat *dmadat; 89 90static ufs_ino_t lookup(const char *); 91static ssize_t fsread(ufs_ino_t, void *, size_t); 92 93static uint8_t ls, dsk_meta; 94static uint32_t fs_off; 95 96static __inline uint8_t 97fsfind(const char *name, ufs_ino_t * ino) 98{ 99 static char buf[DEV_BSIZE]; 100 struct direct *d; 101 char *s; 102 ssize_t n; 103 104 fs_off = 0; 105 while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0) 106 for (s = buf; s < buf + DEV_BSIZE;) { 107 d = (void *)s; 108 if (ls) 109 printf("%s ", d->d_name); 110 else if (!strcmp(name, d->d_name)) { 111 *ino = d->d_ino; 112 return d->d_type; 113 } 114 s += d->d_reclen; 115 } 116 if (n != -1 && ls) 117 printf("\n"); 118 return 0; 119} 120 121static ufs_ino_t 122lookup(const char *path) 123{ 124 static char name[MAXNAMLEN + 1]; 125 const char *s; 126 ufs_ino_t ino; 127 ssize_t n; 128 uint8_t dt; 129 130 ino = ROOTINO; 131 dt = DT_DIR; 132 for (;;) { 133 if (*path == '/') 134 path++; 135 if (!*path) 136 break; 137 for (s = path; *s && *s != '/'; s++); 138 if ((n = s - path) > MAXNAMLEN) 139 return 0; 140 ls = *path == '?' && n == 1 && !*s; 141 memcpy(name, path, n); 142 name[n] = 0; 143 if (dt != DT_DIR) { 144 printf("%s: not a directory.\n", name); 145 return (0); 146 } 147 if ((dt = fsfind(name, &ino)) <= 0) 148 break; 149 path = s; 150 } 151 return dt == DT_REG ? ino : 0; 152} 153 154/* 155 * Possible superblock locations ordered from most to least likely. 156 */ 157static int sblock_try[] = SBLOCKSEARCH; 158 159#if defined(UFS2_ONLY) 160#define DIP(field) dp2.field 161#elif defined(UFS1_ONLY) 162#define DIP(field) dp1.field 163#else 164#define DIP(field) fs.fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field 165#endif 166 167static ssize_t 168fsread(ufs_ino_t inode, void *buf, size_t nbyte) 169{ 170#ifndef UFS2_ONLY 171 static struct ufs1_dinode dp1; 172 ufs1_daddr_t addr1; 173#endif 174#ifndef UFS1_ONLY 175 static struct ufs2_dinode dp2; 176#endif 177 static struct fs fs; 178 static ufs_ino_t inomap; 179 char *blkbuf; 180 void *indbuf; 181 char *s; 182 size_t n, nb, size, off, vboff; 183 ufs_lbn_t lbn; 184 ufs2_daddr_t addr2, vbaddr; 185 static ufs2_daddr_t blkmap, indmap; 186 u_int u; 187 188 blkbuf = dmadat->blkbuf; 189 indbuf = dmadat->indbuf; 190 if (!dsk_meta) { 191 inomap = 0; 192 for (n = 0; sblock_try[n] != -1; n++) { 193 if (dskread(dmadat->sbbuf, sblock_try[n] / DEV_BSIZE, 194 SBLOCKSIZE / DEV_BSIZE)) 195 return -1; 196 memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); 197 if (( 198#if defined(UFS1_ONLY) 199 fs.fs_magic == FS_UFS1_MAGIC 200#elif defined(UFS2_ONLY) 201 (fs.fs_magic == FS_UFS2_MAGIC && 202 fs.fs_sblockloc == sblock_try[n]) 203#else 204 fs.fs_magic == FS_UFS1_MAGIC || 205 (fs.fs_magic == FS_UFS2_MAGIC && 206 fs.fs_sblockloc == sblock_try[n]) 207#endif 208 ) && 209 fs.fs_bsize <= MAXBSIZE && 210 fs.fs_bsize >= sizeof(struct fs)) 211 break; 212 } 213 if (sblock_try[n] == -1) { 214 return -1; 215 } 216 dsk_meta++; 217 } else 218 memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); 219 if (!inode) 220 return 0; 221 if (inomap != inode) { 222 n = IPERVBLK(&fs); 223 if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) 224 return -1; 225 n = INO_TO_VBO(n, inode); 226#if defined(UFS1_ONLY) 227 memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, 228 sizeof(struct ufs1_dinode)); 229#elif defined(UFS2_ONLY) 230 memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, 231 sizeof(struct ufs2_dinode)); 232#else 233 if (fs.fs_magic == FS_UFS1_MAGIC) 234 memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, 235 sizeof(struct ufs1_dinode)); 236 else 237 memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, 238 sizeof(struct ufs2_dinode)); 239#endif 240 inomap = inode; 241 fs_off = 0; 242 blkmap = indmap = 0; 243 } 244 s = buf; 245 size = DIP(di_size); 246 n = size - fs_off; 247 if (nbyte > n) 248 nbyte = n; 249 nb = nbyte; 250 while (nb) { 251 lbn = lblkno(&fs, fs_off); 252 off = blkoff(&fs, fs_off); 253 if (lbn < NDADDR) { 254 addr2 = DIP(di_db[lbn]); 255 } else if (lbn < NDADDR + NINDIR(&fs)) { 256 n = INDIRPERVBLK(&fs); 257 addr2 = DIP(di_ib[0]); 258 u = (u_int)(lbn - NDADDR) / n * DBPERVBLK; 259 vbaddr = fsbtodb(&fs, addr2) + u; 260 if (indmap != vbaddr) { 261 if (dskread(indbuf, vbaddr, DBPERVBLK)) 262 return -1; 263 indmap = vbaddr; 264 } 265 n = (lbn - NDADDR) & (n - 1); 266#if defined(UFS1_ONLY) 267 memcpy(&addr1, (ufs1_daddr_t *)indbuf + n, 268 sizeof(ufs1_daddr_t)); 269 addr2 = addr1; 270#elif defined(UFS2_ONLY) 271 memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, 272 sizeof(ufs2_daddr_t)); 273#else 274 if (fs.fs_magic == FS_UFS1_MAGIC) { 275 memcpy(&addr1, (ufs1_daddr_t *)indbuf + n, 276 sizeof(ufs1_daddr_t)); 277 addr2 = addr1; 278 } else 279 memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, 280 sizeof(ufs2_daddr_t)); 281#endif 282 } else 283 return -1; 284 vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; 285 vboff = off & VBLKMASK; 286 n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); 287 if (n > VBLKSIZE) 288 n = VBLKSIZE; 289 if (blkmap != vbaddr) { 290 if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) 291 return -1; 292 blkmap = vbaddr; 293 } 294 n -= vboff; 295 if (n > nb) 296 n = nb; 297 memcpy(s, blkbuf + vboff, n); 298 s += n; 299 fs_off += n; 300 nb -= n; 301 } 302 return nbyte; 303} 304