sys/boot/common/ufsread.c

   1 /*-
   2  * Copyright (c) 2002 Networks Associates Technology, Inc.
   3  * All rights reserved.
   4  *
   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
   9  * research program
  10  *
  11  * Copyright (c) 1998 Robert Nordier
  12  * All rights reserved.
  13  *
  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
  17  * such forms.
  18  *
  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
  22  * purpose.
  23  *
  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 $
  26  */
  27
  28 #include "dinode.h"
  29 #include "fs.h"
  30 #ifdef __i386__
  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. */
  34 #undef cgbase
  35 #define cgbase(fs, c)   ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
  36 #endif
  37
  38 /*
  39  * We use 4k `virtual' blocks for filesystem data, whatever the actual
  40  * filesystem block size. FFS blocks are always a multiple of 4k.
  41  */
  42 #define VBLKSHIFT       12
  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)
  55
  56 /* Buffers that must not span a 64k boundary. */
  57 struct dmadat {
  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 */
  62 };
  63 static struct dmadat *dmadat;
  64
  65 static ino_t lookup(const char *);
  66 static ssize_t fsread(ino_t, void *, size_t);
  67
  68 static int ls, dsk_meta;
  69 static uint32_t fs_off;
  70
  71 static __inline__ int
  72 fsfind(const char *name, ino_t * ino)
  73 {
  74         char buf[DEV_BSIZE];
  75         struct dirent *d;
  76         char *s;
  77         ssize_t n;
  78
  79         fs_off = 0;
  80         while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
  81                 for (s = buf; s < buf + DEV_BSIZE;) {
  82                         d = (void *)s;
  83                         if (ls)
  84                                 printf("%s ", d->d_name);
  85                         else if (!strcmp(name, d->d_name)) {
  86                                 *ino = d->d_fileno;
  87                                 return d->d_type;
  88                         }
  89                         s += d->d_reclen;
  90                 }
  91         if (n != -1 && ls)
  92                 printf("\n");
  93         return 0;
  94 }
  95
  96 static ino_t
  97 lookup(const char *path)
  98 {
  99         char name[MAXNAMLEN + 1];
 100         const char *s;
 101         ino_t ino;
 102         ssize_t n;
 103         int dt;
 104
 105         ino = ROOTINO;
 106         dt = DT_DIR;
 107         name[0] = '/';
 108         name[1] = '\0';
 109         for (;;) {
 110                 if (*path == '/')
 111                         path++;
 112                 if (!*path)
 113                         break;
 114                 for (s = path; *s && *s != '/'; s++);
 115                 if ((n = s - path) > MAXNAMLEN)
 116                         return 0;
 117                 ls = *path == '?' && n == 1 && !*s;
 118                 memcpy(name, path, n);
 119                 name[n] = 0;
 120                 if (dt != DT_DIR) {
 121                         printf("%s: not a directory.\n", name);
 122                         return (0);
 123                 }
 124                 if ((dt = fsfind(name, &ino)) <= 0)
 125                         break;
 126                 path = s;
 127         }
 128         return dt == DT_REG ? ino : 0;
 129 }
 130
 131 /*
 132  * Possible superblock locations ordered from most to least likely.
 133  */
 134 static int sblock_try[] = SBLOCKSEARCH;
 135
 136 #if defined(UFS2_ONLY)
 137 #define DIP(field) dp2.field
 138 #elif defined(UFS1_ONLY)
 139 #define DIP(field) dp1.field
 140 #else
 141 #define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
 142 #endif
 143
 144 static ssize_t
 145 fsread(ino_t inode, void *buf, size_t nbyte)
 146 {
 147 #ifndef UFS2_ONLY
 148         static struct ufs1_dinode dp1;
 149 #endif
 150 #ifndef UFS1_ONLY
 151         static struct ufs2_dinode dp2;
 152 #endif
 153         static ino_t inomap;
 154         char *blkbuf;
 155         void *indbuf;
 156         struct fs *fs;
 157         char *s;
 158         size_t n, nb, size, off, vboff;
 159         ufs_lbn_t lbn;
 160         ufs2_daddr_t addr, vbaddr;
 161         static ufs2_daddr_t blkmap, indmap;
 162         u_int u;
 163
 164
 165         blkbuf = dmadat->blkbuf;
 166         indbuf = dmadat->indbuf;
 167         fs = (struct fs *)dmadat->sbbuf;
 168         if (!dsk_meta) {
 169                 inomap = 0;
 170                 for (n = 0; sblock_try[n] != -1; n++) {
 171                         if (dskread(fs, sblock_try[n] / DEV_BSIZE,
 172                             SBLOCKSIZE / DEV_BSIZE))
 173                                 return -1;
 174                         if ((
 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])
 180 #else
 181                              fs->fs_magic == FS_UFS1_MAGIC ||
 182                             (fs->fs_magic == FS_UFS2_MAGIC &&
 183                             fs->fs_sblockloc == sblock_try[n])
 184 #endif
 185                             ) &&
 186                             fs->fs_bsize <= MAXBSIZE &&
 187                             fs->fs_bsize >= sizeof(struct fs))
 188                                 break;
 189                 }
 190                 if (sblock_try[n] == -1) {
 191                         printf("Not ufs\n");
 192                         return -1;
 193                 }
 194                 dsk_meta++;
 195         }
 196         if (!inode)
 197                 return 0;
 198         if (inomap != inode) {
 199                 n = IPERVBLK(fs);
 200                 if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK))
 201                         return -1;
 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];
 207 #else
 208                 if (fs->fs_magic == FS_UFS1_MAGIC)
 209                         dp1 = ((struct ufs1_dinode *)blkbuf)[n];
 210                 else
 211                         dp2 = ((struct ufs2_dinode *)blkbuf)[n];
 212 #endif
 213                 inomap = inode;
 214                 fs_off = 0;
 215                 blkmap = indmap = 0;
 216         }
 217         s = buf;
 218         size = DIP(di_size);
 219         n = size - fs_off;
 220         if (nbyte > n)
 221                 nbyte = n;
 222         nb = nbyte;
 223         while (nb) {
 224                 lbn = lblkno(fs, fs_off);
 225                 off = blkoff(fs, fs_off);
 226                 if (lbn < NDADDR) {
 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))
 235                                         return -1;
 236                                 indmap = vbaddr;
 237                         }
 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];
 243 #else
 244                         if (fs->fs_magic == FS_UFS1_MAGIC)
 245                                 addr = ((ufs1_daddr_t *)indbuf)[n];
 246                         else
 247                                 addr = ((ufs2_daddr_t *)indbuf)[n];
 248 #endif
 249                 } else {
 250                         return -1;
 251                 }
 252                 vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;
 253                 vboff = off & VBLKMASK;
 254                 n = sblksize(fs, size, lbn) - (off & ~VBLKMASK);
 255                 if (n > VBLKSIZE)
 256                         n = VBLKSIZE;
 257                 if (blkmap != vbaddr) {
 258                         if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
 259                                 return -1;
 260                         blkmap = vbaddr;
 261                 }
 262                 n -= vboff;
 263                 if (n > nb)
 264                         n = nb;
 265                 memcpy(s, blkbuf + vboff, n);
 266                 s += n;
 267                 fs_off += n;
 268                 nb -= n;
 269         }
 270         return nbyte;
 271 }