67a0a864be
These new-style firmware images use the FMAP of the root of knowledge about their layout, which allows them to have sections containing raw data whose offset and size can easily be determined at runtime or when modifying or flashing the image. Furthermore, they can even have multiple CBFSes, each of which occupies a different FMAP region. It is assumed that the first entry of each CBFS, including the primary one, will be located right at the start of its region. This means that the bootblock needs to be moved into its own FMAP region, but makes the CBFS master header obsolete because, with the exception of the version and alignment, all its fields are redundant once its CBFS has an entry in the FMAP. The version code will be addressed in a future commit before the new format comes into use, while the alignment will just be defined to 64 bytes in both cbfstool and coreboot itself, since there's almost no reason to ever change it in practice. The version code field and all necessary coreboot changes will come separately. BUG=chromium:470407 TEST=Build panther and nyan_big coreboot.rom and image.bin images with and without this patch, diff their hexdumps, and note that no locations differ except for those that do between subsequent builds of the same codebase. Try working with new-style images: use fmaptool to produce an FMAP section from an fmd file having raw sections and multiple CBFSes, pass the resulting file to cbfstool create -M -F, then try printing its layout and CBFSes' contents, add and remove CBFS files, and read and write raw sections. BRANCH=None Change-Id: I7dd2578d2143d0cedd652fdba5b22221fcc2184a Signed-off-by: Sol Boucher <solb@chromium.org> Original-Commit-Id: 8a670322297f83135b929a5b20ff2bd0e7d2abd3 Original-Change-Id: Ib86fb50edc66632f4e6f717909bbe4efb6c874e5 Original-Signed-off-by: Sol Boucher <solb@chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/265863 Original-Reviewed-by: Aaron Durbin <adurbin@chromium.org> Reviewed-on: http://review.coreboot.org/10135 Tested-by: build bot (Jenkins)
165 lines
7.0 KiB
C
165 lines
7.0 KiB
C
/*
|
|
* CBFS Image Manipulation
|
|
*
|
|
* Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef __CBFS_IMAGE_H
|
|
#define __CBFS_IMAGE_H
|
|
#include "common.h"
|
|
#include "cbfs.h"
|
|
|
|
#define IS_TOP_ALIGNED_ADDRESS(x) ((uint32_t)(x) > 0x80000000)
|
|
|
|
/* CBFS image processing */
|
|
|
|
struct cbfs_image {
|
|
struct buffer buffer;
|
|
/* An image has a header iff it's a legacy CBFS. */
|
|
bool has_header;
|
|
/* Only meaningful if has_header is selected. */
|
|
struct cbfs_header header;
|
|
};
|
|
|
|
/* Given a pointer, serialize the header from host-native byte format
|
|
* to cbfs format, i.e. big-endian. */
|
|
void cbfs_put_header(void *dest, const struct cbfs_header *header);
|
|
/* Or deserialize into host-native format */
|
|
void cbfs_get_header(struct cbfs_header *header, void *src);
|
|
|
|
/* Populates a CBFS with a single empty entry filling all available space
|
|
* (entries_size bytes). If image's header field is already present, its
|
|
* contents will be used to place an empty entry of the requested length at the
|
|
* appropriate position in the existing buffer; otherwise, if not has_header,
|
|
* the first entries_size bytes of buffer will be filled exclusively with the
|
|
* single empty entry (and no CBFS master header).
|
|
* Returns 0 on success, otherwise nonzero. */
|
|
int cbfs_image_create(struct cbfs_image *image, size_t entries_size);
|
|
|
|
/* Creates an empty CBFS image by given size, and description to its content
|
|
* (bootblock, align, header location, starting offset of CBFS entries).
|
|
* The output image will contain a valid cbfs_header, with one cbfs_file
|
|
* entry with type CBFS_COMPONENT_NULL, with max available size.
|
|
* Only call this if you want a legacy CBFS with a master header.
|
|
* Returns 0 on success, otherwise nonzero. */
|
|
int cbfs_legacy_image_create(struct cbfs_image *image,
|
|
uint32_t arch,
|
|
uint32_t align,
|
|
struct buffer *bootblock,
|
|
uint32_t bootblock_offset,
|
|
uint32_t header_offset,
|
|
uint32_t entries_offset);
|
|
|
|
/* Constructs a cbfs_image from a buffer. The resulting image contains a shallow
|
|
* copy of the buffer; releasing either one is the legal way to clean up after
|
|
* both of them at once. Always produces a cbfs_image, but...
|
|
* Returns 0 if it contains a valid CBFS, non-zero if it's unrecognized data. */
|
|
int cbfs_image_from_buffer(struct cbfs_image *out, struct buffer *in,
|
|
uint32_t offset);
|
|
|
|
/* Create a duplicate CBFS image. Returns 0 on success, otherwise non-zero.
|
|
* Will not succeed on new-style images without a master header. */
|
|
int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset,
|
|
size_t copy_size);
|
|
|
|
/* Releases the CBFS image. Returns 0 on success, otherwise non-zero. */
|
|
int cbfs_image_delete(struct cbfs_image *image);
|
|
|
|
/* Returns a pointer to entry by name, or NULL if name is not found. */
|
|
struct cbfs_file *cbfs_get_entry(struct cbfs_image *image, const char *name);
|
|
|
|
/* Exports an entry to external file.
|
|
* Returns 0 on success, otherwise (ex, not found) non-zero. */
|
|
int cbfs_export_entry(struct cbfs_image *image, const char *entry_name,
|
|
const char *filename);
|
|
|
|
/* Adds an entry to CBFS image by given name and type. If content_offset is
|
|
* non-zero, try to align "content" (CBFS_SUBHEADER(p)) at content_offset.
|
|
* Note that top-aligned addresses are only supported for legacy CBFSes.
|
|
* Returns 0 on success, otherwise non-zero. */
|
|
int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer,
|
|
const char *name, uint32_t type, uint32_t content_offset);
|
|
|
|
/* Removes an entry from CBFS image. Returns 0 on success, otherwise non-zero. */
|
|
int cbfs_remove_entry(struct cbfs_image *image, const char *name);
|
|
|
|
/* Initializes a new empty (type = NULL) entry with size and name in CBFS image.
|
|
* Returns 0 on success, otherwise (ex, not found) non-zero. */
|
|
int cbfs_create_empty_entry(struct cbfs_file *entry,
|
|
size_t len, const char *name);
|
|
|
|
/* Finds a location to put given content by specified criteria:
|
|
* "page_size" limits the content to fit on same memory page, and
|
|
* "align" specifies starting address alignment.
|
|
* Returns a valid offset, or -1 on failure. */
|
|
int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name,
|
|
uint32_t size, uint32_t page_size, uint32_t align);
|
|
|
|
/* Callback function used by cbfs_walk.
|
|
* Returns 0 on success, or non-zero to stop further iteration. */
|
|
typedef int (*cbfs_entry_callback)(struct cbfs_image *image,
|
|
struct cbfs_file *file,
|
|
void *arg);
|
|
|
|
/* Iterates through all entries in CBFS image, and invoke with callback.
|
|
* Stops if callback returns non-zero values.
|
|
* Returns number of entries invoked. */
|
|
int cbfs_walk(struct cbfs_image *image, cbfs_entry_callback callback, void *arg);
|
|
|
|
/* Primitive CBFS utilities */
|
|
|
|
/* Returns a pointer to the only valid CBFS header in give buffer, otherwise
|
|
* NULL (including when multiple headers were found). If there is a X86 ROM
|
|
* style signature (pointer at 0xfffffffc) found in ROM, it will be selected as
|
|
* the only header.*/
|
|
struct cbfs_header *cbfs_find_header(char *data, size_t size,
|
|
uint32_t forced_offset);
|
|
|
|
/* Returns the first cbfs_file entry in CBFS image by CBFS header (no matter if
|
|
* the entry has valid content or not), otherwise NULL. */
|
|
struct cbfs_file *cbfs_find_first_entry(struct cbfs_image *image);
|
|
|
|
/* Returns next cbfs_file entry (no matter if its content is valid or not), or
|
|
* NULL on failure. */
|
|
struct cbfs_file *cbfs_find_next_entry(struct cbfs_image *image,
|
|
struct cbfs_file *entry);
|
|
|
|
/* Returns ROM address (offset) of entry.
|
|
* This is different from entry->offset (pointer to content). */
|
|
uint32_t cbfs_get_entry_addr(struct cbfs_image *image, struct cbfs_file *entry);
|
|
|
|
/* Returns 1 if valid new-format CBFS (without a master header), otherwise 0. */
|
|
int cbfs_is_valid_cbfs(struct cbfs_image *image);
|
|
|
|
/* Returns 1 if valid legacy CBFS (with a master header), otherwise 0. */
|
|
int cbfs_is_legacy_cbfs(struct cbfs_image *image);
|
|
|
|
/* Returns 1 if entry has valid data (by checking magic number), otherwise 0. */
|
|
int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry);
|
|
|
|
/* Print CBFS component information. */
|
|
int cbfs_print_directory(struct cbfs_image *image);
|
|
int cbfs_print_header_info(struct cbfs_image *image);
|
|
int cbfs_print_entry_info(struct cbfs_image *image, struct cbfs_file *entry,
|
|
void *arg);
|
|
|
|
/* Merge empty entries starting from given entry.
|
|
* Returns 0 on success, otherwise non-zero. */
|
|
int cbfs_merge_empty_entry(struct cbfs_image *image, struct cbfs_file *entry,
|
|
void *arg);
|
|
|
|
#endif
|