grub-core/fs/cbfs.c

   1 /* cbfs.c - cbfs and tar filesystem.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2007,2008,2009,2013 Free Software Foundation, Inc.
   5  *
   6  *  This program 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  *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/misc.h>
  21 #include <grub/disk.h>
  22 #include <grub/archelp.h>
  23
  24 #include <grub/file.h>
  25 #include <grub/mm.h>
  26 #include <grub/dl.h>
  27 #include <grub/i18n.h>
  28 #include <grub/cbfs_core.h>
  29
  30 GRUB_MOD_LICENSE ("GPLv3+");
  31
  32
  33 struct grub_archelp_data
  34 {
  35   grub_disk_t disk;
  36   grub_off_t hofs, next_hofs;
  37   grub_off_t dofs;
  38   grub_off_t size;
  39   grub_off_t cbfs_start;
  40   grub_off_t cbfs_end;
  41   grub_off_t cbfs_align;
  42 };
  43
  44 static grub_err_t
  45 grub_cbfs_find_file (struct grub_archelp_data *data, char **name,
  46                      grub_int32_t *mtime,
  47                      grub_uint32_t *mode)
  48 {
  49   grub_size_t offset;
  50   for (;;
  51        data->dofs = data->hofs + offset,
  52          data->next_hofs = ALIGN_UP (data->dofs + data->size, data->cbfs_align))
  53     {
  54       struct cbfs_file hd;
  55       grub_size_t namesize;
  56
  57       data->hofs = data->next_hofs;
  58
  59       if (data->hofs >= data->cbfs_end)
  60         {
  61           *mode = GRUB_ARCHELP_ATTR_END;
  62           return GRUB_ERR_NONE;
  63         }
  64
  65       if (grub_disk_read (data->disk, 0, data->hofs, sizeof (hd), &hd))
  66         return grub_errno;
  67
  68       if (grub_memcmp (hd.magic, CBFS_FILE_MAGIC, sizeof (hd.magic)) != 0)
  69         {
  70           *mode = GRUB_ARCHELP_ATTR_END;
  71           return GRUB_ERR_NONE;
  72         }
  73       data->size = grub_be_to_cpu32 (hd.len);
  74       (void) mtime;
  75       offset = grub_be_to_cpu32 (hd.offset);
  76
  77       *mode = GRUB_ARCHELP_ATTR_FILE | GRUB_ARCHELP_ATTR_NOTIME;
  78
  79       namesize = offset;
  80       if (namesize >= sizeof (hd))
  81         namesize -= sizeof (hd);
  82       if (namesize == 0)
  83         continue;
  84       *name = grub_malloc (namesize + 1);
  85       if (*name == NULL)
  86         return grub_errno;
  87
  88       if (grub_disk_read (data->disk, 0, data->hofs + sizeof (hd),
  89                           namesize, *name))
  90         {
  91           grub_free (*name);
  92           return grub_errno;
  93         }
  94
  95       if ((*name)[0] == '\0')
  96         {
  97           grub_free (*name);
  98           *name = NULL;
  99           continue;
 100         }
 101
 102       (*name)[namesize] = 0;
 103
 104       data->dofs = data->hofs + offset;
 105       data->next_hofs = ALIGN_UP (data->dofs + data->size, data->cbfs_align);
 106       return GRUB_ERR_NONE;
 107     }
 108 }
 109
 110 static void
 111 grub_cbfs_rewind (struct grub_archelp_data *data)
 112 {
 113   data->next_hofs = data->cbfs_start;
 114 }
 115
 116 static struct grub_archelp_ops arcops =
 117   {
 118     .find_file = grub_cbfs_find_file,
 119     .rewind = grub_cbfs_rewind
 120   };
 121
 122 static int
 123 validate_head (struct cbfs_header *head)
 124 {
 125   return (head->magic == grub_cpu_to_be32_compile_time (CBFS_HEADER_MAGIC)
 126           && (head->version
 127               == grub_cpu_to_be32_compile_time (CBFS_HEADER_VERSION1)
 128               || head->version
 129               == grub_cpu_to_be32_compile_time (CBFS_HEADER_VERSION2))
 130           && (grub_be_to_cpu32 (head->bootblocksize)
 131               < grub_be_to_cpu32 (head->romsize))
 132           && (grub_be_to_cpu32 (head->offset)
 133               < grub_be_to_cpu32 (head->romsize))
 134           && (grub_be_to_cpu32 (head->offset)
 135               + grub_be_to_cpu32 (head->bootblocksize)
 136               < grub_be_to_cpu32 (head->romsize))
 137           && head->align != 0
 138           && (head->align & (head->align - 1)) == 0
 139           && head->romsize != 0);
 140 }
 141
 142 static struct grub_archelp_data *
 143 grub_cbfs_mount (grub_disk_t disk)
 144 {
 145   struct cbfs_file hd;
 146   struct grub_archelp_data *data = NULL;
 147   grub_uint32_t ptr;
 148   grub_off_t header_off;
 149   struct cbfs_header head;
 150
 151   if (grub_disk_native_sectors (disk) == GRUB_DISK_SIZE_UNKNOWN)
 152     goto fail;
 153
 154   if (grub_disk_read (disk, grub_disk_native_sectors (disk) - 1,
 155                       GRUB_DISK_SECTOR_SIZE - sizeof (ptr),
 156                       sizeof (ptr), &ptr))
 157     goto fail;
 158
 159   ptr = grub_cpu_to_le32 (ptr);
 160   header_off = (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS)
 161     + (grub_int32_t) ptr;
 162
 163   if (grub_disk_read (disk, 0, header_off,
 164                       sizeof (head), &head))
 165     goto fail;
 166
 167   if (!validate_head (&head))
 168     goto fail;
 169
 170   data = (struct grub_archelp_data *) grub_zalloc (sizeof (*data));
 171   if (!data)
 172     goto fail;
 173
 174   data->cbfs_start = (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS)
 175     - (grub_be_to_cpu32 (head.romsize) - grub_be_to_cpu32 (head.offset));
 176   data->cbfs_end = (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS)
 177     - grub_be_to_cpu32 (head.bootblocksize);
 178   data->cbfs_align = grub_be_to_cpu32 (head.align);
 179
 180   if (data->cbfs_start >= (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS))
 181     goto fail;
 182   if (data->cbfs_end > (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS))
 183     data->cbfs_end = (grub_disk_native_sectors (disk) << GRUB_DISK_SECTOR_BITS);
 184
 185   data->next_hofs = data->cbfs_start;
 186
 187   if (grub_disk_read (disk, 0, data->cbfs_start, sizeof (hd), &hd))
 188     goto fail;
 189
 190   if (grub_memcmp (hd.magic, CBFS_FILE_MAGIC, sizeof (CBFS_FILE_MAGIC) - 1))
 191     goto fail;
 192
 193   data->disk = disk;
 194
 195   return data;
 196
 197 fail:
 198   grub_free (data);
 199   grub_error (GRUB_ERR_BAD_FS, "not a cbfs filesystem");
 200   return 0;
 201 }
 202
 203 static grub_err_t
 204 grub_cbfs_dir (grub_device_t device, const char *path_in,
 205                grub_fs_dir_hook_t hook, void *hook_data)
 206 {
 207   struct grub_archelp_data *data;
 208   grub_err_t err;
 209
 210   data = grub_cbfs_mount (device->disk);
 211   if (!data)
 212     return grub_errno;
 213
 214   err = grub_archelp_dir (data, &arcops,
 215                           path_in, hook, hook_data);
 216
 217   grub_free (data);
 218
 219   return err;
 220 }
 221
 222 static grub_err_t
 223 grub_cbfs_open (grub_file_t file, const char *name_in)
 224 {
 225   struct grub_archelp_data *data;
 226   grub_err_t err;
 227
 228   data = grub_cbfs_mount (file->device->disk);
 229   if (!data)
 230     return grub_errno;
 231
 232   err = grub_archelp_open (data, &arcops, name_in);
 233   if (err)
 234     {
 235       grub_free (data);
 236     }
 237   else
 238     {
 239       file->data = data;
 240       file->size = data->size;
 241     }
 242   return err;
 243 }
 244
 245 static grub_ssize_t
 246 grub_cbfs_read (grub_file_t file, char *buf, grub_size_t len)
 247 {
 248   struct grub_archelp_data *data;
 249   grub_ssize_t ret;
 250
 251   data = file->data;
 252   data->disk->read_hook = file->read_hook;
 253   data->disk->read_hook_data = file->read_hook_data;
 254
 255   ret = (grub_disk_read (data->disk, 0, data->dofs + file->offset,
 256                          len, buf)) ? -1 : (grub_ssize_t) len;
 257   data->disk->read_hook = 0;
 258
 259   return ret;
 260 }
 261
 262 static grub_err_t
 263 grub_cbfs_close (grub_file_t file)
 264 {
 265   struct grub_archelp_data *data;
 266
 267   data = file->data;
 268   grub_free (data);
 269
 270   return grub_errno;
 271 }
 272
 273 #if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) \
 274   && !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
 275
 276 static char *cbfsdisk_addr;
 277 static grub_off_t cbfsdisk_size = 0;
 278
 279 static int
 280 grub_cbfsdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
 281                        grub_disk_pull_t pull)
 282 {
 283   if (pull != GRUB_DISK_PULL_NONE)
 284     return 0;
 285
 286   return hook ("cbfsdisk", hook_data);
 287 }
 288
 289 static grub_err_t
 290 grub_cbfsdisk_open (const char *name, grub_disk_t disk)
 291 {
 292   if (grub_strcmp (name, "cbfsdisk"))
 293       return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a cbfsdisk");
 294
 295   disk->total_sectors = cbfsdisk_size / GRUB_DISK_SECTOR_SIZE;
 296   disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
 297   disk->id = 0;
 298
 299   return GRUB_ERR_NONE;
 300 }
 301
 302 static void
 303 grub_cbfsdisk_close (grub_disk_t disk __attribute((unused)))
 304 {
 305 }
 306
 307 static grub_err_t
 308 grub_cbfsdisk_read (grub_disk_t disk __attribute((unused)),
 309                     grub_disk_addr_t sector,
 310                     grub_size_t size, char *buf)
 311 {
 312   grub_memcpy (buf, cbfsdisk_addr + (sector << GRUB_DISK_SECTOR_BITS),
 313                size << GRUB_DISK_SECTOR_BITS);
 314   return 0;
 315 }
 316
 317 static grub_err_t
 318 grub_cbfsdisk_write (grub_disk_t disk __attribute__ ((unused)),
 319                      grub_disk_addr_t sector __attribute__ ((unused)),
 320                      grub_size_t size __attribute__ ((unused)),
 321                      const char *buf __attribute__ ((unused)))
 322 {
 323   return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
 324                      "rom flashing isn't implemented yet");
 325 }
 326
 327 static struct grub_disk_dev grub_cbfsdisk_dev =
 328   {
 329     .name = "cbfsdisk",
 330     .id = GRUB_DISK_DEVICE_CBFSDISK_ID,
 331     .disk_iterate = grub_cbfsdisk_iterate,
 332     .disk_open = grub_cbfsdisk_open,
 333     .disk_close = grub_cbfsdisk_close,
 334     .disk_read = grub_cbfsdisk_read,
 335     .disk_write = grub_cbfsdisk_write,
 336     .next = 0
 337   };
 338
 339 static void
 340 init_cbfsdisk (void)
 341 {
 342   grub_uint32_t ptr;
 343   struct cbfs_header *head;
 344
 345   ptr = *(grub_uint32_t *) 0xfffffffc;
 346   head = (struct cbfs_header *) (grub_addr_t) ptr;
 347   grub_dprintf ("cbfs", "head=%p\n", head);
 348
 349   /* coreboot current supports only ROMs <= 16 MiB. Bigger ROMs will
 350      have problems as RCBA is 18 MiB below end of 32-bit typically,
 351      so either memory map would have to be rearranged or we'd need to support
 352      reading ROMs through controller directly.
 353    */
 354   if (ptr < 0xff000000
 355       || 0xffffffff - ptr < (grub_uint32_t) sizeof (*head) + 0xf
 356       || !validate_head (head))
 357     return;
 358
 359   cbfsdisk_size = ALIGN_UP (grub_be_to_cpu32 (head->romsize),
 360                             GRUB_DISK_SECTOR_SIZE);
 361   cbfsdisk_addr = (void *) (grub_addr_t) (0x100000000ULL - cbfsdisk_size);
 362
 363   grub_disk_dev_register (&grub_cbfsdisk_dev);
 364 }
 365
 366 static void
 367 fini_cbfsdisk (void)
 368 {
 369   if (! cbfsdisk_size)
 370     return;
 371   grub_disk_dev_unregister (&grub_cbfsdisk_dev);
 372 }
 373
 374 #endif
 375
 376 static struct grub_fs grub_cbfs_fs = {
 377   .name = "cbfs",
 378   .fs_dir = grub_cbfs_dir,
 379   .fs_open = grub_cbfs_open,
 380   .fs_read = grub_cbfs_read,
 381   .fs_close = grub_cbfs_close,
 382 #ifdef GRUB_UTIL
 383   .reserved_first_sector = 0,
 384   .blocklist_install = 0,
 385 #endif
 386 };
 387
 388 GRUB_MOD_INIT (cbfs)
 389 {
 390 #if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
 391   init_cbfsdisk ();
 392 #endif
 393   grub_fs_register (&grub_cbfs_fs);
 394 }
 395
 396 GRUB_MOD_FINI (cbfs)
 397 {
 398   grub_fs_unregister (&grub_cbfs_fs);
 399 #if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
 400   fini_cbfsdisk ();
 401 #endif
 402 }