Return to fsys_ffs.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs

Annotation of qemu/roms/openbios/fs/grubfs/fsys_ffs.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *  GRUB  --  GRand Unified Bootloader
        !             3:  *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
        !             4:  *
        !             5:  *  This program is free software; you can redistribute it and/or modify
        !             6:  *  it under the terms of the GNU General Public License as published by
        !             7:  *  the Free Software Foundation; either version 2 of the License, or
        !             8:  *  (at your option) any later version.
        !             9:  *
        !            10:  *  This program is distributed in the hope that it will be useful,
        !            11:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13:  *  GNU General Public License for more details.
        !            14:  *
        !            15:  *  You should have received a copy of the GNU General Public License
        !            16:  *  along with this program; if not, write to the Free Software
        !            17:  *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
        !            18:  *  MA 02110-1301, USA.
        !            19:  */
        !            20: 
        !            21: /*
        !            22:  * Elements of this file were originally from the FreeBSD "biosboot"
        !            23:  * bootloader file "disk.c" dated 4/12/95.
        !            24:  *
        !            25:  * The license and header comments from that file are included here.
        !            26:  */
        !            27: 
        !            28: /*
        !            29:  * Mach Operating System
        !            30:  * Copyright (c) 1992, 1991 Carnegie Mellon University
        !            31:  * All Rights Reserved.
        !            32:  *
        !            33:  * Permission to use, copy, modify and distribute this software and its
        !            34:  * documentation is hereby granted, provided that both the copyright
        !            35:  * notice and this permission notice appear in all copies of the
        !            36:  * software, derivative works or modified versions, and any portions
        !            37:  * thereof, and that both notices appear in supporting documentation.
        !            38:  *
        !            39:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            40:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            41:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            42:  *
        !            43:  * Carnegie Mellon requests users of this software to return to
        !            44:  *
        !            45:  *  Software Distribution Coordinator  or  [email protected]
        !            46:  *  School of Computer Science
        !            47:  *  Carnegie Mellon University
        !            48:  *  Pittsburgh PA 15213-3890
        !            49:  *
        !            50:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            51:  * the rights to redistribute these changes.
        !            52:  *
        !            53:  *     from: Mach, Revision 2.2  92/04/04  11:35:49  rpd
        !            54:  *     $Id: fsys_ffs.c,v 1.10 2001/11/12 06:57:29 okuji Exp $
        !            55:  */
        !            56: 
        !            57: #ifdef FSYS_FFS
        !            58: 
        !            59: #include "shared.h"
        !            60: 
        !            61: #include "filesys.h"
        !            62: 
        !            63: #include "defs.h"
        !            64: #include "disk_inode.h"
        !            65: #include "disk_inode_ffs.h"
        !            66: #include "dir.h"
        !            67: #include "fs.h"
        !            68: 
        !            69: /* used for filesystem map blocks */
        !            70: static int mapblock;
        !            71: static int mapblock_offset;
        !            72: static int mapblock_bsize;
        !            73: 
        !            74: /* pointer to superblock */
        !            75: #define SUPERBLOCK ((struct fs *) ( FSYS_BUF + 8192 ))
        !            76: #define INODE ((struct icommon *) ( FSYS_BUF + 16384 ))
        !            77: #define MAPBUF ( FSYS_BUF + 24576 )
        !            78: #define MAPBUF_LEN 8192
        !            79: 
        !            80: 
        !            81: int
        !            82: ffs_mount (void)
        !            83: {
        !            84:   int retval = 1;
        !            85: 
        !            86:   if ((((current_drive & 0x80) || (current_slice != 0))
        !            87:        && ! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_BSDFFS))
        !            88:       || part_length < (SBLOCK + (SBSIZE / DEV_BSIZE))
        !            89:       || !devread (SBLOCK, 0, SBSIZE, (char *) SUPERBLOCK)
        !            90:       || SUPERBLOCK->fs_magic != FS_MAGIC)
        !            91:     retval = 0;
        !            92: 
        !            93:   mapblock = -1;
        !            94:   mapblock_offset = -1;
        !            95: 
        !            96:   return retval;
        !            97: }
        !            98: 
        !            99: static int
        !           100: block_map (int file_block)
        !           101: {
        !           102:   int bnum, offset, bsize;
        !           103: 
        !           104:   if (file_block < NDADDR)
        !           105:     return (INODE->i_db[file_block]);
        !           106: 
        !           107:   /* If the blockmap loaded does not include FILE_BLOCK,
        !           108:      load a new blockmap.  */
        !           109:   if ((bnum = fsbtodb (SUPERBLOCK, INODE->i_ib[0])) != mapblock
        !           110:       || (mapblock_offset <= bnum && bnum <= mapblock_offset + mapblock_bsize))
        !           111:     {
        !           112:       if (MAPBUF_LEN < SUPERBLOCK->fs_bsize)
        !           113:        {
        !           114:          offset = ((file_block - NDADDR) % NINDIR (SUPERBLOCK));
        !           115:          bsize = MAPBUF_LEN;
        !           116: 
        !           117:          if (offset + MAPBUF_LEN > SUPERBLOCK->fs_bsize)
        !           118:            offset = (SUPERBLOCK->fs_bsize - MAPBUF_LEN) / sizeof (int);
        !           119:        }
        !           120:       else
        !           121:        {
        !           122:          bsize = SUPERBLOCK->fs_bsize;
        !           123:          offset = 0;
        !           124:        }
        !           125: 
        !           126:       if (! devread (bnum, offset * sizeof (int), bsize, (char *) MAPBUF))
        !           127:        {
        !           128:          mapblock = -1;
        !           129:          mapblock_bsize = -1;
        !           130:          mapblock_offset = -1;
        !           131:          errnum = ERR_FSYS_CORRUPT;
        !           132:          return -1;
        !           133:        }
        !           134: 
        !           135:       mapblock = bnum;
        !           136:       mapblock_bsize = bsize;
        !           137:       mapblock_offset = offset;
        !           138:     }
        !           139: 
        !           140:   return (((int *) MAPBUF)[((file_block - NDADDR) % NINDIR (SUPERBLOCK))
        !           141:                          - mapblock_offset]);
        !           142: }
        !           143: 
        !           144: 
        !           145: int
        !           146: ffs_read (char *buf, int len)
        !           147: {
        !           148:   int logno, off, size, map, ret = 0;
        !           149: 
        !           150:   while (len && !errnum)
        !           151:     {
        !           152:       off = blkoff (SUPERBLOCK, filepos);
        !           153:       logno = lblkno (SUPERBLOCK, filepos);
        !           154:       size = blksize (SUPERBLOCK, INODE, logno);
        !           155: 
        !           156:       if ((map = block_map (logno)) < 0)
        !           157:        break;
        !           158: 
        !           159:       size -= off;
        !           160: 
        !           161:       if (size > len)
        !           162:        size = len;
        !           163: 
        !           164:       disk_read_func = disk_read_hook;
        !           165: 
        !           166:       devread (fsbtodb (SUPERBLOCK, map), off, size, buf);
        !           167: 
        !           168:       disk_read_func = NULL;
        !           169: 
        !           170:       buf += size;
        !           171:       len -= size;
        !           172:       filepos += size;
        !           173:       ret += size;
        !           174:     }
        !           175: 
        !           176:   if (errnum)
        !           177:     ret = 0;
        !           178: 
        !           179:   return ret;
        !           180: }
        !           181: 
        !           182: 
        !           183: int
        !           184: ffs_dir (char *dirname)
        !           185: {
        !           186:   char *rest, ch;
        !           187:   int block, off, loc, map, ino = ROOTINO;
        !           188:   struct direct *dp;
        !           189: 
        !           190: /* main loop to find destination inode */
        !           191: loop:
        !           192: 
        !           193:   /* load current inode (defaults to the root inode) */
        !           194: 
        !           195:        if (!devread (fsbtodb (SUPERBLOCK, itod (SUPERBLOCK, ino)),
        !           196:                                                                ino % (SUPERBLOCK->fs_inopb) * sizeof (struct dinode),
        !           197:                                                                sizeof (struct dinode), (char *) INODE))
        !           198:                        return 0;                       /* XXX what return value? */
        !           199: 
        !           200:   /* if we have a real file (and we're not just printing possibilities),
        !           201:      then this is where we want to exit */
        !           202: 
        !           203:   if (!*dirname || isspace (*dirname))
        !           204:     {
        !           205:       if ((INODE->i_mode & IFMT) != IFREG)
        !           206:        {
        !           207:          errnum = ERR_BAD_FILETYPE;
        !           208:          return 0;
        !           209:        }
        !           210: 
        !           211:       filemax = INODE->i_size;
        !           212: 
        !           213:       /* incomplete implementation requires this! */
        !           214:       fsmax = (NDADDR + NINDIR (SUPERBLOCK)) * SUPERBLOCK->fs_bsize;
        !           215:       return 1;
        !           216:     }
        !           217: 
        !           218:   /* continue with file/directory name interpretation */
        !           219: 
        !           220:   while (*dirname == '/')
        !           221:     dirname++;
        !           222: 
        !           223:   if (!(INODE->i_size) || ((INODE->i_mode & IFMT) != IFDIR))
        !           224:     {
        !           225:       errnum = ERR_BAD_FILETYPE;
        !           226:       return 0;
        !           227:     }
        !           228: 
        !           229:   for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
        !           230: 
        !           231:   *rest = 0;
        !           232:   loc = 0;
        !           233: 
        !           234:   /* loop for reading a the entries in a directory */
        !           235: 
        !           236:   do
        !           237:     {
        !           238:       if (loc >= INODE->i_size)
        !           239:        {
        !           240: #if 0
        !           241:          putchar ('\n');
        !           242: #endif
        !           243: 
        !           244:          if (print_possibilities < 0)
        !           245:            return 1;
        !           246: 
        !           247:          errnum = ERR_FILE_NOT_FOUND;
        !           248:          *rest = ch;
        !           249:          return 0;
        !           250:        }
        !           251: 
        !           252:       if (!(off = blkoff (SUPERBLOCK, loc)))
        !           253:        {
        !           254:          block = lblkno (SUPERBLOCK, loc);
        !           255: 
        !           256:          if ((map = block_map (block)) < 0
        !           257:              || !devread (fsbtodb (SUPERBLOCK, map), 0,
        !           258:                           blksize (SUPERBLOCK, INODE, block),
        !           259:                           (char *) FSYS_BUF))
        !           260:            {
        !           261:              errnum = ERR_FSYS_CORRUPT;
        !           262:              *rest = ch;
        !           263:              return 0;
        !           264:            }
        !           265:        }
        !           266: 
        !           267:       dp = (struct direct *) (FSYS_BUF + off);
        !           268:       loc += dp->d_reclen;
        !           269: 
        !           270: #ifndef STAGE1_5
        !           271:       if (dp->d_ino && print_possibilities && ch != '/'
        !           272:          && (!*dirname || substring (dirname, dp->d_name) <= 0))
        !           273:        {
        !           274:          if (print_possibilities > 0)
        !           275:            print_possibilities = -print_possibilities;
        !           276: 
        !           277:          print_a_completion (dp->d_name);
        !           278:        }
        !           279: #endif /* STAGE1_5 */
        !           280:     }
        !           281:   while (!dp->d_ino || (substring (dirname, dp->d_name) != 0
        !           282:                        || (print_possibilities && ch != '/')));
        !           283: 
        !           284:   /* only get here if we have a matching directory entry */
        !           285: 
        !           286:   ino = dp->d_ino;
        !           287:   *(dirname = rest) = ch;
        !           288: 
        !           289:   /* go back to main loop at top of function */
        !           290:   goto loop;
        !           291: }
        !           292: 
        !           293: int
        !           294: ffs_embed (int *start_sector, int needed_sectors)
        !           295: {
        !           296:   /* XXX: I don't know if this is really correct. Someone who is
        !           297:      familiar with BSD should check for this.  */
        !           298:   if (needed_sectors > 14)
        !           299:     return 0;
        !           300: 
        !           301:   *start_sector = 1;
        !           302: #if 1
        !           303:   /* FIXME: Disable the embedding in FFS until someone checks if
        !           304:      the code above is correct.  */
        !           305:   return 0;
        !           306: #else
        !           307:   return 1;
        !           308: #endif
        !           309: }
        !           310: 
        !           311: #endif /* FSYS_FFS */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.