void
boot_test_util_copy_area(int from_area_idx, int to_area_idx)
{
const struct flash_area *from_area_desc;
const struct flash_area *to_area_desc;
void *buf;
int rc;
from_area_desc = boot_test_area_descs + from_area_idx;
to_area_desc = boot_test_area_descs + to_area_idx;
TEST_ASSERT(from_area_desc->fa_size == to_area_desc->fa_size);
buf = malloc(from_area_desc->fa_size);
TEST_ASSERT(buf != NULL);
rc = flash_area_read(from_area_desc, 0, buf,
from_area_desc->fa_size);
TEST_ASSERT(rc == 0);
rc = flash_area_erase(to_area_desc,
0,
to_area_desc->fa_size);
TEST_ASSERT(rc == 0);
rc = flash_area_write(to_area_desc, 0, buf,
to_area_desc->fa_size);
TEST_ASSERT(rc == 0);
free(buf);
}
void
boot_test_util_swap_areas(int area_idx1, int area_idx2)
{
const struct flash_area *area_desc1;
const struct flash_area *area_desc2;
uint32_t size;
void *buf1;
void *buf2;
int rc;
area_desc1 = boot_test_area_descs + area_idx1;
area_desc2 = boot_test_area_descs + area_idx2;
TEST_ASSERT(area_desc1->fa_size == area_desc2->fa_size);
buf1 = malloc(area_desc1->fa_size);
TEST_ASSERT(buf1 != NULL);
buf2 = malloc(area_desc2->fa_size);
TEST_ASSERT(buf2 != NULL);
rc = flash_area_read(area_desc1, 0, buf1, area_desc1->fa_size);
TEST_ASSERT(rc == 0);
rc = flash_area_read(area_desc2, 0, buf2, area_desc2->fa_size);
TEST_ASSERT(rc == 0);
rc = flash_area_erase(area_desc1, 0, area_desc1->fa_size);
TEST_ASSERT(rc == 0);
rc = flash_area_erase(area_desc2, 0, area_desc2->fa_size);
TEST_ASSERT(rc == 0);
size = boot_test_util_area_write_size(area_idx1, 0, area_desc1->fa_size);
rc = flash_area_write(area_desc1, 0, buf2, size);
TEST_ASSERT(rc == 0);
size = boot_test_util_area_write_size(area_idx2, 0, area_desc2->fa_size);
rc = flash_area_write(area_desc2, 0, buf1, size);
TEST_ASSERT(rc == 0);
free(buf1);
free(buf2);
}
void
fcb_test_wipe(void)
{
int i;
int rc;
struct flash_area *fap;
for (i = 0; i < sizeof(test_fcb_area) / sizeof(test_fcb_area[0]); i++) {
fap = &test_fcb_area[i];
rc = flash_area_erase(fap, 0, fap->fa_size);
TEST_ASSERT(rc == 0);
}
}
void
boot_test_util_init_flash(void)
{
const struct flash_area *area_desc;
int rc;
rc = hal_flash_init();
TEST_ASSERT(rc == 0);
for (area_desc = boot_test_area_descs;
area_desc->fa_size != 0;
area_desc++) {
rc = flash_area_erase(area_desc, 0, area_desc->fa_size);
TEST_ASSERT(rc == 0);
}
}
/**
* Flushes the log while restoring specified number of entries
* using image scratch
* @param src_fcb, dst_fcb
* @return 0 on success; non-zero on error
*/
static int
log_fcb_rtr_erase(struct log *log, void *arg)
{
struct fcb_log *fcb_log;
struct fcb fcb_scratch;
struct fcb *fcb;
const struct flash_area *ptr;
uint32_t offset;
int rc;
rc = 0;
offset = 0;
if (!log) {
rc = -1;
goto err;
}
fcb_log = (struct fcb_log *)arg;
fcb = (struct fcb *)fcb_log;
memset(&fcb_scratch, 0, sizeof(fcb_scratch));
if (flash_area_open(FLASH_AREA_IMAGE_SCRATCH, &ptr)) {
goto err;
}
sector = *ptr;
fcb_scratch.f_sectors = §or;
fcb_scratch.f_sector_cnt = 1;
fcb_scratch.f_magic = 0x7EADBADF;
fcb_scratch.f_version = g_log_info.li_version;
flash_area_erase(§or, 0, sector.fa_size);
rc = fcb_init(&fcb_scratch);
if (rc) {
goto err;
}
/* Calculate offset of n-th last entry */
rc = fcb_offset_last_n(fcb, fcb_log->fl_entries, &offset);
if (rc) {
goto err;
}
/* Copy to scratch */
rc = log_fcb_copy(log, fcb, &fcb_scratch, offset);
if (rc) {
goto err;
}
/* Flush log */
rc = log_fcb_flush(log);
if (rc) {
goto err;
}
/* Copy back from scratch */
rc = log_fcb_copy(log, &fcb_scratch, fcb, 0);
err:
return (rc);
}
void
coredump_dump(void *regs, int regs_sz)
{
struct coredump_header hdr;
struct coredump_tlv tlv;
const struct flash_area *fa;
struct image_version ver;
const struct bsp_mem_dump *mem, *cur;
int area_cnt, i;
uint8_t hash[IMGMGR_HASH_LEN];
uint32_t off;
uint32_t area_off, area_end;
if (coredump_disabled) {
return;
}
if (flash_area_open(FLASH_AREA_CORE, &fa)) {
return;
}
if (flash_area_read(fa, 0, &hdr, sizeof(hdr))) {
return;
}
if (hdr.ch_magic == COREDUMP_MAGIC) {
/*
* Don't override corefile.
*/
return;
}
if (flash_area_erase(fa, 0, fa->fa_size)) {
return;
}
/*
* First put in data, followed by the header.
*/
tlv.ct_type = COREDUMP_TLV_REGS;
tlv._pad = 0;
tlv.ct_len = regs_sz;
tlv.ct_off = 0;
off = sizeof(hdr);
dump_core_tlv(fa, &off, &tlv, regs);
if (imgr_read_info(bsp_imgr_current_slot(), &ver, hash) == 0) {
tlv.ct_type = COREDUMP_TLV_IMAGE;
tlv.ct_len = IMGMGR_HASH_LEN;
dump_core_tlv(fa, &off, &tlv, hash);
}
mem = bsp_core_dump(&area_cnt);
for (i = 0; i < area_cnt; i++) {
cur = &mem[i];
area_off = (uint32_t)cur->bmd_start;
area_end = area_off + cur->bmd_size;
while (area_off < area_end) {
tlv.ct_type = COREDUMP_TLV_MEM;
if (cur->bmd_size > USHRT_MAX) {
tlv.ct_len = SHRT_MAX + 1;
} else {
tlv.ct_len = cur->bmd_size;
}
tlv.ct_off = area_off;
dump_core_tlv(fa, &off, &tlv, (void *)area_off);
area_off += tlv.ct_len;
}
}
hdr.ch_magic = COREDUMP_MAGIC;
hdr.ch_size = off;
flash_area_write(fa, 0, &hdr, sizeof(hdr));
}
