/* * This file is part of the coreboot project. * * Copyright 2015 Google Inc. * * 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. */ #include <console/console.h> #include <commonlib/cbfs.h> #include <commonlib/endian.h> #include <commonlib/helpers.h> #include <string.h> #if !defined(ERROR) #define ERROR(x...) printk(BIOS_ERR, "CBFS: " x) #endif #if !defined(LOG) #define LOG(x...) printk(BIOS_INFO, "CBFS: " x) #endif #if defined(IS_ENABLED) #if IS_ENABLED(CONFIG_DEBUG_CBFS) #define DEBUG(x...) printk(BIOS_SPEW, "CBFS: " x) #else #define DEBUG(x...) #endif #elif !defined(DEBUG) #define DEBUG(x...) #endif static size_t cbfs_next_offset(const struct region_device *cbfs, const struct cbfsf *f) { size_t offset; if (f == NULL) return 0; /* The region_device objects store absolute offets over the whole * region. Therefore a relative offset needs to be calculated. */ offset = rdev_relative_offset(cbfs, &f->data); offset += region_device_sz(&f->data); return ALIGN_UP(offset, CBFS_ALIGNMENT); } static int cbfs_end(const struct region_device *cbfs, size_t offset) { if (offset >= region_device_sz(cbfs)) return 1; return 0; } int cbfs_for_each_file(const struct region_device *cbfs, const struct cbfsf *prev, struct cbfsf *fh) { size_t offset; offset = cbfs_next_offset(cbfs, prev); /* Try to scan the entire cbfs region looking for file name. */ while (1) { struct cbfs_file file; const size_t fsz = sizeof(file); DEBUG("Checking offset %zx\n", offset); /* End of region. */ if (cbfs_end(cbfs, offset)) return 1; /* Can't read file. Nothing else to do but bail out. */ if (rdev_readat(cbfs, &file, offset, fsz) != fsz) break; if (memcmp(file.magic, CBFS_FILE_MAGIC, sizeof(file.magic))) { offset++; offset = ALIGN_UP(offset, CBFS_ALIGNMENT); continue; } file.len = read_be32(&file.len); file.offset = read_be32(&file.offset); DEBUG("File @ offset %zx size %x\n", offset, file.len); /* Keep track of both the metadata and the data for the file. */ if (rdev_chain(&fh->metadata, cbfs, offset, file.offset)) break; if (rdev_chain(&fh->data, cbfs, offset + file.offset, file.len)) break; /* Success. */ return 0; } return -1; } size_t cbfs_for_each_attr(void *metadata, size_t metadata_size, size_t last_offset) { struct cbfs_file_attribute *attr; if (!last_offset) { struct cbfs_file *file = metadata; size_t start_offset = read_be32(&file->attributes_offset); if (start_offset <= sizeof(struct cbfs_file) || start_offset + sizeof(*attr) > metadata_size) return 0; return start_offset; } attr = metadata + last_offset; size_t next_offset = last_offset + read_be32(&attr->len); if (next_offset + sizeof(*attr) > metadata_size) return 0; return next_offset; } int cbfsf_decompression_info(struct cbfsf *fh, uint32_t *algo, size_t *size) { size_t metadata_size = region_device_sz(&fh->metadata); void *metadata = rdev_mmap_full(&fh->metadata); size_t offs = 0; if (!metadata) return -1; while ((offs = cbfs_for_each_attr(metadata, metadata_size, offs))) { struct cbfs_file_attr_compression *attr = metadata + offs; if (read_be32(&attr->tag) != CBFS_FILE_ATTR_TAG_COMPRESSION) continue; *algo = read_be32(&attr->compression); *size = read_be32(&attr->decompressed_size); rdev_munmap(&fh->metadata, metadata); return 0; } *algo = CBFS_COMPRESS_NONE; *size = region_device_sz(&fh->data); rdev_munmap(&fh->metadata, metadata); return 0; } int cbfsf_file_type(struct cbfsf *fh, uint32_t *ftype) { const size_t sz = sizeof(*ftype); if (rdev_readat(&fh->metadata, ftype, offsetof(struct cbfs_file, type), sz) != sz) return -1; *ftype = read_be32(ftype); return 0; } int cbfs_locate(struct cbfsf *fh, const struct region_device *cbfs, const char *name, uint32_t *type) { struct cbfsf *prev; LOG("Locating '%s'\n", name); prev = NULL; while (1) { int ret; char *fname; int name_match; const size_t fsz = sizeof(struct cbfs_file); ret = cbfs_for_each_file(cbfs, prev, fh); prev = fh; /* Either failed to read or hit the end of the region. */ if (ret < 0 || ret > 0) break; fname = rdev_mmap(&fh->metadata, fsz, region_device_sz(&fh->metadata) - fsz); if (fname == NULL) break; name_match = !strcmp(fname, name); rdev_munmap(&fh->metadata, fname); if (!name_match) { DEBUG(" Unmatched '%s' at %zx\n", fname, rdev_relative_offset(cbfs, &fh->metadata)); continue; } if (type != NULL) { uint32_t ftype; if (cbfsf_file_type(fh, &ftype)) break; if (*type != 0 && *type != ftype) { DEBUG(" Unmatched type %x at %zx\n", ftype, rdev_relative_offset(cbfs, &fh->metadata)); continue; } // *type being 0 means we want to know ftype. // We could just do a blind assignment but // if type is pointing to read-only memory // that might be bad. if (*type == 0) *type = ftype; } LOG("Found @ offset %zx size %zx\n", rdev_relative_offset(cbfs, &fh->metadata), region_device_sz(&fh->data)); /* Success. */ return 0; } LOG("'%s' not found.\n", name); return -1; } static int cbfs_extend_hash_buffer(struct vb2_digest_context *ctx, void *buf, size_t sz) { return vb2_digest_extend(ctx, buf, sz); } static int cbfs_extend_hash(struct vb2_digest_context *ctx, const struct region_device *rdev) { uint8_t buffer[1024]; size_t sz_left; size_t offset; sz_left = region_device_sz(rdev); offset = 0; while (sz_left) { int rv; size_t block_sz = MIN(sz_left, sizeof(buffer)); if (rdev_readat(rdev, buffer, offset, block_sz) != block_sz) return VB2_ERROR_UNKNOWN; rv = cbfs_extend_hash_buffer(ctx, buffer, block_sz); if (rv) return rv; sz_left -= block_sz; offset += block_sz; } return VB2_SUCCESS; } /* Include offsets of child regions within the parent into the hash. */ static int cbfs_extend_hash_with_offset(struct vb2_digest_context *ctx, const struct region_device *p, const struct region_device *c) { int32_t soffset; int rv; soffset = rdev_relative_offset(p, c); if (soffset < 0) return VB2_ERROR_UNKNOWN; /* All offsets in big endian format. */ write_be32(&soffset, soffset); rv = cbfs_extend_hash_buffer(ctx, &soffset, sizeof(soffset)); if (rv) return rv; return cbfs_extend_hash(ctx, c); } /* Hash in the potential CBFS header sitting at the beginning of the CBFS * region as well as relative offset at the end. */ static int cbfs_extend_hash_master_header(struct vb2_digest_context *ctx, const struct region_device *cbfs) { struct region_device rdev; int rv; if (rdev_chain(&rdev, cbfs, 0, sizeof(struct cbfs_header))) return VB2_ERROR_UNKNOWN; rv = cbfs_extend_hash_with_offset(ctx, cbfs, &rdev); if (rv) return rv; /* Include potential relative offset at end of region. */ if (rdev_chain(&rdev, cbfs, region_device_sz(cbfs) - sizeof(int32_t), sizeof(int32_t))) return VB2_ERROR_UNKNOWN; return cbfs_extend_hash_with_offset(ctx, cbfs, &rdev); } int cbfs_vb2_hash_contents(const struct region_device *cbfs, enum vb2_hash_algorithm hash_alg, void *digest, size_t digest_sz) { struct vb2_digest_context ctx; int rv; struct cbfsf f; struct cbfsf *prev; struct cbfsf *fh; rv = vb2_digest_init(&ctx, hash_alg); if (rv) return rv; rv = cbfs_extend_hash_master_header(&ctx, cbfs); if (rv) return rv; prev = NULL; fh = &f; while (1) { uint32_t ftype; rv = cbfs_for_each_file(cbfs, prev, fh); prev = fh; if (rv < 0) return VB2_ERROR_UNKNOWN; /* End of CBFS. */ if (rv > 0) break; rv = cbfs_extend_hash_with_offset(&ctx, cbfs, &fh->metadata); if (rv) return rv; /* Include data contents in hash if file is non-empty. */ if (cbfsf_file_type(fh, &ftype)) return VB2_ERROR_UNKNOWN; if (ftype == CBFS_TYPE_DELETED || ftype == CBFS_TYPE_DELETED2) continue; rv = cbfs_extend_hash_with_offset(&ctx, cbfs, &fh->data); if (rv) return rv; } return vb2_digest_finalize(&ctx, digest, digest_sz); }