![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsys_ufs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs|
Return to fsys_ufs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 ! root 1: /* ! 2: * GRUB -- GRand Unified Bootloader ! 3: * Copyright (c) 2000, 2001 Free Software Foundation, Inc. ! 4: * Copyright (c) 2005 Rink Springer ! 5: * ! 6: * This file is based on FreeBSD 5.4-RELEASE's /sys/boot/common/ufsread.c, ! 7: * and has some minor patches so it'll work with Cromwell/GRUB. ! 8: * ! 9: */ ! 10: /*- ! 11: * Copyright (c) 2002 McAfee, Inc. ! 12: * All rights reserved. ! 13: * ! 14: * This software was developed for the FreeBSD Project by Marshall ! 15: * Kirk McKusick and McAfee Research,, the Security Research Division of ! 16: * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as ! 17: * part of the DARPA CHATS research program ! 18: * ! 19: * Redistribution and use in source and binary forms, with or without ! 20: * modification, are permitted provided that the following conditions ! 21: * are met: ! 22: * 1. Redistributions of source code must retain the above copyright ! 23: * notice, this list of conditions and the following disclaimer. ! 24: * 2. Redistributions in binary form must reproduce the above copyright ! 25: * notice, this list of conditions and the following disclaimer in the ! 26: * documentation and/or other materials provided with the distribution. ! 27: * ! 28: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ! 29: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 30: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 31: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ! 32: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 33: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 34: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 35: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 36: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 37: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 38: * SUCH DAMAGE. ! 39: */ ! 40: /*- ! 41: * Copyright (c) 1998 Robert Nordier ! 42: * All rights reserved. ! 43: * ! 44: * Redistribution and use in source and binary forms are freely ! 45: * permitted provided that the above copyright notice and this ! 46: * paragraph and the following disclaimer are duplicated in all ! 47: * such forms. ! 48: * ! 49: * This software is provided "AS IS" and without any express or ! 50: * implied warranties, including, without limitation, the implied ! 51: * warranties of merchantability and fitness for a particular ! 52: * purpose. ! 53: */ ! 54: #ifdef FSYS_UFS ! 55: ! 56: #include "asm/types.h" ! 57: ! 58: #include "shared.h" ! 59: #include "filesys.h" ! 60: ! 61: #include "ufs_dinode.h" ! 62: #include "ufs_fs.h" ! 63: ! 64: #ifdef __i386__ ! 65: /* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase ! 66: (see sys/ufs/ffs/fs.h rev 1.39) so that i386 boot loader (boot2) can ! 67: support both UFS1 and UFS2 again. */ ! 68: #undef cgbase ! 69: #define cgbase(fs, c) ((ufs2_daddr_t)((fs)->fs_fpg * (c))) ! 70: #endif ! 71: ! 72: /* ! 73: * We use 4k `virtual' blocks for filesystem data, whatever the actual ! 74: * filesystem block size. FFS blocks are always a multiple of 4k. ! 75: */ ! 76: #define VBLKSHIFT 12 ! 77: #define VBLKSIZE (1 << VBLKSHIFT) ! 78: #define VBLKMASK (VBLKSIZE - 1) ! 79: #define DBPERVBLK (VBLKSIZE / DEV_BSIZE) ! 80: #define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT)) ! 81: #define IPERVBLK(fs) (INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT)) ! 82: #define INO_TO_VBA(fs, ipervblk, x) \ ! 83: (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \ ! 84: (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK)) ! 85: #define INO_TO_VBO(ipervblk, x) ((x) % ipervblk) ! 86: #define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \ ! 87: ((off) / VBLKSIZE) * DBPERVBLK) ! 88: #define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK) ! 89: ! 90: /* Buffers that must not span a 64k boundary. */ ! 91: struct dmadat { ! 92: char blkbuf[VBLKSIZE]; /* filesystem blocks */ ! 93: char indbuf[VBLKSIZE]; /* indir blocks */ ! 94: char sbbuf[SBLOCKSIZE]; /* superblock */ ! 95: char secbuf[DEV_BSIZE]; /* for MBR/disklabel */ ! 96: }; ! 97: static struct dmadat *dmadat = (struct dmadat*)FSYS_BUF; ! 98: ! 99: #define SUPERBLOCK ((struct fs*)dmadat->sbbuf) ! 100: ! 101: ino_t lookup(const char *); ! 102: ssize_t fsread(ino_t, void *, size_t); ! 103: ! 104: static int dsk_meta; ! 105: static uint32_t fs_off; ! 106: static ino_t cur_ino = 0; ! 107: ! 108: static inline int ! 109: dskread (void* buf, unsigned lba, unsigned nblk) ! 110: { ! 111: return !devread (lba, 0, nblk * DEV_BSIZE, buf) ? -1 : 0; ! 112: } ! 113: ! 114: #if defined(UFS2_ONLY) ! 115: #define DIP(field) dp2.field ! 116: #elif defined(UFS1_ONLY) ! 117: #define DIP(field) dp1.field ! 118: #else ! 119: #define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field ! 120: #endif ! 121: ! 122: static __inline int ! 123: fsfind(const char *name, ino_t * ino) ! 124: { ! 125: char buf[DEV_BSIZE]; ! 126: struct ufs_dirent *d; ! 127: char *s; ! 128: ssize_t n; ! 129: #ifndef UFS2_ONLY ! 130: static struct ufs1_dinode dp1; ! 131: #endif ! 132: #ifndef UFS1_ONLY ! 133: static struct ufs2_dinode dp2; ! 134: #endif ! 135: char* blkbuf = dmadat->blkbuf; ! 136: struct fs* fs = (struct fs *)dmadat->sbbuf; ! 137: ! 138: fs_off = 0; ! 139: while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0) ! 140: for (s = buf; s < buf + DEV_BSIZE;) { ! 141: d = (void *)s; ! 142: if (!strcmp(name, d->d_name)) { ! 143: *ino = d->d_fileno; ! 144: ! 145: /* below is for grub, which wants the file size ! 146: */ ! 147: n = IPERVBLK(fs); ! 148: if (dskread(blkbuf, INO_TO_VBA(fs, n, (*ino)), DBPERVBLK)) ! 149: return -1; ! 150: n = INO_TO_VBO(n, (*ino)); ! 151: #if defined(UFS1_ONLY) ! 152: dp1 = ((struct ufs1_dinode *)blkbuf)[n]; ! 153: #elif defined(UFS2_ONLY) ! 154: dp2 = ((struct ufs2_dinode *)blkbuf)[n]; ! 155: #else ! 156: if (fs->fs_magic == FS_UFS1_MAGIC) ! 157: dp1 = ((struct ufs1_dinode *)blkbuf)[n]; ! 158: else ! 159: dp2 = ((struct ufs2_dinode *)blkbuf)[n]; ! 160: #endif ! 161: ! 162: filemax = DIP(di_size); ! 163: return d->d_type; ! 164: } ! 165: s += d->d_reclen; ! 166: } ! 167: return 0; ! 168: } ! 169: ! 170: ino_t ! 171: lookup(const char *path) ! 172: { ! 173: char name[MAXNAMLEN + 1]; ! 174: const char *s; ! 175: ino_t ino; ! 176: ssize_t n; ! 177: int dt; ! 178: ! 179: ino = ROOTINO; ! 180: dt = DT_DIR; ! 181: name[0] = '/'; ! 182: name[1] = '\0'; ! 183: for (;;) { ! 184: if (*path == '/') ! 185: path++; ! 186: if (!*path) ! 187: break; ! 188: for (s = path; *s && *s != '/'; s++); ! 189: if ((n = s - path) > MAXNAMLEN) ! 190: return 0; ! 191: memcpy(name, path, n); ! 192: name[n] = 0; ! 193: if (dt != DT_DIR) { ! 194: printk("%s: not a directory.\n", name); ! 195: return (0); ! 196: } ! 197: if ((dt = fsfind(name, &ino)) <= 0) ! 198: break; ! 199: path = s; ! 200: } ! 201: return dt == DT_REG ? ino : 0; ! 202: } ! 203: ! 204: /* ! 205: * Possible superblock locations ordered from most to least likely. ! 206: */ ! 207: static const int sblock_try[] = SBLOCKSEARCH; ! 208: ! 209: ssize_t ! 210: fsread(ino_t inode, void *buf, size_t nbyte) ! 211: { ! 212: #ifndef UFS2_ONLY ! 213: static struct ufs1_dinode dp1; ! 214: #endif ! 215: #ifndef UFS1_ONLY ! 216: static struct ufs2_dinode dp2; ! 217: #endif ! 218: static ino_t inomap; ! 219: char *blkbuf; ! 220: void *indbuf; ! 221: struct fs *fs; ! 222: char *s; ! 223: size_t n, nb, size, off, vboff; ! 224: ufs_lbn_t lbn; ! 225: ufs2_daddr_t addr, vbaddr; ! 226: static ufs2_daddr_t blkmap, indmap; ! 227: unsigned int u; ! 228: ! 229: ! 230: blkbuf = dmadat->blkbuf; ! 231: indbuf = dmadat->indbuf; ! 232: fs = (struct fs *)dmadat->sbbuf; ! 233: if (!dsk_meta) { ! 234: inomap = 0; ! 235: for (n = 0; sblock_try[n] != -1; n++) { ! 236: if (dskread(fs, sblock_try[n] / DEV_BSIZE, ! 237: SBLOCKSIZE / DEV_BSIZE)) ! 238: return -1; ! 239: if (( ! 240: #if defined(UFS1_ONLY) ! 241: fs->fs_magic == FS_UFS1_MAGIC ! 242: #elif defined(UFS2_ONLY) ! 243: (fs->fs_magic == FS_UFS2_MAGIC && ! 244: fs->fs_sblockloc == sblock_try[n]) ! 245: #else ! 246: fs->fs_magic == FS_UFS1_MAGIC || ! 247: (fs->fs_magic == FS_UFS2_MAGIC && ! 248: fs->fs_sblockloc == sblock_try[n]) ! 249: #endif ! 250: ) && ! 251: fs->fs_bsize <= MAXBSIZE && ! 252: fs->fs_bsize >= sizeof(struct fs)) ! 253: break; ! 254: } ! 255: if (sblock_try[n] == -1) { ! 256: printk("Not ufs\n"); ! 257: return -1; ! 258: } ! 259: dsk_meta++; ! 260: } ! 261: if (!inode) ! 262: return 0; ! 263: if (inomap != inode) { ! 264: n = IPERVBLK(fs); ! 265: if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK)) ! 266: return -1; ! 267: n = INO_TO_VBO(n, inode); ! 268: #if defined(UFS1_ONLY) ! 269: dp1 = ((struct ufs1_dinode *)blkbuf)[n]; ! 270: #elif defined(UFS2_ONLY) ! 271: dp2 = ((struct ufs2_dinode *)blkbuf)[n]; ! 272: #else ! 273: if (fs->fs_magic == FS_UFS1_MAGIC) ! 274: dp1 = ((struct ufs1_dinode *)blkbuf)[n]; ! 275: else ! 276: dp2 = ((struct ufs2_dinode *)blkbuf)[n]; ! 277: #endif ! 278: inomap = inode; ! 279: fs_off = 0; ! 280: blkmap = indmap = 0; ! 281: } ! 282: s = buf; ! 283: size = DIP(di_size); ! 284: n = size - fs_off; ! 285: if (nbyte > n) ! 286: nbyte = n; ! 287: nb = nbyte; ! 288: while (nb) { ! 289: lbn = lblkno(fs, fs_off); ! 290: off = blkoff(fs, fs_off); ! 291: if (lbn < NDADDR) { ! 292: addr = DIP(di_db[lbn]); ! 293: } else if (lbn < NDADDR + NINDIR(fs)) { ! 294: n = INDIRPERVBLK(fs); ! 295: addr = DIP(di_ib[0]); ! 296: u = (unsigned int)(lbn - NDADDR) / (n * DBPERVBLK); ! 297: vbaddr = fsbtodb(fs, addr) + u; ! 298: if (indmap != vbaddr) { ! 299: if (dskread(indbuf, vbaddr, DBPERVBLK)) ! 300: return -1; ! 301: indmap = vbaddr; ! 302: } ! 303: n = (lbn - NDADDR) & (n - 1); ! 304: #if defined(UFS1_ONLY) ! 305: addr = ((ufs1_daddr_t *)indbuf)[n]; ! 306: #elif defined(UFS2_ONLY) ! 307: addr = ((ufs2_daddr_t *)indbuf)[n]; ! 308: #else ! 309: if (fs->fs_magic == FS_UFS1_MAGIC) ! 310: addr = ((ufs1_daddr_t *)indbuf)[n]; ! 311: else ! 312: addr = ((ufs2_daddr_t *)indbuf)[n]; ! 313: #endif ! 314: } else { ! 315: return -1; ! 316: } ! 317: vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK; ! 318: vboff = off & VBLKMASK; ! 319: n = sblksize(fs, size, lbn) - (off & ~VBLKMASK); ! 320: if (n > VBLKSIZE) ! 321: n = VBLKSIZE; ! 322: if (blkmap != vbaddr) { ! 323: if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) ! 324: return -1; ! 325: blkmap = vbaddr; ! 326: } ! 327: n -= vboff; ! 328: if (n > nb) ! 329: n = nb; ! 330: memcpy(s, blkbuf + vboff, n); ! 331: s += n; ! 332: fs_off += n; ! 333: nb -= n; ! 334: } ! 335: return nbyte; ! 336: } ! 337: ! 338: int ! 339: ufs_mount (void) ! 340: { ! 341: int i, retval = 0; ! 342: ! 343: /* ! 344: * We don't care about stuff being in disklabels or not. If the magic ! 345: * matches, we're good to go. ! 346: */ ! 347: for (i = 0; sblock_try[i] != -1; ++i) ! 348: { ! 349: if (! (part_length < (sblock_try[i] + (SBLOCKSIZE / DEV_BSIZE)) ! 350: || ! devread (0, sblock_try[i], SBLOCKSIZE, (char *) SUPERBLOCK))) ! 351: { ! 352: if ( ! 353: #if defined(UFS1_ONLY) ! 354: SUPERBLOCK->fs_magic == FS_UFS1_MAGIC ! 355: #elif defined(UFS2_ONLY) ! 356: (SUPERBLOCK->fs_magic == FS_UFS2_MAGIC && ! 357: SUPERBLOCK->fs_sblockloc == sblock_try[i]) ! 358: #else ! 359: SUPERBLOCK->fs_magic == FS_UFS1_MAGIC || ! 360: (SUPERBLOCK->fs_magic == FS_UFS2_MAGIC && ! 361: SUPERBLOCK->fs_sblockloc == sblock_try[i]) ! 362: #endif ! 363: ) { ! 364: retval = 1; break; ! 365: } ! 366: } ! 367: } ! 368: return retval; ! 369: } ! 370: ! 371: int ! 372: ufs_read (char *buf, int len) ! 373: { ! 374: return fsread(cur_ino, buf, len); ! 375: } ! 376: ! 377: int ! 378: ufs_dir (char *dirname) ! 379: { ! 380: cur_ino = lookup(dirname); ! 381: return cur_ino & 0xffffffff; ! 382: } ! 383: ! 384: int ! 385: ufs_embed (int* start_sector, int needed_sectors) ! 386: { ! 387: /* TODO; unused by Cromwell */ ! 388: return 0; ! 389: } ! 390: ! 391: #endif /* FSYS_UFS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.