// for ext4 int ext4_dump_read(part_t *part, unsigned char* buf, uint64_t offset, uint32_t len) { #ifdef MTK_GPT_SCHEME_SUPPORT if ((offset / BLK_SIZE + len / BLK_SIZE) >= part->nr_sects) { voprintf_error("GPT: Read %s partition overflow, size%lu, block %lu\n", part->info->name, offset / BLK_SIZE, part->nr_sects); return 0; } #else if ((offset / BLK_SIZE + len / BLK_SIZE) >= part->blknum) { voprintf_error("Read %s partition overflow, size%lu, block %lu\n", part->name, offset / BLK_SIZE, part->blknum); return 0; } #endif #ifdef MTK_NEW_COMBO_EMMC_SUPPORT #ifdef MTK_GPT_SCHEME_SUPPORT return emmc_read(part->part_id, (part->start_sect * BLK_SIZE) + offset, buf, len) == len; #else return emmc_read(part->part_id, (part->startblk * BLK_SIZE) + offset, buf, len) == len; #endif #else #ifdef MTK_GPT_SCHEME_SUPPORT return emmc_read((part->start_sect * BLK_SIZE) + offset, buf, len) == len; #else return emmc_read((part->startblk * BLK_SIZE) + offset, buf, len) == len; #endif #endif }
bool card_dump_write(const part_t *part, const void *buf, uint64_t offset, uint32_t len) { #ifdef MTK_GPT_SCHEME_SUPPORT if ((offset / BLK_SIZE + len / BLK_SIZE) >= part->nr_sects) { voprintf_error("Write to %s partition overflow, size %lu, block %lu\n", part->info->name, offset / BLK_SIZE, part->nr_sects); return 0; } #else if ((offset / BLK_SIZE + len / BLK_SIZE) >= part->blknum) { voprintf_error("Write to %s partition overflow, size %lu, block %lu\n", part->name, offset / BLK_SIZE, part->blknum); return 0; } #endif if (len % BLK_SIZE != 0) { voprintf_error("Write to partition size/offset not align, offset %lld elen %lu\n", offset, len); return 0; } #ifdef MTK_NEW_COMBO_EMMC_SUPPORT #ifdef MTK_GPT_SCHEME_SUPPORT bool retval = emmc_write(part->part_id, (part->start_sect * BLK_SIZE) + offset, (unsigned char *)buf, len) == len; #else bool retval = emmc_write(part->part_id, (part->startblk * BLK_SIZE) + offset, (unsigned char *)buf, len) == len; #endif #else #ifdef MTK_GPT_SCHEME_SUPPORT bool retval = emmc_write((part->start_sect * BLK_SIZE) + offset, (unsigned char *)buf, len) == len; #else bool retval = emmc_write((part->startblk * BLK_SIZE) + offset, (unsigned char *)buf, len) == len; #endif #endif if (!retval) { voprintf_error("EMMC write failed %d\n", len); } return retval; }
struct mrdump_dev *mrdump_dev_emmc_ext4(void) { struct mrdump_dev *dev = malloc(sizeof(struct mrdump_dev)); part_t *ext4part = mrdump_get_ext4_partition(); if (ext4part == NULL) { voprintf_error("No EXT4 partition found!\n"); return NULL; } dev->name = "emmc"; dev->handle = ext4part; dev->read = mrdump_dev_ext4_read; dev->write = mrdump_dev_ext4_write; return dev; }
struct mrdump_dev *mrdump_dev_emmc_vfat(void) { struct mrdump_dev *dev = malloc(sizeof(struct mrdump_dev)); part_t *fatpart = card_dump_init(0, "intsd"); if (fatpart == NULL) { voprintf_error("No VFAT partition found!\n"); return NULL; } dev->name = "emmc"; dev->handle = fatpart; dev->read = mrdump_dev_emmc_read; dev->write = mrdump_dev_emmc_write; return dev; }
static void kdump_ui(struct mrdump_control_block *mrdump_cblock) { video_clean_screen(); video_set_cursor(0, 0); mrdump_status_error("Unknown error\n"); voprintf_info("Kdump triggerd by '%s'\n", mrdump_mode2string(mrdump_cblock->crash_record.reboot_mode)); struct aee_timer elapse_time; aee_timer_init(&elapse_time); uint32_t total_dump_size = memory_size(); aee_timer_start(&elapse_time); switch (mrdump_cblock->machdesc.output_device) { case MRDUMP_DEV_NULL: kdump_null_output(mrdump_cblock, total_dump_size); break; #if 0 case MRDUMP_DEV_SDCARD: kdump_sdcard_output(mrdump_cblock, total_dump_size); break; #endif case MRDUMP_DEV_EMMC: kdump_emmc_output(mrdump_cblock, total_dump_size); break; default: voprintf_error("Unknown device id %d\n", mrdump_cblock->machdesc.output_device); } aee_timer_stop(&elapse_time); voprintf_info("Reset count down %d ...\n", MRDUMP_DELAY_TIME); mtk_wdt_restart(); int timeout = MRDUMP_DELAY_TIME; while(timeout-- >= 0) { mdelay(1000); mtk_wdt_restart(); voprintf_info("\rsec %d", timeout); } aee_mrdump_flush_cblock(); video_clean_screen(); video_set_cursor(0, 0); }
bool kzip_add_file(struct kzip_file *zfile, const struct kzip_memlist *memlist, const char *zfilename) { int ret, flush; z_stream strm; struct aee_timer zip_time; if (zfile->entries_num >= KZIP_ENTRY_MAX) { voprintf_error("Too manry zip entry %d\n", zfile->entries_num); return false; } voprintf_debug("%s: zf %p(%p) %s\n", __func__, zfile, zfile->write_cb, zfilename); struct kzip_entry *zentry = &zfile->zentries[zfile->entries_num++]; zentry->filename = strdup(zfilename); zentry->localheader_offset = zfile->current_size; zentry->level = DEF_MEM_LEVEL; KZIP_DEBUG("%s: write local header\n", __func__); uint8_t zip_localheader[128]; int hsize = put_localheader(zip_localheader, zfilename, DEF_MEM_LEVEL); if (kzip_write_current(zfile, zip_localheader, hsize) != hsize) { return false; } KZIP_DEBUG("%s: init compressor\n", __func__); /* allocate deflate state */ strm.workspace = malloc(zlib_deflate_workspacesize(-MAX_WBITS, DEF_MEM_LEVEL)); ret = zlib_deflateInit2(&strm, zentry->level, Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); if (ret != Z_OK) { voprintf_error("zlib compress init failed\n"); free(strm.workspace); return false; } uint8_t *out = malloc(CHUNK); aee_timer_init(&zip_time); aee_timer_start(&zip_time); /* compress until end of file */ do { flush = (memlist->size == 0) ? Z_FINISH : Z_NO_FLUSH; KZIP_DEBUG("-- Compress memory %x, size %d\n", memlist->address, memlist->size); strm.avail_in = memlist->size; strm.next_in = memlist->address; /* run deflate() on input until output buffer not full, finish compression if all of source has been read in */ do { strm.avail_out = CHUNK; strm.next_out = out; ret = zlib_deflate(&strm, flush); /* no bad return value */ assert(ret != Z_STREAM_ERROR); /* state not clobbered */ int have = CHUNK - strm.avail_out; if (have > 0) { aee_timer_stop(&zip_time); if (kzip_write_current(zfile, out, have) != have) { goto error; } aee_timer_start(&zip_time); } } while (strm.avail_out == 0); assert(strm.avail_in == 0); /* all input will be used */ memlist++; /* done when last data in file processed */ } while (flush != Z_FINISH); assert(ret == Z_STREAM_END); /* stream will be complete */ /* clean up and return */ (void)zlib_deflateEnd(&strm); free(strm.workspace); free(out); aee_timer_stop(&zip_time); voprintf_info("Zip time: %d sec\n", zip_time.acc_ms / 1000); zentry->comp_size = strm.total_out; zentry->uncomp_size = strm.total_in; zentry->crc32 = strm.crc32 ^ 0xffffffffUL; return true; error: free(strm.workspace); free(out); (void)zlib_deflateEnd(&strm); return false; }