fs/cbfs/cbfs.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
   4  */
   5
   6 #include <common.h>
   7 #include <cbfs.h>
   8 #include <malloc.h>
   9 #include <asm/byteorder.h>
  10
  11 static const u32 good_magic = 0x4f524243;
  12 static const u8 good_file_magic[] = "LARCHIVE";
  13
  14 struct cbfs_priv {
  15         int initialized;
  16         struct cbfs_header header;
  17         struct cbfs_cachenode *file_cache;
  18         enum cbfs_result result;
  19 };
  20
  21 static struct cbfs_priv cbfs_s;
  22
  23 const char *file_cbfs_error(void)
  24 {
  25         switch (cbfs_s.result) {
  26         case CBFS_SUCCESS:
  27                 return "Success";
  28         case CBFS_NOT_INITIALIZED:
  29                 return "CBFS not initialized";
  30         case CBFS_BAD_HEADER:
  31                 return "Bad CBFS header";
  32         case CBFS_BAD_FILE:
  33                 return "Bad CBFS file";
  34         case CBFS_FILE_NOT_FOUND:
  35                 return "File not found";
  36         default:
  37                 return "Unknown";
  38         }
  39 }
  40
  41 enum cbfs_result cbfs_get_result(void)
  42 {
  43         return cbfs_s.result;
  44 }
  45
  46 /* Do endian conversion on the CBFS header structure. */
  47 static void swap_header(struct cbfs_header *dest, struct cbfs_header *src)
  48 {
  49         dest->magic = be32_to_cpu(src->magic);
  50         dest->version = be32_to_cpu(src->version);
  51         dest->rom_size = be32_to_cpu(src->rom_size);
  52         dest->boot_block_size = be32_to_cpu(src->boot_block_size);
  53         dest->align = be32_to_cpu(src->align);
  54         dest->offset = be32_to_cpu(src->offset);
  55 }
  56
  57 /* Do endian conversion on a CBFS file header. */
  58 static void swap_file_header(struct cbfs_fileheader *dest,
  59                              const struct cbfs_fileheader *src)
  60 {
  61         memcpy(&dest->magic, &src->magic, sizeof(dest->magic));
  62         dest->len = be32_to_cpu(src->len);
  63         dest->type = be32_to_cpu(src->type);
  64         dest->attributes_offset = be32_to_cpu(src->attributes_offset);
  65         dest->offset = be32_to_cpu(src->offset);
  66 }
  67
  68 /*
  69  * Given a starting position in memory, scan forward, bounded by a size, and
  70  * find the next valid CBFS file. No memory is allocated by this function. The
  71  * caller is responsible for allocating space for the new file structure.
  72  *
  73  * @param start         The location in memory to start from.
  74  * @param size          The size of the memory region to search.
  75  * @param align         The alignment boundaries to check on.
  76  * @param new_node      A pointer to the file structure to load.
  77  * @param used          A pointer to the count of of bytes scanned through,
  78  *                      including the file if one is found.
  79  *
  80  * @return 1 if a file is found, 0 if one isn't.
  81  */
  82 static int file_cbfs_next_file(struct cbfs_priv *priv, u8 *start, u32 size,
  83                                u32 align, struct cbfs_cachenode *new_node,
  84                                u32 *used)
  85 {
  86         struct cbfs_fileheader header;
  87
  88         *used = 0;
  89
  90         while (size >= align) {
  91                 const struct cbfs_fileheader *file_header =
  92                         (const struct cbfs_fileheader *)start;
  93                 u32 name_len;
  94                 u32 step;
  95
  96                 /* Check if there's a file here. */
  97                 if (memcmp(good_file_magic, &file_header->magic,
  98                            sizeof(file_header->magic))) {
  99                         *used += align;
 100                         size -= align;
 101                         start += align;
 102                         continue;
 103                 }
 104
 105                 swap_file_header(&header, file_header);
 106                 if (header.offset < sizeof(struct cbfs_fileheader)) {
 107                         priv->result = CBFS_BAD_FILE;
 108                         return -1;
 109                 }
 110                 new_node->next = NULL;
 111                 new_node->type = header.type;
 112                 new_node->data = start + header.offset;
 113                 new_node->data_length = header.len;
 114                 name_len = header.offset - sizeof(struct cbfs_fileheader);
 115                 new_node->name = (char *)file_header +
 116                                 sizeof(struct cbfs_fileheader);
 117                 new_node->name_length = name_len;
 118                 new_node->attributes_offset = header.attributes_offset;
 119
 120                 step = header.len;
 121                 if (step % align)
 122                         step = step + align - step % align;
 123
 124                 *used += step;
 125                 return 1;
 126         }
 127         return 0;
 128 }
 129
 130 /* Look through a CBFS instance and copy file metadata into regular memory. */
 131 static void file_cbfs_fill_cache(struct cbfs_priv *priv, u8 *start, u32 size,
 132                                  u32 align)
 133 {
 134         struct cbfs_cachenode *cache_node;
 135         struct cbfs_cachenode *new_node;
 136         struct cbfs_cachenode **cache_tail = &priv->file_cache;
 137
 138         /* Clear out old information. */
 139         cache_node = priv->file_cache;
 140         while (cache_node) {
 141                 struct cbfs_cachenode *old_node = cache_node;
 142                 cache_node = cache_node->next;
 143                 free(old_node);
 144         }
 145         priv->file_cache = NULL;
 146
 147         while (size >= align) {
 148                 int ret;
 149                 u32 used;
 150
 151                 new_node = (struct cbfs_cachenode *)
 152                                 malloc(sizeof(struct cbfs_cachenode));
 153                 ret = file_cbfs_next_file(priv, start, size, align, new_node,
 154                                           &used);
 155
 156                 if (ret < 0) {
 157                         free(new_node);
 158                         return;
 159                 } else if (ret == 0) {
 160                         free(new_node);
 161                         break;
 162                 }
 163                 *cache_tail = new_node;
 164                 cache_tail = &new_node->next;
 165
 166                 size -= used;
 167                 start += used;
 168         }
 169         priv->result = CBFS_SUCCESS;
 170 }
 171
 172 /* Get the CBFS header out of the ROM and do endian conversion. */
 173 static int file_cbfs_load_header(ulong end_of_rom, struct cbfs_header *header)
 174 {
 175         struct cbfs_header *header_in_rom;
 176         int32_t offset = *(u32 *)(end_of_rom - 3);
 177
 178         header_in_rom = (struct cbfs_header *)(end_of_rom + offset + 1);
 179         swap_header(header, header_in_rom);
 180
 181         if (header->magic != good_magic || header->offset >
 182                         header->rom_size - header->boot_block_size) {
 183                 cbfs_s.result = CBFS_BAD_HEADER;
 184                 return 1;
 185         }
 186         return 0;
 187 }
 188
 189 static int cbfs_load_header_ptr(struct cbfs_priv *priv, ulong base,
 190                                 struct cbfs_header *header)
 191 {
 192         struct cbfs_header *header_in_rom;
 193
 194         header_in_rom = (struct cbfs_header *)base;
 195         swap_header(header, header_in_rom);
 196
 197         if (header->magic != good_magic || header->offset >
 198                         header->rom_size - header->boot_block_size) {
 199                 priv->result = CBFS_BAD_HEADER;
 200                 return -EFAULT;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static void cbfs_init(struct cbfs_priv *priv, ulong end_of_rom)
 207 {
 208         u8 *start_of_rom;
 209
 210         priv->initialized = 0;
 211
 212         if (file_cbfs_load_header(end_of_rom, &priv->header))
 213                 return;
 214
 215         start_of_rom = (u8 *)(end_of_rom + 1 - priv->header.rom_size);
 216
 217         file_cbfs_fill_cache(priv, start_of_rom, priv->header.rom_size,
 218                              priv->header.align);
 219         if (priv->result == CBFS_SUCCESS)
 220                 priv->initialized = 1;
 221 }
 222
 223 void file_cbfs_init(ulong end_of_rom)
 224 {
 225         cbfs_init(&cbfs_s, end_of_rom);
 226 }
 227
 228 int cbfs_init_mem(ulong base, ulong size, struct cbfs_priv **privp)
 229 {
 230         struct cbfs_priv priv_s, *priv = &priv_s;
 231         int ret;
 232
 233         /*
 234          * Use a local variable to start with until we know that the CBFS is
 235          * valid. Assume that a master header appears at the start, at offset
 236          * 0x38.
 237          */
 238         ret = cbfs_load_header_ptr(priv, base + 0x38, &priv->header);
 239         if (ret)
 240                 return ret;
 241
 242         file_cbfs_fill_cache(priv, (u8 *)base, priv->header.rom_size,
 243                              priv->header.align);
 244         if (priv->result != CBFS_SUCCESS)
 245                 return -EINVAL;
 246
 247         priv->initialized = 1;
 248         priv = malloc(sizeof(priv_s));
 249         if (!priv)
 250                 return -ENOMEM;
 251         memcpy(priv, &priv_s, sizeof(priv_s));
 252         *privp = priv;
 253
 254         return 0;
 255 }
 256
 257 const struct cbfs_header *file_cbfs_get_header(void)
 258 {
 259         struct cbfs_priv *priv = &cbfs_s;
 260
 261         if (priv->initialized) {
 262                 priv->result = CBFS_SUCCESS;
 263                 return &priv->header;
 264         } else {
 265                 priv->result = CBFS_NOT_INITIALIZED;
 266                 return NULL;
 267         }
 268 }
 269
 270 const struct cbfs_cachenode *file_cbfs_get_first(void)
 271 {
 272         struct cbfs_priv *priv = &cbfs_s;
 273
 274         if (!priv->initialized) {
 275                 priv->result = CBFS_NOT_INITIALIZED;
 276                 return NULL;
 277         } else {
 278                 priv->result = CBFS_SUCCESS;
 279                 return priv->file_cache;
 280         }
 281 }
 282
 283 void file_cbfs_get_next(const struct cbfs_cachenode **file)
 284 {
 285         struct cbfs_priv *priv = &cbfs_s;
 286
 287         if (!priv->initialized) {
 288                 priv->result = CBFS_NOT_INITIALIZED;
 289                 *file = NULL;
 290                 return;
 291         }
 292
 293         if (*file)
 294                 *file = (*file)->next;
 295         priv->result = CBFS_SUCCESS;
 296 }
 297
 298 const struct cbfs_cachenode *cbfs_find_file(struct cbfs_priv *priv,
 299                                             const char *name)
 300 {
 301         struct cbfs_cachenode *cache_node = priv->file_cache;
 302
 303         if (!priv->initialized) {
 304                 priv->result = CBFS_NOT_INITIALIZED;
 305                 return NULL;
 306         }
 307
 308         while (cache_node) {
 309                 if (!strcmp(name, cache_node->name))
 310                         break;
 311                 cache_node = cache_node->next;
 312         }
 313         if (!cache_node)
 314                 priv->result = CBFS_FILE_NOT_FOUND;
 315         else
 316                 priv->result = CBFS_SUCCESS;
 317
 318         return cache_node;
 319 }
 320
 321 const struct cbfs_cachenode *file_cbfs_find(const char *name)
 322 {
 323         return cbfs_find_file(&cbfs_s, name);
 324 }
 325
 326 const struct cbfs_cachenode *file_cbfs_find_uncached(ulong end_of_rom,
 327                                                      const char *name)
 328 {
 329         struct cbfs_priv *priv = &cbfs_s;
 330         u8 *start;
 331         u32 size;
 332         u32 align;
 333         static struct cbfs_cachenode node;
 334
 335         if (file_cbfs_load_header(end_of_rom, &priv->header))
 336                 return NULL;
 337
 338         start = (u8 *)(end_of_rom + 1 - priv->header.rom_size);
 339         size = priv->header.rom_size;
 340         align = priv->header.align;
 341
 342         while (size >= align) {
 343                 int ret;
 344                 u32 used;
 345
 346                 ret = file_cbfs_next_file(priv, start, size, align, &node,
 347                                           &used);
 348
 349                 if (ret < 0)
 350                         return NULL;
 351                 else if (ret == 0)
 352                         break;
 353
 354                 if (!strcmp(name, node.name))
 355                         return &node;
 356
 357                 size -= used;
 358                 start += used;
 359         }
 360         cbfs_s.result = CBFS_FILE_NOT_FOUND;
 361         return NULL;
 362 }
 363
 364 const char *file_cbfs_name(const struct cbfs_cachenode *file)
 365 {
 366         cbfs_s.result = CBFS_SUCCESS;
 367
 368         return file->name;
 369 }
 370
 371 u32 file_cbfs_size(const struct cbfs_cachenode *file)
 372 {
 373         cbfs_s.result = CBFS_SUCCESS;
 374
 375         return file->data_length;
 376 }
 377
 378 u32 file_cbfs_type(const struct cbfs_cachenode *file)
 379 {
 380         cbfs_s.result = CBFS_SUCCESS;
 381
 382         return file->type;
 383 }
 384
 385 long file_cbfs_read(const struct cbfs_cachenode *file, void *buffer,
 386                     unsigned long maxsize)
 387 {
 388         u32 size;
 389
 390         size = file->data_length;
 391         if (maxsize && size > maxsize)
 392                 size = maxsize;
 393
 394         memcpy(buffer, file->data, size);
 395         cbfs_s.result = CBFS_SUCCESS;
 396
 397         return size;
 398 }