fs/jfs.c

   1 /* jfs.c - JFS.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2004,2005,2006,2007,2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/err.h>
  21 #include <grub/file.h>
  22 #include <grub/mm.h>
  23 #include <grub/misc.h>
  24 #include <grub/disk.h>
  25 #include <grub/dl.h>
  26 #include <grub/types.h>
  27
  28 #define GRUB_JFS_MAX_SYMLNK_CNT 8
  29 #define GRUB_JFS_FILETYPE_MASK  0170000
  30 #define GRUB_JFS_FILETYPE_REG   0100000
  31 #define GRUB_JFS_FILETYPE_LNK   0120000
  32 #define GRUB_JFS_FILETYPE_DIR   0040000
  33
  34 #define GRUB_JFS_SBLOCK         64
  35 #define GRUB_JFS_AGGR_INODE     2
  36 #define GRUB_JFS_FS1_INODE_BLK  104
  37
  38 #define GRUB_JFS_TREE_LEAF      2
  39
  40 struct grub_jfs_sblock
  41 {
  42   /* The magic for JFS.  It should contain the string "JFS1".  */
  43   grub_uint8_t magic[4];
  44   grub_uint32_t version;
  45   grub_uint64_t ag_size;
  46
  47   /* The size of a filesystem block in bytes.  XXX: currently only
  48      4096 was tested.  */
  49   grub_uint32_t blksz;
  50   grub_uint16_t log2_blksz;
  51
  52   grub_uint8_t unused[71];
  53   grub_uint8_t volname[11];
  54 };
  55
  56 struct grub_jfs_extent
  57 {
  58   /* The length of the extent in filesystem blocks.  */
  59   grub_uint16_t length;
  60   grub_uint8_t length2;
  61
  62   /* The physical offset of the first block on the disk.  */
  63   grub_uint8_t blk1;
  64   grub_uint32_t blk2;
  65 } __attribute__ ((packed));
  66
  67 struct grub_jfs_iag
  68 {
  69   grub_uint8_t unused[3072];
  70   struct grub_jfs_extent inodes[128];
  71 } __attribute__ ((packed));
  72
  73
  74 /* The head of the tree used to find extents.  */
  75 struct grub_jfs_treehead
  76 {
  77   grub_uint64_t next;
  78   grub_uint64_t prev;
  79
  80   grub_uint8_t flags;
  81   grub_uint8_t unused;
  82
  83   grub_uint16_t count;
  84   grub_uint16_t max;
  85   grub_uint8_t unused2[10];
  86 } __attribute__ ((packed));
  87
  88 /* A node in the extent tree.  */
  89 struct grub_jfs_tree_extent
  90 {
  91   grub_uint8_t flags;
  92   grub_uint16_t unused;
  93
  94   /* The offset is the key used to lookup an extent.  */
  95   grub_uint8_t offset1;
  96   grub_uint32_t offset2;
  97
  98   struct grub_jfs_extent extent;
  99 } __attribute__ ((packed));
 100
 101 /* The tree of directory entries.  */
 102 struct grub_jfs_tree_dir
 103 {
 104   /* Pointers to the previous and next tree headers of other nodes on
 105      this level.  */
 106   grub_uint64_t nextb;
 107   grub_uint64_t prevb;
 108
 109   grub_uint8_t flags;
 110
 111   /* The amount of dirents in this node.  */
 112   grub_uint8_t count;
 113   grub_uint8_t freecnt;
 114   grub_uint8_t freelist;
 115   grub_uint8_t maxslot;
 116
 117   /* The location of the sorted array of pointers to dirents.  */
 118   grub_uint8_t sindex;
 119   grub_uint8_t unused[10];
 120 } __attribute__ ((packed));
 121
 122 /* An internal node in the dirents tree.  */
 123 struct grub_jfs_internal_dirent
 124 {
 125   struct grub_jfs_extent ex;
 126   grub_uint8_t next;
 127   grub_uint8_t len;
 128   grub_uint16_t namepart[11];
 129 } __attribute__ ((packed));
 130
 131 /* A leaf node in the dirents tree.  */
 132 struct grub_jfs_leaf_dirent
 133 {
 134   /* The inode for this dirent.  */
 135   grub_uint32_t inode;
 136   grub_uint8_t next;
 137
 138   /* The size of the name.  */
 139   grub_uint8_t len;
 140   grub_uint16_t namepart[11];
 141   grub_uint32_t index;
 142 } __attribute__ ((packed));
 143
 144 /* A leaf in the dirents tree.  This one is used if the previously
 145    dirent was not big enough to store the name.  */
 146 struct grub_jfs_leaf_next_dirent
 147 {
 148   grub_uint8_t next;
 149   grub_uint8_t len;
 150   grub_uint16_t namepart[15];
 151 } __attribute__ ((packed));
 152
 153 struct grub_jfs_inode
 154 {
 155   grub_uint32_t stamp;
 156   grub_uint32_t fileset;
 157   grub_uint32_t inode;
 158   grub_uint8_t unused[12];
 159   grub_uint64_t size;
 160   grub_uint8_t unused2[20];
 161   grub_uint32_t mode;
 162   grub_uint8_t unused3[72];
 163   grub_uint8_t unused4[96];
 164
 165   union
 166   {
 167     /* The tree describing the extents of the file.  */
 168     struct __attribute__ ((packed))
 169     {
 170       struct grub_jfs_treehead tree;
 171       struct grub_jfs_tree_extent extents[16];
 172     } file;
 173     union
 174     {
 175       /* The tree describing the dirents.  */
 176       struct
 177       {
 178         grub_uint8_t unused[16];
 179         grub_uint8_t flags;
 180
 181         /* Amount of dirents in this node.  */
 182         grub_uint8_t count;
 183         grub_uint8_t freecnt;
 184         grub_uint8_t freelist;
 185         grub_uint32_t idotdot;
 186         grub_uint8_t sorted[8];
 187       } header;
 188       struct grub_jfs_leaf_dirent dirents[8];
 189     } dir __attribute__ ((packed));
 190     /* Fast symlink.  */
 191     struct
 192     {
 193       grub_uint8_t unused[32];
 194       grub_uint8_t path[128];
 195     } symlink;
 196   } __attribute__ ((packed));
 197 } __attribute__ ((packed));
 198
 199 struct grub_jfs_data
 200 {
 201   struct grub_jfs_sblock sblock;
 202   grub_disk_t disk;
 203   struct grub_jfs_inode fileset;
 204   struct grub_jfs_inode currinode;
 205   int pos;
 206   int linknest;
 207 } __attribute__ ((packed));
 208
 209 struct grub_jfs_diropen
 210 {
 211   int index;
 212   union
 213   {
 214     struct grub_jfs_tree_dir header;
 215     struct grub_jfs_leaf_dirent dirent[0];
 216     struct grub_jfs_leaf_next_dirent next_dirent[0];
 217     char sorted[0];
 218   } *dirpage __attribute__ ((packed));
 219   struct grub_jfs_data *data;
 220   struct grub_jfs_inode *inode;
 221   int count;
 222   char *sorted;
 223   struct grub_jfs_leaf_dirent *leaf;
 224   struct grub_jfs_leaf_next_dirent *next_leaf;
 225
 226   /* The filename and inode of the last read dirent.  */
 227   char name[255];
 228   grub_uint32_t ino;
 229 } __attribute__ ((packed));
 230
 231
 232 static grub_dl_t my_mod;
 233 \f
 234 static grub_err_t grub_jfs_lookup_symlink (struct grub_jfs_data *data, int ino);
 235
 236 /* Get the block number for the block BLK in the node INODE in the
 237    mounted filesystem DATA.  */
 238 static int
 239 grub_jfs_blkno (struct grub_jfs_data *data, struct grub_jfs_inode *inode,
 240                 unsigned int blk)
 241 {
 242   auto int getblk (struct grub_jfs_treehead *treehead,
 243                    struct grub_jfs_tree_extent *extents);
 244
 245   int getblk (struct grub_jfs_treehead *treehead,
 246               struct grub_jfs_tree_extent *extents)
 247     {
 248       int found = -1;
 249       int i;
 250
 251       for (i = 0; i < grub_le_to_cpu16 (treehead->count) - 2; i++)
 252         {
 253           if (treehead->flags & GRUB_JFS_TREE_LEAF)
 254             {
 255               /* Read the leafnode.  */
 256               if (grub_le_to_cpu32 (extents[i].offset2) <= blk
 257                   && ((grub_le_to_cpu16 (extents[i].extent.length))
 258                       + (extents[i].extent.length2 << 8)
 259                       + grub_le_to_cpu32 (extents[i].offset2)) > blk)
 260                 return (blk - grub_le_to_cpu32 (extents[i].offset2)
 261                         + grub_le_to_cpu32 (extents[i].extent.blk2));
 262             }
 263           else
 264             if (blk >= grub_le_to_cpu32 (extents[i].offset2))
 265               found = i;
 266         }
 267
 268       if (found != -1)
 269         {
 270           struct
 271           {
 272             struct grub_jfs_treehead treehead;
 273             struct grub_jfs_tree_extent extents[254];
 274           } tree;
 275
 276           if (grub_disk_read (data->disk,
 277                               grub_le_to_cpu32 (extents[found].extent.blk2)
 278                               << (grub_le_to_cpu16 (data->sblock.log2_blksz)
 279                                   - GRUB_DISK_SECTOR_BITS), 0,
 280                               sizeof (tree), (char *) &tree))
 281             return -1;
 282
 283           return getblk (&tree.treehead, &tree.extents[0]);
 284         }
 285
 286       return -1;
 287     }
 288
 289   return getblk (&inode->file.tree, &inode->file.extents[0]);
 290 }
 291
 292
 293 static grub_err_t
 294 grub_jfs_read_inode (struct grub_jfs_data *data, int ino,
 295                      struct grub_jfs_inode *inode)
 296 {
 297   struct grub_jfs_iag iag;
 298   int iagnum = ino / 4096;
 299   int inoext = (ino % 4096) / 32;
 300   int inonum = (ino % 4096) % 32;
 301   grub_uint32_t iagblk;
 302   grub_uint32_t inoblk;
 303
 304   iagblk = grub_jfs_blkno (data, &data->fileset, iagnum + 1);
 305   if (grub_errno)
 306     return grub_errno;
 307
 308   /* Read in the IAG.  */
 309   if (grub_disk_read (data->disk,
 310                       iagblk << (grub_le_to_cpu16 (data->sblock.log2_blksz)
 311                                  - GRUB_DISK_SECTOR_BITS), 0,
 312                       sizeof (struct grub_jfs_iag), &iag))
 313     return grub_errno;
 314
 315   inoblk = grub_le_to_cpu32 (iag.inodes[inoext].blk2);
 316   inoblk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz)
 317               - GRUB_DISK_SECTOR_BITS);
 318   inoblk += inonum;
 319
 320   if (grub_disk_read (data->disk, inoblk, 0,
 321                       sizeof (struct grub_jfs_inode), inode))
 322     return grub_errno;
 323
 324   return 0;
 325 }
 326
 327
 328 static struct grub_jfs_data *
 329 grub_jfs_mount (grub_disk_t disk)
 330 {
 331   struct grub_jfs_data *data = 0;
 332
 333   data = grub_malloc (sizeof (struct grub_jfs_data));
 334   if (!data)
 335     return 0;
 336
 337   /* Read the superblock.  */
 338   if (grub_disk_read (disk, GRUB_JFS_SBLOCK, 0,
 339                       sizeof (struct grub_jfs_sblock), &data->sblock))
 340     goto fail;
 341
 342   if (grub_strncmp ((char *) (data->sblock.magic), "JFS1", 4))
 343     {
 344       grub_error (GRUB_ERR_BAD_FS, "not a jfs filesystem");
 345       goto fail;
 346     }
 347
 348   data->disk = disk;
 349   data->pos = 0;
 350   data->linknest = 0;
 351
 352   /* Read the inode of the first fileset.  */
 353   if (grub_disk_read (data->disk, GRUB_JFS_FS1_INODE_BLK, 0,
 354                       sizeof (struct grub_jfs_inode), &data->fileset))
 355     goto fail;
 356
 357   return data;
 358
 359  fail:
 360   grub_free (data);
 361
 362   if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
 363     grub_error (GRUB_ERR_BAD_FS, "not a jfs filesystem");
 364
 365   return 0;
 366 }
 367
 368
 369 static struct grub_jfs_diropen *
 370 grub_jfs_opendir (struct grub_jfs_data *data, struct grub_jfs_inode *inode)
 371 {
 372   struct grub_jfs_internal_dirent *de;
 373   struct grub_jfs_diropen *diro;
 374   int blk;
 375
 376   de = (struct grub_jfs_internal_dirent *) inode->dir.dirents;
 377
 378   if (!((grub_le_to_cpu32 (inode->mode)
 379          & GRUB_JFS_FILETYPE_MASK) == GRUB_JFS_FILETYPE_DIR))
 380     {
 381       grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
 382       return 0;
 383     }
 384
 385   diro = grub_zalloc (sizeof (struct grub_jfs_diropen));
 386   if (!diro)
 387     return 0;
 388
 389   diro->data = data;
 390   diro->inode = inode;
 391
 392   /* Check if the entire tree is contained within the inode.  */
 393   if (inode->file.tree.flags & GRUB_JFS_TREE_LEAF)
 394     {
 395       diro->leaf = inode->dir.dirents;
 396       diro->next_leaf = (struct grub_jfs_leaf_next_dirent *) de;
 397       diro->sorted = (char *) (inode->dir.header.sorted);
 398       diro->count = inode->dir.header.count;
 399
 400       return diro;
 401     }
 402
 403   diro->dirpage = grub_malloc (grub_le_to_cpu32 (data->sblock.blksz));
 404   if (!diro->dirpage)
 405     {
 406       grub_free (diro);
 407       return 0;
 408     }
 409
 410   blk = grub_le_to_cpu32 (de[inode->dir.header.sorted[0]].ex.blk2);
 411   blk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz) - GRUB_DISK_SECTOR_BITS);
 412
 413   /* Read in the nodes until we are on the leaf node level.  */
 414   do
 415     {
 416       int index;
 417       if (grub_disk_read (data->disk, blk, 0,
 418                           grub_le_to_cpu32 (data->sblock.blksz),
 419                           diro->dirpage->sorted))
 420         {
 421           grub_free (diro->dirpage);
 422           grub_free (diro);
 423           return 0;
 424         }
 425
 426       de = (struct grub_jfs_internal_dirent *) diro->dirpage->dirent;
 427       index = diro->dirpage->sorted[diro->dirpage->header.sindex * 32];
 428       blk = (grub_le_to_cpu32 (de[index].ex.blk2)
 429              << (grub_le_to_cpu16 (data->sblock.log2_blksz)
 430                  - GRUB_DISK_SECTOR_BITS));
 431     } while (!(diro->dirpage->header.flags & GRUB_JFS_TREE_LEAF));
 432
 433   diro->leaf = diro->dirpage->dirent;
 434   diro->next_leaf = diro->dirpage->next_dirent;
 435   diro->sorted = &diro->dirpage->sorted[diro->dirpage->header.sindex * 32];
 436   diro->count = diro->dirpage->header.count;
 437
 438   return diro;
 439 }
 440
 441
 442 static void
 443 grub_jfs_closedir (struct grub_jfs_diropen *diro)
 444 {
 445   if (!diro)
 446     return;
 447   grub_free (diro->dirpage);
 448   grub_free (diro);
 449 }
 450
 451
 452 /* Read in the next dirent from the directory described by DIRO.  */
 453 static grub_err_t
 454 grub_jfs_getent (struct grub_jfs_diropen *diro)
 455 {
 456   int strpos = 0;
 457   struct grub_jfs_leaf_dirent *leaf;
 458   struct grub_jfs_leaf_next_dirent *next_leaf;
 459   int len;
 460   int nextent;
 461   grub_uint16_t filename[255];
 462
 463   auto void addstr (grub_uint16_t *uname, int ulen);
 464
 465   /* Add the unicode string to the utf16 filename buffer.  */
 466   void addstr (grub_uint16_t *name, int ulen)
 467     {
 468       while (ulen--)
 469         filename[strpos++] = *(name++);
 470     }
 471
 472   /* The last node, read in more.  */
 473   if (diro->index == diro->count)
 474     {
 475       unsigned int next;
 476
 477       /* If the inode contains the entry tree or if this was the last
 478          node, there is nothing to read.  */
 479       if ((diro->inode->file.tree.flags & GRUB_JFS_TREE_LEAF)
 480           || !grub_le_to_cpu64 (diro->dirpage->header.nextb))
 481         return GRUB_ERR_OUT_OF_RANGE;
 482
 483       next = grub_le_to_cpu64 (diro->dirpage->header.nextb);
 484       next <<= (grub_le_to_cpu16 (diro->data->sblock.log2_blksz)
 485                 - GRUB_DISK_SECTOR_BITS);
 486
 487       if (grub_disk_read (diro->data->disk, next, 0,
 488                           grub_le_to_cpu32 (diro->data->sblock.blksz),
 489                           diro->dirpage->sorted))
 490         return grub_errno;
 491
 492       diro->leaf = diro->dirpage->dirent;
 493       diro->next_leaf = diro->dirpage->next_dirent;
 494       diro->sorted = &diro->dirpage->sorted[diro->dirpage->header.sindex * 32];
 495       diro->count = diro->dirpage->header.count;
 496       diro->index = 0;
 497     }
 498
 499   leaf = &diro->leaf[(int) diro->sorted[diro->index]];
 500   next_leaf = &diro->next_leaf[diro->index];
 501
 502   len = leaf->len;
 503   if (!len)
 504     {
 505       diro->index++;
 506       return grub_jfs_getent (diro);
 507     }
 508
 509   addstr (leaf->namepart, len < 11 ? len : 11);
 510   diro->ino = grub_le_to_cpu32 (leaf->inode);
 511   len -= 11;
 512
 513   /* Move down to the leaf level.  */
 514   nextent = leaf->next;
 515   if (leaf->next != 255)
 516     do
 517       {
 518         next_leaf = &diro->next_leaf[nextent];
 519         addstr (next_leaf->namepart, len < 15 ? len : 15 );
 520
 521         len -= 15;
 522         nextent = next_leaf->next;
 523       } while (next_leaf->next != 255 && len > 0);
 524
 525   diro->index++;
 526
 527   /* Convert the temporary UTF16 filename to UTF8.  */
 528   *grub_utf16_to_utf8 ((grub_uint8_t *) (diro->name), filename, strpos) = '\0';
 529
 530   return 0;
 531 }
 532
 533
 534 /* Read LEN bytes from the file described by DATA starting with byte
 535    POS.  Return the amount of read bytes in READ.  */
 536 static grub_ssize_t
 537 grub_jfs_read_file (struct grub_jfs_data *data,
 538                     void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
 539                                        unsigned offset, unsigned length),
 540                     int pos, grub_size_t len, char *buf)
 541 {
 542   int i;
 543   int blockcnt;
 544
 545   /* Adjust len so it we can't read past the end of the file.  */
 546   if (len > data->currinode.size)
 547     len = data->currinode.size;
 548
 549   blockcnt = ((len + pos + grub_le_to_cpu32 (data->sblock.blksz) - 1)
 550               / grub_le_to_cpu32 (data->sblock.blksz));
 551
 552   for (i = pos / grub_le_to_cpu32 (data->sblock.blksz); i < blockcnt; i++)
 553     {
 554       int blknr;
 555       int blockoff = pos % grub_le_to_cpu32 (data->sblock.blksz);
 556       int blockend = grub_le_to_cpu32 (data->sblock.blksz);
 557
 558       int skipfirst = 0;
 559
 560       blknr = grub_jfs_blkno (data, &data->currinode, i);
 561       if (grub_errno)
 562         return -1;
 563
 564       /* Last block.  */
 565       if (i == blockcnt - 1)
 566         {
 567           blockend = (len + pos) % grub_le_to_cpu32 (data->sblock.blksz);
 568
 569           if (!blockend)
 570             blockend = grub_le_to_cpu32 (data->sblock.blksz);
 571         }
 572
 573       /* First block.  */
 574       if (i == (pos / (int) grub_le_to_cpu32 (data->sblock.blksz)))
 575         {
 576           skipfirst = blockoff;
 577           blockend -= skipfirst;
 578         }
 579
 580       data->disk->read_hook = read_hook;
 581       grub_disk_read (data->disk,
 582                       blknr << (grub_le_to_cpu16 (data->sblock.log2_blksz)
 583                                 - GRUB_DISK_SECTOR_BITS),
 584                       skipfirst, blockend, buf);
 585
 586       data->disk->read_hook = 0;
 587       if (grub_errno)
 588         return -1;
 589
 590       buf += grub_le_to_cpu32 (data->sblock.blksz) - skipfirst;
 591     }
 592
 593   return len;
 594 }
 595
 596
 597 /* Find the file with the pathname PATH on the filesystem described by
 598    DATA.  */
 599 static grub_err_t
 600 grub_jfs_find_file (struct grub_jfs_data *data, const char *path)
 601 {
 602   char fpath[grub_strlen (path)];
 603   char *name = fpath;
 604   char *next;
 605   unsigned int pos = 0;
 606   struct grub_jfs_diropen *diro;
 607
 608   grub_strncpy (fpath, path, grub_strlen (path) + 1);
 609
 610   if (grub_jfs_read_inode (data, GRUB_JFS_AGGR_INODE, &data->currinode))
 611     return grub_errno;
 612
 613   /* Skip the first slashes.  */
 614   while (*name == '/')
 615     {
 616       name++;
 617       if (!*name)
 618         return 0;
 619     }
 620
 621   /* Extract the actual part from the pathname.  */
 622   next = grub_strchr (name, '/');
 623   if (next)
 624     {
 625       while (*next == '/')
 626         {
 627           next[0] = '\0';
 628           next++;
 629         }
 630     }
 631   diro = grub_jfs_opendir (data, &data->currinode);
 632   if (!diro)
 633     return grub_errno;
 634
 635   for (;;)
 636     {
 637       if (grub_strlen (name) == 0)
 638         return GRUB_ERR_NONE;
 639
 640       if (grub_jfs_getent (diro) == GRUB_ERR_OUT_OF_RANGE)
 641         break;
 642
 643       /* Check if the current direntry matches the current part of the
 644          pathname.  */
 645       if (!grub_strcmp (name, diro->name))
 646         {
 647           int ino = diro->ino;
 648           int dirino = grub_le_to_cpu32 (data->currinode.inode);
 649
 650           grub_jfs_closedir (diro);
 651           diro = 0;
 652
 653           if (grub_jfs_read_inode (data, ino, &data->currinode))
 654             break;
 655
 656           /* Check if this is a symlink.  */
 657           if ((grub_le_to_cpu32 (data->currinode.mode)
 658                & GRUB_JFS_FILETYPE_MASK) == GRUB_JFS_FILETYPE_LNK)
 659             {
 660               grub_jfs_lookup_symlink (data, dirino);
 661               if (grub_errno)
 662                 return grub_errno;
 663             }
 664
 665           if (!next)
 666             return 0;
 667
 668           pos = 0;
 669
 670           name = next;
 671           next = grub_strchr (name, '/');
 672           if (next)
 673             {
 674               next[0] = '\0';
 675               next++;
 676             }
 677
 678           /* Open this directory for reading dirents.  */
 679           diro = grub_jfs_opendir (data, &data->currinode);
 680           if (!diro)
 681             return grub_errno;
 682
 683           continue;
 684         }
 685     }
 686
 687   grub_jfs_closedir (diro);
 688   grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
 689   return grub_errno;
 690 }
 691
 692
 693 static grub_err_t
 694 grub_jfs_lookup_symlink (struct grub_jfs_data *data, int ino)
 695 {
 696   int size = grub_le_to_cpu64 (data->currinode.size);
 697   char symlink[size + 1];
 698
 699   if (++data->linknest > GRUB_JFS_MAX_SYMLNK_CNT)
 700     return grub_error (GRUB_ERR_SYMLINK_LOOP, "too deep nesting of symlinks");
 701
 702   if (size <= 128)
 703     grub_strncpy (symlink, (char *) (data->currinode.symlink.path), 128);
 704   else if (grub_jfs_read_file (data, 0, 0, size, symlink) < 0)
 705     return grub_errno;
 706
 707   symlink[size] = '\0';
 708
 709   /* The symlink is an absolute path, go back to the root inode.  */
 710   if (symlink[0] == '/')
 711     ino = 2;
 712
 713   /* Now load in the old inode.  */
 714   if (grub_jfs_read_inode (data, ino, &data->currinode))
 715     return grub_errno;
 716
 717   grub_jfs_find_file (data, symlink);
 718   if (grub_errno)
 719     grub_error (grub_errno, "Can not follow symlink `%s'.", symlink);
 720
 721   return grub_errno;
 722 }
 723 \f
 724
 725 static grub_err_t
 726 grub_jfs_dir (grub_device_t device, const char *path,
 727               int (*hook) (const char *filename,
 728                            const struct grub_dirhook_info *info))
 729 {
 730   struct grub_jfs_data *data = 0;
 731   struct grub_jfs_diropen *diro = 0;
 732
 733   grub_dl_ref (my_mod);
 734
 735   data = grub_jfs_mount (device->disk);
 736   if (!data)
 737     goto fail;
 738
 739   if (grub_jfs_find_file (data, path))
 740     goto fail;
 741
 742   diro = grub_jfs_opendir (data, &data->currinode);
 743   if (!diro)
 744     goto fail;
 745
 746   /* Iterate over the dirents in the directory that was found.  */
 747   while (grub_jfs_getent (diro) != GRUB_ERR_OUT_OF_RANGE)
 748     {
 749       struct grub_jfs_inode inode;
 750       struct grub_dirhook_info info;
 751       grub_memset (&info, 0, sizeof (info));
 752
 753       if (grub_jfs_read_inode (data, diro->ino, &inode))
 754         goto fail;
 755
 756       info.dir = (grub_le_to_cpu32 (inode.mode)
 757                   & GRUB_JFS_FILETYPE_MASK) == GRUB_JFS_FILETYPE_DIR;
 758       if (hook (diro->name, &info))
 759         goto fail;
 760     }
 761
 762   /* XXX: GRUB_ERR_OUT_OF_RANGE is used for the last dirent.  */
 763   if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
 764     grub_errno = 0;
 765
 766  fail:
 767   grub_jfs_closedir (diro);
 768   grub_free (data);
 769
 770   grub_dl_unref (my_mod);
 771
 772   return grub_errno;
 773 }
 774
 775
 776 /* Open a file named NAME and initialize FILE.  */
 777 static grub_err_t
 778 grub_jfs_open (struct grub_file *file, const char *name)
 779 {
 780   struct grub_jfs_data *data;
 781
 782   grub_dl_ref (my_mod);
 783
 784   data = grub_jfs_mount (file->device->disk);
 785   if (!data)
 786     goto fail;
 787
 788   grub_jfs_find_file (data, name);
 789   if (grub_errno)
 790     goto fail;
 791
 792   /* It is only possible for open regular files.  */
 793   if (! ((grub_le_to_cpu32 (data->currinode.mode)
 794           & GRUB_JFS_FILETYPE_MASK) == GRUB_JFS_FILETYPE_REG))
 795     {
 796       grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a regular file");
 797       goto fail;
 798     }
 799
 800   file->data = data;
 801   file->size = grub_le_to_cpu64 (data->currinode.size);
 802
 803   return 0;
 804
 805  fail:
 806
 807   grub_dl_unref (my_mod);
 808
 809   grub_free (data);
 810
 811   return grub_errno;
 812 }
 813
 814
 815 static grub_ssize_t
 816 grub_jfs_read (grub_file_t file, char *buf, grub_size_t len)
 817 {
 818   struct grub_jfs_data *data =
 819     (struct grub_jfs_data *) file->data;
 820
 821   return grub_jfs_read_file (data, file->read_hook, file->offset, len, buf);
 822 }
 823
 824
 825 static grub_err_t
 826 grub_jfs_close (grub_file_t file)
 827 {
 828   grub_free (file->data);
 829
 830   grub_dl_unref (my_mod);
 831
 832   return GRUB_ERR_NONE;
 833 }
 834
 835
 836 static grub_err_t
 837 grub_jfs_label (grub_device_t device, char **label)
 838 {
 839   struct grub_jfs_data *data;
 840   data = grub_jfs_mount (device->disk);
 841
 842   if (data)
 843     *label = grub_strndup ((char *) (data->sblock.volname), 11);
 844   else
 845     *label = 0;
 846
 847   return grub_errno;
 848 }
 849 \f
 850
 851 static struct grub_fs grub_jfs_fs =
 852   {
 853     .name = "jfs",
 854     .dir = grub_jfs_dir,
 855     .open = grub_jfs_open,
 856     .read = grub_jfs_read,
 857     .close = grub_jfs_close,
 858     .label = grub_jfs_label,
 859     .next = 0
 860   };
 861
 862 GRUB_MOD_INIT(jfs)
 863 {
 864   grub_fs_register (&grub_jfs_fs);
 865   my_mod = mod;
 866 }
 867
 868 GRUB_MOD_FINI(jfs)
 869 {
 870   grub_fs_unregister (&grub_jfs_fs);
 871 }