static void
dump_core_tlv(const struct flash_area *fa, uint32_t *off,
struct coredump_tlv *tlv, void *data)
{
flash_area_write(fa, *off, tlv, sizeof(*tlv));
*off += sizeof(*tlv);
flash_area_write(fa, *off, data, tlv->ct_len);
*off += tlv->ct_len;
}
/**
* Deletes the main image version number from the boot vector.
* This must be called by the app to confirm that it is ok to keep booting
* to this image.
*
* @return 0 on success; nonzero on failure.
*/
int
boot_vect_write_main(void)
{
const struct flash_area *fap;
uint32_t off;
int rc;
uint8_t val;
/*
* Write to slot 0.
*/
rc = flash_area_open(FLASH_AREA_IMAGE_0, &fap);
if (rc) {
return rc;
}
off = fap->fa_size - sizeof(struct boot_img_trailer);
off += (sizeof(uint32_t) + sizeof(uint8_t));
rc = flash_area_read(fap, off, &val, sizeof(val));
if (!rc && val == 0xff) {
val = 0;
rc = flash_area_write(fap, off, &val, sizeof(val));
}
return rc;
}
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);
}
static int
log_fcb_append(struct log *log, void *buf, int len)
{
struct fcb *fcb;
struct fcb_entry loc;
struct fcb_log *fcb_log;
int rc;
fcb_log = (struct fcb_log *)log->l_log->log_arg;
fcb = fcb_log->fl_fcb;
while (1) {
rc = fcb_append(fcb, len, &loc);
if (rc == 0) {
break;
}
if (rc != FCB_ERR_NOSPACE) {
goto err;
}
if (log->l_log->log_rtr_erase && fcb_log->fl_entries) {
rc = log->l_log->log_rtr_erase(log, fcb_log);
if (rc) {
goto err;
}
continue;
}
rc = fcb_rotate(fcb);
if (rc) {
goto err;
}
}
rc = flash_area_write(loc.fe_area, loc.fe_data_off, buf, len);
if (rc) {
goto err;
}
rc = fcb_append_finish(fcb, &loc);
err:
return (rc);
}
/**
* Write the test image version number from the boot vector.
*
* @return 0 on success; nonzero on failure.
*/
int
boot_vect_write_test(int slot)
{
const struct flash_area *fap;
uint32_t off;
uint32_t magic;
int rc;
rc = flash_area_open(slot, &fap);
if (rc) {
return rc;
}
off = fap->fa_size - sizeof(struct boot_img_trailer);
magic = BOOT_IMG_MAGIC;
rc = flash_area_write(fap, off, &magic, sizeof(magic));
flash_area_close(fap);
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));
}
