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                         int NESTED_FUNC_ATTR
 175                         (*hook) (const char *filename,
 176                                  enum grub_fshelp_filetype filetype,
 177                                  grub_fshelp_node_t node))
 178 {
 179   grub_disk_addr_t caddr;
 180   struct grub_romfs_file_header hdr;
 181   unsigned nptr;
 182   unsigned i, j;
 183   grub_size_t a = 0;
 184   grub_properly_aligned_t *name = NULL;
 185
 186   for (caddr = dir->data_addr; caddr;
 187        caddr = grub_be_to_cpu32 (hdr.next_file) & ~(GRUB_ROMFS_ALIGN - 1))
 188     {
 189       grub_disk_addr_t naddr = caddr + sizeof (hdr);
 190       grub_uint32_t csum = 0;
 191       enum grub_fshelp_filetype filetype = GRUB_FSHELP_UNKNOWN;
 192       struct grub_fshelp_node *node = NULL;
 193       grub_err_t err;
 194
 195       err = grub_disk_read (dir->data->disk, caddr >> GRUB_DISK_SECTOR_BITS,
 196                             caddr & (GRUB_DISK_SECTOR_SIZE - 1),
 197                             sizeof (hdr), &hdr);
 198       if (err)
 199         {
 200           grub_free (name);
 201           return 1;
 202         }
 203       for (nptr = 0; ; nptr++, naddr += 16)
 204         {
 205           if (a <= nptr)
 206             {
 207               grub_properly_aligned_t *on;
 208               a = 2 * (nptr + 1);
 209               on = name;
 210               name = grub_realloc (name, a * 16);
 211               if (!name)
 212                 {
 213                   grub_free (on);
 214                   return 1;
 215                 }
 216             }
 217           COMPILE_TIME_ASSERT (16 % sizeof (name[0]) == 0);
 218           err = grub_disk_read (dir->data->disk, naddr >> GRUB_DISK_SECTOR_BITS,
 219                                 naddr & (GRUB_DISK_SECTOR_SIZE - 1),
 220                                 16, name + (16 / sizeof (name[0])) * nptr);
 221           if (err)
 222             return 1;
 223           for (j = 0; j < 16; j++)
 224             if (!((char *) name)[16 * nptr + j])
 225               break;
 226           if (j != 16)
 227             break;
 228         }
 229       for (i = 0; i < sizeof (hdr) / sizeof (grub_uint32_t); i++)
 230         csum += grub_be_to_cpu32 (((grub_uint32_t *) &hdr)[i]);
 231       for (i = 0; i < (nptr + 1) * 4; i++)
 232         csum += grub_be_to_cpu32 (((grub_uint32_t *) name)[i]);
 233       if (csum != 0)
 234         {
 235           grub_error (GRUB_ERR_BAD_FS, "invalid checksum");
 236           grub_free (name);
 237           return 1;
 238         }
 239       node = grub_malloc (sizeof (*node));
 240       if (!node)
 241         return 1;
 242       node->addr = caddr;
 243       node->data_addr = caddr + (nptr + 1) * 16 + sizeof (hdr);
 244       node->data = dir->data;
 245       node->file = hdr;
 246       switch (grub_be_to_cpu32 (hdr.next_file) & GRUB_ROMFS_TYPE_MASK)
 247         {
 248         case GRUB_ROMFS_TYPE_REGULAR:
 249           filetype = GRUB_FSHELP_REG;
 250           break;
 251         case GRUB_ROMFS_TYPE_SYMLINK:
 252           filetype = GRUB_FSHELP_SYMLINK;
 253           break;
 254         case GRUB_ROMFS_TYPE_DIRECTORY:
 255           node->data_addr = grub_be_to_cpu32 (hdr.spec);
 256           filetype = GRUB_FSHELP_DIR;
 257           break;
 258         case GRUB_ROMFS_TYPE_HARDLINK:
 259           {
 260             grub_disk_addr_t laddr;
 261             node->addr = laddr = grub_be_to_cpu32 (hdr.spec);
 262             err = grub_disk_read (dir->data->disk,
 263                                   laddr >> GRUB_DISK_SECTOR_BITS,
 264                                   laddr & (GRUB_DISK_SECTOR_SIZE - 1),
 265                                   sizeof (node->file), &node->file);
 266             if (err)
 267               return 1;
 268             if ((grub_be_to_cpu32 (node->file.next_file) & GRUB_ROMFS_TYPE_MASK)
 269                 == GRUB_ROMFS_TYPE_REGULAR
 270                 || (grub_be_to_cpu32 (node->file.next_file)
 271                     & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_SYMLINK)
 272               {
 273                 laddr += sizeof (hdr);
 274                 while (1)
 275                   {
 276                     char buf[16];
 277                     err = grub_disk_read (dir->data->disk,
 278                                           laddr >> GRUB_DISK_SECTOR_BITS,
 279                                           laddr & (GRUB_DISK_SECTOR_SIZE - 1),
 280                                           16, buf);
 281                     if (err)
 282                       return 1;
 283                     for (i = 0; i < 16; i++)
 284                       if (!buf[i])
 285                         break;
 286                     if (i != 16)
 287                       break;
 288                     laddr += 16;
 289                   }
 290                 node->data_addr = laddr + 16;
 291               }
 292             if ((grub_be_to_cpu32 (node->file.next_file)
 293                  & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_REGULAR)
 294               filetype = GRUB_FSHELP_REG;
 295             if ((grub_be_to_cpu32 (node->file.next_file)
 296                  & GRUB_ROMFS_TYPE_MASK) == GRUB_ROMFS_TYPE_SYMLINK)
 297               filetype = GRUB_FSHELP_SYMLINK;
 298             if ((grub_be_to_cpu32 (node->file.next_file) & GRUB_ROMFS_TYPE_MASK)
 299                 == GRUB_ROMFS_TYPE_DIRECTORY)
 300               {
 301                 node->data_addr = grub_be_to_cpu32 (node->file.spec);
 302                 filetype = GRUB_FSHELP_DIR;
 303               }
 304
 305             break;
 306           }
 307         }
 308
 309       if (hook ((char *) name, filetype, node))
 310         {
 311           grub_free (name);
 312           return 1;
 313         }
 314     }
 315   grub_free (name);
 316   return 0;
 317 }
 318
 319 static grub_err_t
 320 grub_romfs_dir (grub_device_t device, const char *path,
 321                 int (*hook) (const char *filename,
 322                              const struct grub_dirhook_info *info))
 323 {
 324   struct grub_romfs_data *data = 0;
 325   struct grub_fshelp_node *fdiro = 0, start;
 326
 327   auto int NESTED_FUNC_ATTR iterate (const char *filename,
 328                                      enum grub_fshelp_filetype filetype,
 329                                      grub_fshelp_node_t node);
 330
 331   int NESTED_FUNC_ATTR iterate (const char *filename,
 332                                 enum grub_fshelp_filetype filetype,
 333                                 grub_fshelp_node_t node)
 334     {
 335       struct grub_dirhook_info info;
 336       grub_memset (&info, 0, sizeof (info));
 337
 338       info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
 339       grub_free (node);
 340       return hook (filename, &info);
 341     }
 342
 343   data = grub_romfs_mount (device);
 344   if (! data)
 345     goto fail;
 346
 347   start.addr = data->first_file;
 348   start.data_addr = data->first_file;
 349   start.data = data;
 350   grub_fshelp_find_file (path, &start, &fdiro, grub_romfs_iterate_dir,
 351                          grub_romfs_read_symlink, GRUB_FSHELP_DIR);
 352   if (grub_errno)
 353     goto fail;
 354
 355   grub_romfs_iterate_dir (fdiro, iterate);
 356
 357  fail:
 358   grub_free (data);
 359
 360   return grub_errno;
 361 }
 362
 363 static grub_err_t
 364 grub_romfs_open (struct grub_file *file, const char *name)
 365 {
 366   struct grub_romfs_data *data = 0;
 367   struct grub_fshelp_node *fdiro = 0, start;
 368
 369   data = grub_romfs_mount (file->device);
 370   if (! data)
 371     goto fail;
 372
 373   start.addr = data->first_file;
 374   start.data_addr = data->first_file;
 375   start.data = data;
 376
 377   grub_fshelp_find_file (name, &start, &fdiro, grub_romfs_iterate_dir,
 378                          grub_romfs_read_symlink, GRUB_FSHELP_REG);
 379   if (grub_errno)
 380     goto fail;
 381
 382   file->size = grub_be_to_cpu32 (fdiro->file.size);
 383   file->data = fdiro;
 384   return GRUB_ERR_NONE;
 385
 386  fail:
 387   grub_free (data);
 388
 389   return grub_errno;
 390 }
 391
 392 static grub_ssize_t
 393 grub_romfs_read (grub_file_t file, char *buf, grub_size_t len)
 394 {
 395   struct grub_fshelp_node *data = file->data;
 396
 397   /* XXX: The file is stored in as a single extent.  */
 398   data->data->disk->read_hook = file->read_hook;
 399   grub_disk_read (data->data->disk,
 400                   (data->data_addr + file->offset) >> GRUB_DISK_SECTOR_BITS,
 401                   (data->data_addr + file->offset) & (GRUB_DISK_SECTOR_SIZE - 1),
 402                   len, buf);
 403   data->data->disk->read_hook = NULL;
 404
 405   if (grub_errno)
 406     return -1;
 407
 408   return len;
 409 }
 410
 411 static grub_err_t
 412 grub_romfs_close (grub_file_t file)
 413 {
 414   struct grub_fshelp_node *data = file->data;
 415
 416   grub_free (data->data);
 417   grub_free (data);
 418
 419   return GRUB_ERR_NONE;
 420 }
 421
 422 static grub_err_t
 423 grub_romfs_label (grub_device_t device, char **label)
 424 {
 425   struct grub_romfs_data *data;
 426   grub_err_t err;
 427
 428   *label = NULL;
 429
 430   data = grub_romfs_mount (device);
 431   if (!data)
 432     return grub_errno;
 433   *label = grub_malloc (data->first_file + 1
 434                         - sizeof (struct grub_romfs_superblock));
 435   if (!*label)
 436     {
 437       grub_free (data);
 438       return grub_errno;
 439     }
 440   err = grub_disk_read (device->disk, 0, sizeof (struct grub_romfs_superblock),
 441                         data->first_file
 442                         - sizeof (struct grub_romfs_superblock),
 443                         *label);
 444   if (err)
 445     {
 446       grub_free (data);
 447       grub_free (*label);
 448       *label = NULL;
 449       return err;
 450     }
 451   (*label)[data->first_file - sizeof (struct grub_romfs_superblock)] = 0;
 452   grub_free (data);
 453   return GRUB_ERR_NONE;
 454 }
 455
 456
 457 static struct grub_fs grub_romfs_fs =
 458   {
 459     .name = "romfs",
 460     .dir = grub_romfs_dir,
 461     .open = grub_romfs_open,
 462     .read = grub_romfs_read,
 463     .close = grub_romfs_close,
 464     .label = grub_romfs_label,
 465 #ifdef GRUB_UTIL
 466     .reserved_first_sector = 0,
 467     .blocklist_install = 0,
 468 #endif
 469     .next = 0
 470   };
 471
 472 GRUB_MOD_INIT(romfs)
 473 {
 474   grub_fs_register (&grub_romfs_fs);
 475 }
 476
 477 GRUB_MOD_FINI(romfs)
 478 {
 479   grub_fs_unregister (&grub_romfs_fs);
 480 }