sys/boot/common/ufsread.c

   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$");
  48
  49 #include <ufs/ufs/dinode.h>
  50 #include <ufs/ufs/dir.h>
  51 #include <ufs/ffs/fs.h>
  52 #ifdef UFS_SMALL_CGBASE
  53 /* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase
  54    (see sys/ufs/ffs/fs.h rev 1.39) so that small boot loaders (e.g. boot2) can
  55    support both UFS1 and UFS2. */
  56 #undef cgbase
  57 #define cgbase(fs, c)   ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
  58 #endif
  59
  60 /*
  61  * We use 4k `virtual' blocks for filesystem data, whatever the actual
  62  * filesystem block size. FFS blocks are always a multiple of 4k.
  63  */
  64 #define VBLKSHIFT       12
  65 #define VBLKSIZE        (1 << VBLKSHIFT)
  66 #define VBLKMASK        (VBLKSIZE - 1)
  67 #define DBPERVBLK       (VBLKSIZE / DEV_BSIZE)
  68 #define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
  69 #define IPERVBLK(fs)    (INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
  70 #define INO_TO_VBA(fs, ipervblk, x) \
  71     (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \
  72     (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))
  73 #define INO_TO_VBO(ipervblk, x) ((x) % ipervblk)
  74 #define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \
  75     ((off) / VBLKSIZE) * DBPERVBLK)
  76 #define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)
  77
  78 /* Buffers that must not span a 64k boundary. */
  79 struct dmadat {
  80         char blkbuf[VBLKSIZE];  /* filesystem blocks */
  81         char indbuf[VBLKSIZE];  /* indir blocks */
  82         char sbbuf[SBLOCKSIZE]; /* superblock */
  83         char secbuf[DEV_BSIZE]; /* for MBR/disklabel */
  84 };
  85 static struct dmadat *dmadat;
  86
  87 static ino_t lookup(const char *);
  88 static ssize_t fsread(ino_t, void *, size_t);
  89
  90 static uint8_t ls, dsk_meta;
  91 static uint32_t fs_off;
  92
  93 static __inline int
  94 fsfind(const char *name, ino_t * ino)
  95 {
  96         char buf[DEV_BSIZE];
  97         struct direct *d;
  98         char *s;
  99         ssize_t n;
 100
 101         fs_off = 0;
 102         while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
 103                 for (s = buf; s < buf + DEV_BSIZE;) {
 104                         d = (void *)s;
 105                         if (ls)
 106                                 printf("%s ", d->d_name);
 107                         else if (!strcmp(name, d->d_name)) {
 108                                 *ino = d->d_ino;
 109                                 return d->d_type;
 110                         }
 111                         s += d->d_reclen;
 112                 }
 113         if (n != -1 && ls)
 114                 printf("\n");
 115         return 0;
 116 }
 117
 118 static ino_t
 119 lookup(const char *path)
 120 {
 121         char name[MAXNAMLEN + 1];
 122         const char *s;
 123         ino_t ino;
 124         ssize_t n;
 125         uint8_t dt;
 126
 127         ino = ROOTINO;
 128         dt = DT_DIR;
 129         for (;;) {
 130                 if (*path == '/')
 131                         path++;
 132                 if (!*path)
 133                         break;
 134                 for (s = path; *s && *s != '/'; s++);
 135                 if ((n = s - path) > MAXNAMLEN)
 136                         return 0;
 137                 ls = *path == '?' && n == 1 && !*s;
 138                 memcpy(name, path, n);
 139                 name[n] = 0;
 140                 if (dt != DT_DIR) {
 141                         printf("%s: not a directory.\n", name);
 142                         return (0);
 143                 }
 144                 if ((dt = fsfind(name, &ino)) <= 0)
 145                         break;
 146                 path = s;
 147         }
 148         return dt == DT_REG ? ino : 0;
 149 }
 150
 151 /*
 152  * Possible superblock locations ordered from most to least likely.
 153  */
 154 static int sblock_try[] = SBLOCKSEARCH;
 155
 156 #if defined(UFS2_ONLY)
 157 #define DIP(field) dp2.field
 158 #elif defined(UFS1_ONLY)
 159 #define DIP(field) dp1.field
 160 #else
 161 #define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
 162 #endif
 163
 164 static ssize_t
 165 fsread(ino_t inode, void *buf, size_t nbyte)
 166 {
 167 #ifndef UFS2_ONLY
 168         static struct ufs1_dinode dp1;
 169 #endif
 170 #ifndef UFS1_ONLY
 171         static struct ufs2_dinode dp2;
 172 #endif
 173         static ino_t inomap;
 174         char *blkbuf;
 175         void *indbuf;
 176         struct fs *fs;
 177         char *s;
 178         size_t n, nb, size, off, vboff;
 179         ufs_lbn_t lbn;
 180         ufs2_daddr_t addr, vbaddr;
 181         static ufs2_daddr_t blkmap, indmap;
 182         u_int u;
 183
 184
 185         blkbuf = dmadat->blkbuf;
 186         indbuf = dmadat->indbuf;
 187         fs = (struct fs *)dmadat->sbbuf;
 188         if (!dsk_meta) {
 189                 inomap = 0;
 190                 for (n = 0; sblock_try[n] != -1; n++) {
 191                         if (dskread(fs, sblock_try[n] / DEV_BSIZE,
 192                             SBLOCKSIZE / DEV_BSIZE))
 193                                 return -1;
 194                         if ((
 195 #if defined(UFS1_ONLY)
 196                              fs->fs_magic == FS_UFS1_MAGIC
 197 #elif defined(UFS2_ONLY)
 198                             (fs->fs_magic == FS_UFS2_MAGIC &&
 199                             fs->fs_sblockloc == sblock_try[n])
 200 #else
 201                              fs->fs_magic == FS_UFS1_MAGIC ||
 202                             (fs->fs_magic == FS_UFS2_MAGIC &&
 203                             fs->fs_sblockloc == sblock_try[n])
 204 #endif
 205                             ) &&
 206                             fs->fs_bsize <= MAXBSIZE &&
 207                             fs->fs_bsize >= sizeof(struct fs))
 208                                 break;
 209                 }
 210                 if (sblock_try[n] == -1) {
 211                         printf("Not ufs\n");
 212                         return -1;
 213                 }
 214                 dsk_meta++;
 215         }
 216         if (!inode)
 217                 return 0;
 218         if (inomap != inode) {
 219                 n = IPERVBLK(fs);
 220                 if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK))
 221                         return -1;
 222                 n = INO_TO_VBO(n, inode);
 223 #if defined(UFS1_ONLY)
 224                 memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
 225                     sizeof(struct ufs1_dinode));
 226 #elif defined(UFS2_ONLY)
 227                 memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
 228                     sizeof(struct ufs2_dinode));
 229 #else
 230                 if (fs->fs_magic == FS_UFS1_MAGIC)
 231                         memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
 232                             sizeof(struct ufs1_dinode));
 233                 else
 234                         memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
 235                             sizeof(struct ufs2_dinode));
 236
 237 #endif
 238                 inomap = inode;
 239                 fs_off = 0;
 240                 blkmap = indmap = 0;
 241         }
 242         s = buf;
 243         size = DIP(di_size);
 244         n = size - fs_off;
 245         if (nbyte > n)
 246                 nbyte = n;
 247         nb = nbyte;
 248         while (nb) {
 249                 lbn = lblkno(fs, fs_off);
 250                 off = blkoff(fs, fs_off);
 251                 if (lbn < NDADDR) {
 252                         addr = DIP(di_db[lbn]);
 253                 } else if (lbn < NDADDR + NINDIR(fs)) {
 254                         n = INDIRPERVBLK(fs);
 255                         addr = DIP(di_ib[0]);
 256                         u = (u_int)(lbn - NDADDR) / n * DBPERVBLK;
 257                         vbaddr = fsbtodb(fs, addr) + u;
 258                         if (indmap != vbaddr) {
 259                                 if (dskread(indbuf, vbaddr, DBPERVBLK))
 260                                         return -1;
 261                                 indmap = vbaddr;
 262                         }
 263                         n = (lbn - NDADDR) & (n - 1);
 264 #if defined(UFS1_ONLY)
 265                         addr = ((ufs1_daddr_t *)indbuf)[n];
 266 #elif defined(UFS2_ONLY)
 267                         addr = ((ufs2_daddr_t *)indbuf)[n];
 268 #else
 269                         if (fs->fs_magic == FS_UFS1_MAGIC)
 270                                 addr = ((ufs1_daddr_t *)indbuf)[n];
 271                         else
 272                                 addr = ((ufs2_daddr_t *)indbuf)[n];
 273 #endif
 274                 } else {
 275                         return -1;
 276                 }
 277                 vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;
 278                 vboff = off & VBLKMASK;
 279                 n = sblksize(fs, size, lbn) - (off & ~VBLKMASK);
 280                 if (n > VBLKSIZE)
 281                         n = VBLKSIZE;
 282                 if (blkmap != vbaddr) {
 283                         if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
 284                                 return -1;
 285                         blkmap = vbaddr;
 286                 }
 287                 n -= vboff;
 288                 if (n > nb)
 289                         n = nb;
 290                 memcpy(s, blkbuf + vboff, n);
 291                 s += n;
 292                 fs_off += n;
 293                 nb -= n;
 294         }
 295         return nbyte;
 296 }