qemu/roms/openbios/fs/grubfs/fsys_minix.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 1999,2000,2001,2002  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 /* Restrictions:
  22    This is MINIX V1 only (yet)
  23    Disk creation is like:
  24    mkfs.minix -c DEVICE
  25 */
  26
  27 #ifdef FSYS_MINIX
  28
  29 #include "shared.h"
  30 #include "filesys.h"
  31
  32 /* #define DEBUG_MINIX */
  33
  34 /* indirect blocks */
  35 static int mapblock1, mapblock2, namelen;
  36
  37 /* sizes are always in bytes, BLOCK values are always in DEV_BSIZE (sectors) */
  38 #define DEV_BSIZE 512
  39
  40 /* include/linux/fs.h */
  41 #define BLOCK_SIZE_BITS 10
  42 #define BLOCK_SIZE      (1<<BLOCK_SIZE_BITS)
  43
  44 /* made up, defaults to 1 but can be passed via mount_opts */
  45 #define WHICH_SUPER 1
  46 /* kind of from fs/ext2/super.c (is OK for minix) */
  47 #define SBLOCK (WHICH_SUPER * BLOCK_SIZE / DEV_BSIZE)   /* = 2 */
  48
  49 /* include/asm-i386/type.h */
  50 typedef __signed__ char __s8;
  51 typedef unsigned char __u8;
  52 typedef __signed__ short __s16;
  53 typedef unsigned short __u16;
  54 typedef __signed__ int __s32;
  55 typedef unsigned int __u32;
  56
  57 /* include/linux/minix_fs.h */
  58 #define MINIX_ROOT_INO 1
  59
  60 /* Not the same as the bogus LINK_MAX in <linux/limits.h>. Oh well. */
  61 #define MINIX_LINK_MAX  250
  62 #define MINIX2_LINK_MAX 65530
  63
  64 #define MINIX_I_MAP_SLOTS       8
  65 #define MINIX_Z_MAP_SLOTS       64
  66 #define MINIX_SUPER_MAGIC       0x137F          /* original minix fs */
  67 #define MINIX_SUPER_MAGIC2      0x138F          /* minix fs, 30 char names */
  68 #define MINIX2_SUPER_MAGIC      0x2468          /* minix V2 fs */
  69 #define MINIX2_SUPER_MAGIC2     0x2478          /* minix V2 fs, 30 char names */
  70 #define MINIX_VALID_FS          0x0001          /* Clean fs. */
  71 #define MINIX_ERROR_FS          0x0002          /* fs has errors. */
  72
  73 #define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
  74 #define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
  75
  76 #define MINIX_V1                0x0001          /* original minix fs */
  77 #define MINIX_V2                0x0002          /* minix V2 fs */
  78
  79 /* originally this is :
  80 #define INODE_VERSION(inode)    inode->i_sb->u.minix_sb.s_version
  81    here we have */
  82 #define INODE_VERSION(inode)    (SUPERBLOCK->s_version)
  83
  84 /*
  85  * This is the original minix inode layout on disk.
  86  * Note the 8-bit gid and atime and ctime.
  87  */
  88 struct minix_inode {
  89         __u16 i_mode;
  90         __u16 i_uid;
  91         __u32 i_size;
  92         __u32 i_time;
  93         __u8  i_gid;
  94         __u8  i_nlinks;
  95         __u16 i_zone[9];
  96 };
  97
  98 /*
  99  * The new minix inode has all the time entries, as well as
 100  * long block numbers and a third indirect block (7+1+1+1
 101  * instead of 7+1+1). Also, some previously 8-bit values are
 102  * now 16-bit. The inode is now 64 bytes instead of 32.
 103  */
 104 struct minix2_inode {
 105         __u16 i_mode;
 106         __u16 i_nlinks;
 107         __u16 i_uid;
 108         __u16 i_gid;
 109         __u32 i_size;
 110         __u32 i_atime;
 111         __u32 i_mtime;
 112         __u32 i_ctime;
 113         __u32 i_zone[10];
 114 };
 115
 116 /*
 117  * minix super-block data on disk
 118  */
 119 struct minix_super_block {
 120         __u16 s_ninodes;
 121         __u16 s_nzones;
 122         __u16 s_imap_blocks;
 123         __u16 s_zmap_blocks;
 124         __u16 s_firstdatazone;
 125         __u16 s_log_zone_size;
 126         __u32 s_max_size;
 127         __u16 s_magic;
 128         __u16 s_state;
 129         __u32 s_zones;
 130 };
 131
 132 struct minix_dir_entry {
 133         __u16 inode;
 134         char name[0];
 135 };
 136
 137 /* made up, these are pointers into FSYS_BUF */
 138 /* read once, always stays there: */
 139 #define SUPERBLOCK \
 140     ((struct minix_super_block *)(FSYS_BUF))
 141 #define INODE \
 142     ((struct minix_inode *)((char *) SUPERBLOCK + BLOCK_SIZE))
 143 #define DATABLOCK1 \
 144     ((char *)((char *)INODE + sizeof(struct minix_inode)))
 145 #define DATABLOCK2 \
 146     ((char *)((char *)DATABLOCK1 + BLOCK_SIZE))
 147
 148 /* linux/stat.h */
 149 #define S_IFMT  00170000
 150 #define S_IFLNK  0120000
 151 #define S_IFREG  0100000
 152 #define S_IFDIR  0040000
 153 #define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)
 154 #define S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)
 155 #define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)
 156
 157 #define PATH_MAX                1024    /* include/linux/limits.h */
 158 #define MAX_LINK_COUNT             5    /* number of symbolic links to follow */
 159
 160 /* check filesystem types and read superblock into memory buffer */
 161 int
 162 minix_mount (void)
 163 {
 164   if (((current_drive & 0x80) || current_slice != 0)
 165       && ! IS_PC_SLICE_TYPE_MINIX (current_slice)
 166       && ! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_OTHER))
 167     return 0;                   /* The partition is not of MINIX type */
 168
 169   if (part_length < (SBLOCK +
 170                      (sizeof (struct minix_super_block) / DEV_BSIZE)))
 171     return 0;                   /* The partition is too short */
 172
 173   if (!devread (SBLOCK, 0, sizeof (struct minix_super_block),
 174                 (char *) SUPERBLOCK))
 175     return 0;                   /* Cannot read superblock */
 176
 177   switch (SUPERBLOCK->s_magic)
 178     {
 179     case MINIX_SUPER_MAGIC:
 180       namelen = 14;
 181       break;
 182     case MINIX_SUPER_MAGIC2:
 183       namelen = 30;
 184       break;
 185     default:
 186       return 0;                 /* Unsupported type */
 187     }
 188
 189   return 1;
 190 }
 191
 192 /* Takes a file system block number and reads it into BUFFER. */
 193 static int
 194 minix_rdfsb (int fsblock, char *buffer)
 195 {
 196   return devread (fsblock * (BLOCK_SIZE / DEV_BSIZE), 0,
 197                   BLOCK_SIZE, buffer);
 198 }
 199
 200 /* Maps LOGICAL_BLOCK (the file offset divided by the blocksize) into
 201    a physical block (the location in the file system) via an inode. */
 202 static int
 203 minix_block_map (int logical_block)
 204 {
 205   int i;
 206
 207   if (logical_block < 7)
 208     return INODE->i_zone[logical_block];
 209
 210   logical_block -= 7;
 211   if (logical_block < 512)
 212     {
 213       i = INODE->i_zone[7];
 214
 215       if (!i || ((mapblock1 != 1)
 216                  && !minix_rdfsb (i, DATABLOCK1)))
 217         {
 218           errnum = ERR_FSYS_CORRUPT;
 219           return -1;
 220         }
 221       mapblock1 = 1;
 222       return ((__u16 *) DATABLOCK1) [logical_block];
 223     }
 224
 225   logical_block -= 512;
 226   i = INODE->i_zone[8];
 227   if (!i || ((mapblock1 != 2)
 228              && !minix_rdfsb (i, DATABLOCK1)))
 229     {
 230       errnum = ERR_FSYS_CORRUPT;
 231       return -1;
 232     }
 233   mapblock1 = 2;
 234   i = ((__u16 *) DATABLOCK1)[logical_block >> 9];
 235   if (!i || ((mapblock2 != i)
 236              && !minix_rdfsb (i, DATABLOCK2)))
 237     {
 238       errnum = ERR_FSYS_CORRUPT;
 239       return -1;
 240     }
 241   mapblock2 = i;
 242   return ((__u16 *) DATABLOCK2)[logical_block & 511];
 243 }
 244
 245 /* read from INODE into BUF */
 246 int
 247 minix_read (char *buf, int len)
 248 {
 249   int logical_block;
 250   int offset;
 251   int map;
 252   int ret = 0;
 253   int size = 0;
 254
 255   while (len > 0)
 256     {
 257       /* find the (logical) block component of our location */
 258       logical_block = filepos >> BLOCK_SIZE_BITS;
 259       offset = filepos & (BLOCK_SIZE - 1);
 260       map = minix_block_map (logical_block);
 261 #ifdef DEBUG_MINIX
 262       printf ("map=%d\n", map);
 263 #endif
 264       if (map < 0)
 265         break;
 266
 267       size = BLOCK_SIZE;
 268       size -= offset;
 269       if (size > len)
 270         size = len;
 271
 272       disk_read_func = disk_read_hook;
 273
 274       devread (map * (BLOCK_SIZE / DEV_BSIZE),
 275                offset, size, buf);
 276
 277       disk_read_func = NULL;
 278
 279       buf += size;
 280       len -= size;
 281       filepos += size;
 282       ret += size;
 283     }
 284
 285   if (errnum)
 286     ret = 0;
 287
 288   return ret;
 289 }
 290
 291 /* preconditions: minix_mount already executed, therefore supblk in buffer
 292      known as SUPERBLOCK
 293    returns: 0 if error, nonzero iff we were able to find the file successfully
 294    postconditions: on a nonzero return, buffer known as INODE contains the
 295      inode of the file we were trying to look up
 296    side effects: none yet  */
 297 int
 298 minix_dir (char *dirname)
 299 {
 300   int current_ino = MINIX_ROOT_INO;  /* start at the root */
 301   int updir_ino = current_ino;       /* the parent of the current directory */
 302   int ino_blk;                       /* fs pointer of the inode's info */
 303
 304   int str_chk = 0;                   /* used ot hold the results of a string
 305                                         compare */
 306
 307   struct minix_inode * raw_inode;    /* inode info for current_ino */
 308
 309   char linkbuf[PATH_MAX];            /* buffer for following sym-links */
 310   int link_count = 0;
 311
 312   char * rest;
 313   char ch;
 314
 315   int off;                           /* offset within block of directory
 316                                         entry */
 317   int loc;                           /* location within a directory */
 318   int blk;                           /* which data blk within dir entry */
 319   long map;                          /* fs pointer of a particular block from
 320                                         dir entry */
 321   struct minix_dir_entry * dp;       /* pointer to directory entry */
 322
 323   /* loop invariants:
 324      current_ino = inode to lookup
 325      dirname = pointer to filename component we are cur looking up within
 326      the directory known pointed to by current_ino (if any) */
 327
 328 #ifdef DEBUG_MINIX
 329   printf ("\n");
 330 #endif
 331
 332   while (1)
 333     {
 334 #ifdef DEBUG_MINIX
 335       printf ("inode %d, dirname %s\n", current_ino, dirname);
 336 #endif
 337
 338       ino_blk = (2 + SUPERBLOCK->s_imap_blocks + SUPERBLOCK->s_zmap_blocks
 339                  + (current_ino - 1) / MINIX_INODES_PER_BLOCK);
 340       if (! minix_rdfsb (ino_blk, (char *) INODE))
 341         return 0;
 342
 343       /* reset indirect blocks! */
 344       mapblock2 = mapblock1 = -1;
 345
 346       raw_inode = INODE + ((current_ino - 1) % MINIX_INODES_PER_BLOCK);
 347
 348       /* copy inode to fixed location */
 349       memmove ((void *) INODE, (void *) raw_inode,
 350                sizeof (struct minix_inode));
 351
 352       /* If we've got a symbolic link, then chase it. */
 353       if (S_ISLNK (INODE->i_mode))
 354         {
 355           int len;
 356
 357           if (++link_count > MAX_LINK_COUNT)
 358             {
 359               errnum = ERR_SYMLINK_LOOP;
 360               return 0;
 361             }
 362 #ifdef DEBUG_MINIX
 363           printf ("S_ISLNK (%s)\n", dirname);
 364 #endif
 365
 366           /* Find out how long our remaining name is. */
 367           len = 0;
 368           while (dirname[len] && !isspace (dirname[len]))
 369             len++;
 370
 371           /* Get the symlink size. */
 372           filemax = (INODE->i_size);
 373           if (filemax + len > sizeof (linkbuf) - 2)
 374             {
 375               errnum = ERR_FILELENGTH;
 376               return 0;
 377             }
 378
 379           if (len)
 380             {
 381               /* Copy the remaining name to the end of the symlink data.
 382                  Note that DIRNAME and LINKBUF may overlap! */
 383               memmove (linkbuf + filemax, dirname, len);
 384             }
 385           linkbuf[filemax + len] = '\0';
 386
 387           /* Read the necessary blocks, and reset the file pointer. */
 388           len = grub_read (linkbuf, filemax);
 389           filepos = 0;
 390           if (!len)
 391             return 0;
 392
 393 #ifdef DEBUG_MINIX
 394           printf ("symlink=%s\n", linkbuf);
 395 #endif
 396
 397           dirname = linkbuf;
 398           if (*dirname == '/')
 399             {
 400               /* It's an absolute link, so look it up in root. */
 401               current_ino = MINIX_ROOT_INO;
 402               updir_ino = current_ino;
 403             }
 404           else
 405             {
 406               /* Relative, so look it up in our parent directory. */
 407               current_ino = updir_ino;
 408             }
 409
 410           /* Try again using the new name. */
 411           continue;
 412         }
 413
 414       /* If end of filename, INODE points to the file's inode */
 415       if (!*dirname || isspace (*dirname))
 416         {
 417           if (!S_ISREG (INODE->i_mode))
 418             {
 419               errnum = ERR_BAD_FILETYPE;
 420               return 0;
 421             }
 422
 423           filemax = (INODE->i_size);
 424           return 1;
 425         }
 426
 427       /* else we have to traverse a directory */
 428       updir_ino = current_ino;
 429
 430       /* skip over slashes */
 431       while (*dirname == '/')
 432         dirname++;
 433
 434       /* if this isn't a directory of sufficient size to hold our file,
 435          abort */
 436       if (!(INODE->i_size) || !S_ISDIR (INODE->i_mode))
 437         {
 438           errnum = ERR_BAD_FILETYPE;
 439           return 0;
 440         }
 441
 442       /* skip to next slash or end of filename (space) */
 443       for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/';
 444            rest++);
 445
 446       /* look through this directory and find the next filename component */
 447       /* invariant: rest points to slash after the next filename component */
 448       *rest = 0;
 449       loc = 0;
 450
 451       do
 452         {
 453 #ifdef DEBUG_MINIX
 454           printf ("dirname=`%s', rest=`%s', loc=%d\n", dirname, rest, loc);
 455 #endif
 456
 457           /* if our location/byte offset into the directory exceeds the size,
 458              give up */
 459           if (loc >= INODE->i_size)
 460             {
 461               if (print_possibilities < 0)
 462                 {
 463 #if 0
 464                   putchar ('\n');
 465 #endif
 466                 }
 467               else
 468                 {
 469                   errnum = ERR_FILE_NOT_FOUND;
 470                   *rest = ch;
 471                 }
 472               return (print_possibilities < 0);
 473             }
 474
 475           /* else, find the (logical) block component of our location */
 476           blk = loc >> BLOCK_SIZE_BITS;
 477
 478           /* we know which logical block of the directory entry we are looking
 479              for, now we have to translate that to the physical (fs) block on
 480              the disk */
 481           map = minix_block_map (blk);
 482 #ifdef DEBUG_MINIX
 483           printf ("fs block=%d\n", map);
 484 #endif
 485           mapblock2 = -1;
 486           if ((map < 0) || !minix_rdfsb (map, DATABLOCK2))
 487             {
 488               errnum = ERR_FSYS_CORRUPT;
 489               *rest = ch;
 490               return 0;
 491             }
 492           off = loc & (BLOCK_SIZE - 1);
 493           dp = (struct minix_dir_entry *) (DATABLOCK2 + off);
 494           /* advance loc prematurely to next on-disk directory entry  */
 495           loc += sizeof (dp->inode) + namelen;
 496
 497           /* NOTE: minix filenames are NULL terminated if < NAMELEN
 498              else exact */
 499
 500 #ifdef DEBUG_MINIX
 501           printf ("directory entry ino=%d\n", dp->inode);
 502           if (dp->inode)
 503             printf ("entry=%s\n", dp->name);
 504 #endif
 505
 506           if (dp->inode)
 507             {
 508               int saved_c = dp->name[namelen];
 509
 510               dp->name[namelen] = 0;
 511               str_chk = substring (dirname, dp->name);
 512
 513 # ifndef STAGE1_5
 514               if (print_possibilities && ch != '/'
 515                   && (!*dirname || str_chk <= 0))
 516                 {
 517                   if (print_possibilities > 0)
 518                     print_possibilities = -print_possibilities;
 519                   print_a_completion (dp->name);
 520                 }
 521 # endif
 522
 523               dp->name[namelen] = saved_c;
 524             }
 525
 526         }
 527       while (!dp->inode || (str_chk || (print_possibilities && ch != '/')));
 528
 529       current_ino = dp->inode;
 530       *(dirname = rest) = ch;
 531     }
 532   /* never get here */
 533 }
 534
 535 #endif /* FSYS_MINIX */