arch/all-pc/boot/grub2-aros/grub-core/fs/romfs.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2010  Free Software Foundation, Inc.
   4  *
   5  *  GRUB 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 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/file.h>
  20 #include <grub/types.h>
  21 #include <grub/dl.h>
  22 #include <grub/mm.h>
  23 #include <grub/disk.h>
  24 #include <grub/fs.h>
  25 #include <grub/fshelp.h>
  26
  27 GRUB_MOD_LICENSE ("GPLv3+");
  28
  29 struct grub_romfs_superblock
  30 {
  31   char magic[8];
  32 #define GRUB_ROMFS_MAGIC "-rom1fs-"
  33   grub_uint32_t total_size;
  34   grub_uint32_t chksum;
  35   char label[0];
  36 };
  37
  38 struct grub_romfs_file_header
  39 {
  40   grub_uint32_t next_file;
  41   grub_uint32_t spec;
  42   grub_uint32_t size;
  43   grub_uint32_t chksum;
  44   char name[0];
  45 };
  46
  47 struct grub_romfs_data
  48 {
  49   grub_disk_addr_t first_file;
  50   grub_disk_t disk;
  51 };
  52
  53 struct grub_fshelp_node
  54 {
  55   grub_disk_addr_t addr;
  56   struct grub_romfs_data *data;
  57   grub_disk_addr_t data_addr;
  58   /* Not filled for root.  */
  59   struct grub_romfs_file_header file;
  60 };
  61
  62 #define GRUB_ROMFS_ALIGN 16
  63 #define GRUB_ROMFS_TYPE_MASK 7
  64 #define GRUB_ROMFS_TYPE_HARDLINK 0
  65 #define GRUB_ROMFS_TYPE_DIRECTORY 1
  66 #define GRUB_ROMFS_TYPE_REGULAR 2
  67 #define GRUB_ROMFS_TYPE_SYMLINK 3
  68
  69 static grub_err_t
  70 do_checksum (void *in, grub_size_t insize)
  71 {
  72   grub_uint32_t *a = in;
  73   grub_size_t sz = insize / 4;
  74   grub_uint32_t *b = a + sz;
  75   grub_uint32_t csum = 0;
  76
  77   while (a < b)
  78     csum += grub_be_to_cpu32 (*a++);
  79   if (csum)
  80     return grub_error (GRUB_ERR_BAD_FS, "invalid checksum");
  81   return GRUB_ERR_NONE;
  82 }
  83
  84 static struct grub_romfs_data *
  85 grub_romfs_mount (grub_device_t dev)
  86 {
  87   union {
  88     struct grub_romfs_superblock sb;
  89     char d[512];
  90   } sb;
  91   grub_err_t err;
  92   char *ptr;
  93   grub_disk_addr_t sec = 0;
  94   struct grub_romfs_data *data;
  95   if (!dev->disk)
  96     {
  97       grub_error (GRUB_ERR_BAD_FS, "not a disk");
  98       return NULL;
  99     }
 100   err = grub_disk_read (dev->disk, 0, 0, sizeof (sb), &sb);
 101   if (err == GRUB_ERR_OUT_OF_RANGE)
 102     err = grub_errno = GRUB_ERR_BAD_FS;
 103   if (err)
 104     return NULL;
 105   if (grub_be_to_cpu32 (sb.sb.total_size) < sizeof (sb))
 106     {
 107       grub_error (GRUB_ERR_BAD_FS, "too short filesystem");
 108       return NULL;
 109     }
 110   if (grub_memcmp (sb.sb.magic, GRUB_ROMFS_MAGIC,
 111                    sizeof (sb.sb.magic)) != 0)
 112     {
 113       grub_error (GRUB_ERR_BAD_FS, "not romfs");
 114       return NULL;
 115     }
 116   err = do_checksum (&sb, sizeof (sb) < grub_be_to_cpu32 (sb.sb.total_size) ?
 117                      sizeof (sb) : grub_be_to_cpu32 (sb.sb.total_size));
 118   if (err)
 119     {
 120       grub_error (GRUB_ERR_BAD_FS, "checksum incorrect");
 121       return NULL;
 122     }
 123   for (ptr = sb.sb.label; (void *) ptr < (void *) (&sb + 1)
 124          && ptr - sb.d < (grub_ssize_t) grub_be_to_cpu32 (sb.sb.total_size); ptr++)
 125     if (!*ptr)
 126       break;
 127   while ((void *) ptr == &sb + 1)
 128     {
 129       sec++;
 130       err = grub_disk_read (dev->disk, sec, 0, sizeof (sb), &sb);
 131       if (err == GRUB_ERR_OUT_OF_RANGE)
 132         err = grub_errno = GRUB_ERR_BAD_FS;
 133       if (err)
 134         return NULL;
 135       for (ptr = sb.d; (void *) ptr < (void *) (&sb + 1)
 136              && (ptr - sb.d + (sec << GRUB_DISK_SECTOR_BITS)
 137                  < grub_be_to_cpu32 (sb.sb.total_size));
 138            ptr++)
 139         if (!*ptr)
 140           break;
 141     }
 142   data = grub_malloc (sizeof (*data));
 143   if (!data)
 144     return NULL;
 145   data->first_file = ALIGN_UP (ptr + 1 - sb.d, GRUB_ROMFS_ALIGN)
 146     + (sec << GRUB_DISK_SECTOR_BITS);
 147   data->disk = dev->disk;
 148   return data;
 149 }
 150
 151 static char *
 152 grub_romfs_read_symlink (grub_fshelp_node_t node)
 153 {
 154   char *ret;
 155   grub_err_t err;
 156   ret = grub_malloc (grub_be_to_cpu32 (node->file.size) + 1);
 157   if (!ret)
 158     return NULL;
 159   err = grub_disk_read (node->data->disk,
 160                         (node->data_addr) >> GRUB_DISK_SECTOR_BITS,
 161                         (node->data_addr) & (GRUB_DISK_SECTOR_SIZE - 1),
 162                         grub_be_to_cpu32 (node->file.size), ret);
 163   if (err)
 164     {
 165       grub_free (ret);
 166       return NULL;
 167     }
 168   ret[grub_be_to_cpu32 (node->file.size)] = 0;
 169   return ret;
 170 }
 171
 172 static int
 173 grub_romfs_iterate_dir (grub_fshelp_node_t dir,
 174                         grub_fshelp_iterate_dir_hook_t hook, void *hook_data)
 175 {
 176   grub_disk_addr_t caddr;
 177   struct grub_romfs_file_header hdr;
 178   unsigned nptr;
 179   unsigned i, j;
 180   grub_size_t a = 0;
 181   grub_properly_aligned_t *name = NULL;
 182
 183   for (caddr = dir->data_addr; caddr;
 184        caddr = grub_be_to_cpu32 (hdr.next_file) & ~(GRUB_ROMFS_ALIGN - 1))
 185     {
 186       grub_disk_addr_t naddr = caddr + sizeof (hdr);
 187       grub_uint32_t csum = 0;
 188       enum grub_fshelp_filetype filetype = GRUB_FSHELP_UNKNOWN;
 189       struct grub_fshelp_node *node = NULL;
 190       grub_err_t err;
 191
 192       err = grub_disk_read (dir->data->disk, caddr >> GRUB_DISK_SECTOR_BITS,
 193                             caddr & (GRUB_DISK_SECTOR_SIZE - 1),
 194                             sizeof (hdr), &hdr);
 195       if (err)
 196         {
 197           grub_free (name);
 198           return 1;
 199         }
 200       for (nptr = 0; ; nptr++, naddr += 16)
 201         {
 202           if (a <= nptr)
 203             {
 204               grub_properly_aligned_t *on;
 205               a = 2 * (nptr + 1);
 206               on = name;
 207               name = grub_realloc (name, a * 16);
 208               if (!name)
 209                 {
 210                   grub_free (on);
 211                   return 1;
 212                 }
 213             }
 214           COMPILE_TIME_ASSERT (16 % sizeof (name[0]) == 0);
 215           err = grub_disk_read (dir->data->disk, naddr >> GRUB_DISK_SECTOR_BITS,
 216                                 naddr & (GRUB_DISK_SECTOR_SIZE - 1),
 217                                 16, name + (16 / sizeof (name[0])) * nptr);
 218           if (err)
 219             return 1;
 220           for (j = 0; j < 16; j++)
 221             if (!((char *) name)[16 * nptr + j])
 222               break;
 223           if (j != 16)
 224             break;
 225         }
 226       for (i = 0; i < sizeof (hdr) / sizeof (grub_uint32_t); i++)
 227         csum += grub_be_to_cpu32 (((grub_uint32_t *) &hdr)[i]);
 228       for (i = 0; i < (nptr + 1) * 4; i++)
 229         csum += grub_be_to_cpu32 (((grub_uint32_t *) name)[i]);
 230       if (csum != 0)
 231         {
 232           grub_error (GRUB_ERR_BAD_FS, "invalid checksum");
 233           grub_free (name);
 234           return 1;
 235         }
 236       node = grub_malloc (sizeof (*node));
 237       if (!node)
 238         return 1;
 239       node->addr = caddr;
 240       node->data_addr = caddr + (nptr + 1) * 16 + sizeof (hdr);
 241       node->data = dir->data;
 242       node->file = hdr;
 243       switch (grub_be_to_cpu32 (hdr.next_file) & GRUB_ROMFS_TYPE_MASK)
 244         {
 245         case GRUB_ROMFS_TYPE_REGULAR:
 246           filetype = GRUB_FSHELP_REG;
 247           break;
 248         case GRUB_ROMFS_TYPE_SYMLINK:
 249           filetype = GRUB_FSHELP_SYMLINK;
 250           break;
 251         case GRUB_ROMFS_TYPE_DIRECTORY:
 252           node->data_addr = grub_be_to_cpu32 (hdr.spec);
 253           filetype = GRUB_FSHELP_DIR;
 254           break;
 255         case GRUB_ROMFS_TYPE_HARDLINK:
 256           {
 257             grub_disk_addr_t laddr;
 258             node->addr = laddr = grub_be_to_cpu32 (hdr.spec);
 259             err = grub_disk_read (dir->data->disk,
 260                                   laddr >> GRUB_DISK_SECTOR_BITS,
 261                                   laddr & (GRUB_DISK_SECTOR_SIZE - 1),
 262                                   sizeof (node->file), &node->file);
 263             if (err)
 264               return 1;
 265             if ((grub_be_to_cpu32 (node->file.next_file) & GRUB_ROMFS_TYPE_MASK)
 266                 == GRUB_ROMFS_TYPE_REGULAR
 267                 || (grub_be_to_cpu32 (node->file.next_file)
 268                     & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_SYMLINK)
 269               {
 270                 laddr += sizeof (hdr);
 271                 while (1)
 272                   {
 273                     char buf[16];
 274                     err = grub_disk_read (dir->data->disk,
 275                                           laddr >> GRUB_DISK_SECTOR_BITS,
 276                                           laddr & (GRUB_DISK_SECTOR_SIZE - 1),
 277                                           16, buf);
 278                     if (err)
 279                       return 1;
 280                     for (i = 0; i < 16; i++)
 281                       if (!buf[i])
 282                         break;
 283                     if (i != 16)
 284                       break;
 285                     laddr += 16;
 286                   }
 287                 node->data_addr = laddr + 16;
 288               }
 289             if ((grub_be_to_cpu32 (node->file.next_file)
 290                  & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_REGULAR)
 291               filetype = GRUB_FSHELP_REG;
 292             if ((grub_be_to_cpu32 (node->file.next_file)
 293                  & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_SYMLINK)
 294               filetype = GRUB_FSHELP_SYMLINK;
 295             if ((grub_be_to_cpu32 (node->file.next_file) & GRUB_ROMFS_TYPE_MASK)
 296                 == GRUB_ROMFS_TYPE_DIRECTORY)
 297               {
 298                 node->data_addr = grub_be_to_cpu32 (node->file.spec);
 299                 filetype = GRUB_FSHELP_DIR;
 300               }
 301
 302             break;
 303           }
 304         }
 305
 306       if (hook ((char *) name, filetype, node, hook_data))
 307         {
 308           grub_free (name);
 309           return 1;
 310         }
 311     }
 312   grub_free (name);
 313   return 0;
 314 }
 315
 316 /* Context for grub_romfs_dir.  */
 317 struct grub_romfs_dir_ctx
 318 {
 319   grub_fs_dir_hook_t hook;
 320   void *hook_data;
 321 };
 322
 323 /* Helper for grub_romfs_dir.  */
 324 static int
 325 grub_romfs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
 326                      grub_fshelp_node_t node, void *data)
 327 {
 328   struct grub_romfs_dir_ctx *ctx = data;
 329   struct grub_dirhook_info info;
 330
 331   grub_memset (&info, 0, sizeof (info));
 332
 333   info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
 334   grub_free (node);
 335   return ctx->hook (filename, &info, ctx->hook_data);
 336 }
 337
 338 static grub_err_t
 339 grub_romfs_dir (grub_device_t device, const char *path,
 340                 grub_fs_dir_hook_t hook, void *hook_data)
 341 {
 342   struct grub_romfs_dir_ctx ctx = { hook, hook_data };
 343   struct grub_romfs_data *data = 0;
 344   struct grub_fshelp_node *fdiro = 0, start;
 345
 346   data = grub_romfs_mount (device);
 347   if (! data)
 348     goto fail;
 349
 350   start.addr = data->first_file;
 351   start.data_addr = data->first_file;
 352   start.data = data;
 353   grub_fshelp_find_file (path, &start, &fdiro, grub_romfs_iterate_dir,
 354                          grub_romfs_read_symlink, GRUB_FSHELP_DIR);
 355   if (grub_errno)
 356     goto fail;
 357
 358   grub_romfs_iterate_dir (fdiro, grub_romfs_dir_iter, &ctx);
 359
 360  fail:
 361   grub_free (data);
 362
 363   return grub_errno;
 364 }
 365
 366 static grub_err_t
 367 grub_romfs_open (struct grub_file *file, const char *name)
 368 {
 369   struct grub_romfs_data *data = 0;
 370   struct grub_fshelp_node *fdiro = 0, start;
 371
 372   data = grub_romfs_mount (file->device);
 373   if (! data)
 374     goto fail;
 375
 376   start.addr = data->first_file;
 377   start.data_addr = data->first_file;
 378   start.data = data;
 379
 380   grub_fshelp_find_file (name, &start, &fdiro, grub_romfs_iterate_dir,
 381                          grub_romfs_read_symlink, GRUB_FSHELP_REG);
 382   if (grub_errno)
 383     goto fail;
 384
 385   file->size = grub_be_to_cpu32 (fdiro->file.size);
 386   file->data = fdiro;
 387   return GRUB_ERR_NONE;
 388
 389  fail:
 390   grub_free (data);
 391
 392   return grub_errno;
 393 }
 394
 395 static grub_ssize_t
 396 grub_romfs_read (grub_file_t file, char *buf, grub_size_t len)
 397 {
 398   struct grub_fshelp_node *data = file->data;
 399
 400   /* XXX: The file is stored in as a single extent.  */
 401   data->data->disk->read_hook = file->read_hook;
 402   data->data->disk->read_hook_data = file->read_hook_data;
 403   grub_disk_read (data->data->disk,
 404                   (data->data_addr + file->offset) >> GRUB_DISK_SECTOR_BITS,
 405                   (data->data_addr + file->offset) & (GRUB_DISK_SECTOR_SIZE - 1),
 406                   len, buf);
 407   data->data->disk->read_hook = NULL;
 408
 409   if (grub_errno)
 410     return -1;
 411
 412   return len;
 413 }
 414
 415 static grub_err_t
 416 grub_romfs_close (grub_file_t file)
 417 {
 418   struct grub_fshelp_node *data = file->data;
 419
 420   grub_free (data->data);
 421   grub_free (data);
 422
 423   return GRUB_ERR_NONE;
 424 }
 425
 426 static grub_err_t
 427 grub_romfs_label (grub_device_t device, char **label)
 428 {
 429   struct grub_romfs_data *data;
 430   grub_err_t err;
 431
 432   *label = NULL;
 433
 434   data = grub_romfs_mount (device);
 435   if (!data)
 436     return grub_errno;
 437   *label = grub_malloc (data->first_file + 1
 438                         - sizeof (struct grub_romfs_superblock));
 439   if (!*label)
 440     {
 441       grub_free (data);
 442       return grub_errno;
 443     }
 444   err = grub_disk_read (device->disk, 0, sizeof (struct grub_romfs_superblock),
 445                         data->first_file
 446                         - sizeof (struct grub_romfs_superblock),
 447                         *label);
 448   if (err)
 449     {
 450       grub_free (data);
 451       grub_free (*label);
 452       *label = NULL;
 453       return err;
 454     }
 455   (*label)[data->first_file - sizeof (struct grub_romfs_superblock)] = 0;
 456   grub_free (data);
 457   return GRUB_ERR_NONE;
 458 }
 459
 460
 461 static struct grub_fs grub_romfs_fs =
 462   {
 463     .name = "romfs",
 464     .dir = grub_romfs_dir,
 465     .open = grub_romfs_open,
 466     .read = grub_romfs_read,
 467     .close = grub_romfs_close,
 468     .label = grub_romfs_label,
 469 #ifdef GRUB_UTIL
 470     .reserved_first_sector = 0,
 471     .blocklist_install = 0,
 472 #endif
 473     .next = 0
 474   };
 475
 476 GRUB_MOD_INIT(romfs)
 477 {
 478   grub_fs_register (&grub_romfs_fs);
 479 }
 480
 481 GRUB_MOD_FINI(romfs)
 482 {
 483   grub_fs_unregister (&grub_romfs_fs);
 484 }