[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/src/bsp/lk/lib/aee/kdump_ext4.c b/src/bsp/lk/lib/aee/kdump_ext4.c
new file mode 100644
index 0000000..3dc3c11
--- /dev/null
+++ b/src/bsp/lk/lib/aee/kdump_ext4.c
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2018 MediaTek Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <lib/mempool.h>
+#include <lib/zlib.h>
+#include <malloc.h>
+#include <platform/mtk_wdt.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string.h>
+
+#include "aee.h"
+#include "kdump.h"
+#include "kdump_sdhc.h"
+#include "lib/cksum.h"
+
+#define BLKSIZE 4096
+#define MAX_CONTINUE 16 // only 1MB memory for lk
+#define EXSPACE (BLKSIZE*MAX_CONTINUE) // Expect continue space
+
+uint64_t lba_marker_time;
+struct __attribute__((__packed__)) marked_block_data {
+ uint32_t lba;
+ uint64_t zero_padding[510];
+ uint64_t timestamp;
+ uint32_t crc;
+} bdata;
+
+struct mrdump_lba_handle {
+ struct mrdump_dev *dumpdev;
+ uint64_t allocsize;
+ uint64_t filesize;
+ unsigned int wlba;
+ unsigned int rlba;
+ int bidx;
+ int midx;
+ unsigned int blknum;
+ unsigned int block_lba[1024];
+ uint8_t data[EXSPACE];
+};
+
+static uint64_t ext4_lba_to_block_offset(uint32_t lba)
+{
+ return (uint64_t)lba * (uint64_t)BLKSIZE;
+}
+
+#ifdef MTK_USERIMAGES_USE_F2FS
+static bool check_block_valid(const struct mrdump_lba_handle *handle, uint32_t lba)
+{
+ mtk_wdt_restart();
+ if (!handle->dumpdev->read(handle->dumpdev, ext4_lba_to_block_offset(lba), (uint8_t *)&bdata, BLKSIZE)) {
+ voprintf_error(" Read BlockData failed\n");
+ return false;
+ }
+
+ if (bdata.lba != lba) {
+ voprintf_error(" Read BlockData LBA failed (c:%08x, v:%08x)\n", bdata.lba, lba);
+ return false;
+ }
+
+ if (bdata.timestamp != lba_marker_time) {
+ voprintf_error(" Read BlockData timestamp failed (c:%016x, v:%016x)\n", bdata.timestamp, lba_marker_time);
+ return false;
+ }
+
+ unsigned int crcval = crc32(0, Z_NULL, 0);
+ crcval = crc32(crcval, (void *)&bdata, (BLKSIZE - 4));
+ if (bdata.crc != crcval) {
+ voprintf_error("%s: Get BlockData crc32 error (c:%08x, v:%08x)\n", __func__, crcval, bdata.crc);
+ return false;
+ }
+
+ return true;
+}
+#endif
+
+static int Get_Next_bidx(struct mrdump_lba_handle *handle, unsigned int moves)
+{
+ unsigned int mycrc;
+
+ if (handle->bidx == 1022) {
+ handle->rlba = handle->block_lba[handle->bidx];
+ if (!handle->dumpdev->read(handle->dumpdev, ext4_lba_to_block_offset(handle->rlba), (uint8_t *)handle->block_lba, BLKSIZE)) {
+ voprintf_error(" SDCard: Reading BlockLBA failed.\n");
+ return -1;
+ }
+ // check crc32
+ mycrc = crc32(0, Z_NULL, 0);
+ mycrc = crc32(mycrc, (void *)handle->block_lba, (BLKSIZE-4));
+ if (mycrc != handle->block_lba[1023]) {
+ voprintf_error(" Get next index crc32 error!\n");
+ return -1;
+ }
+ handle->bidx = 0;
+ } else {
+ handle->bidx+=moves;
+ }
+ return handle->bidx;
+}
+
+unsigned int Num_to_Join(const struct mrdump_lba_handle *handle, unsigned int idx)
+{
+ unsigned int i, j;
+ uint32_t lba;
+
+ for (i=0, j=0; i<MAX_CONTINUE; i++) {
+ lba = handle->block_lba[idx+i];
+ if ((lba - handle->block_lba[idx]) == i) {
+ mtk_wdt_restart();
+#ifdef MTK_USERIMAGES_USE_F2FS
+ if (!check_block_valid(handle, lba)) {
+ voprintf_error(" BlockData Verification failed\n");
+ return 0;
+ }
+#endif
+ j++;
+ continue;
+ }
+ break;
+ }
+ return j;
+}
+
+// Store data and write when buffer(handle's data) full
+// return left length to avoid recursive call. --> turn to for loop
+static int Do_Store_or_Write(struct mrdump_lba_handle *handle, uint8_t *buf, uint32_t Length)
+{
+ int total;
+ unsigned int leftspace, mylen, reval;
+
+ total = BLKSIZE * handle->blknum;
+ leftspace = total - handle->midx;
+
+ // Check Length
+ if (Length > leftspace) {
+ mylen = leftspace;
+ reval = Length - leftspace;
+ } else {
+ mylen = Length;
+ reval = 0;
+ }
+
+ // Store
+ while (mylen > 0) {
+ handle->data[handle->midx] = *buf;
+ handle->midx++;
+ buf++;
+ mylen--;
+ }
+
+ // Write
+ if (handle->midx == total) {
+ if (!handle->dumpdev->write(handle->dumpdev, ext4_lba_to_block_offset(handle->wlba), handle->data, total)) {
+ voprintf_error(" SDCard: Write dump data failed.\n");
+ return -1;
+ }
+ handle->bidx = Get_Next_bidx(handle, handle->blknum);
+ if (handle->bidx < 0) {
+ voprintf_error(" SDCard: Reading bidx failed.\n");
+ return -1;
+ }
+ if (handle->bidx == 1022) {
+ handle->bidx = Get_Next_bidx(handle, handle->blknum);
+ if (handle->bidx < 0) {
+ voprintf_error(" SDCard: Reading 1022 bidx failed.\n");
+ return -1;
+ }
+ }
+ handle->blknum = Num_to_Join(handle, handle->bidx);
+ if (handle->blknum == 0)
+ return -1;
+ handle->wlba = handle->block_lba[handle->bidx];
+ handle->midx = 0;
+ }
+ return reval;
+}
+
+static int lba_write_cb(void *opaque_handle, void *buf, int size)
+{
+ unsigned int len, moves;
+ int ret;
+ uint8_t *Ptr;
+
+ struct mrdump_lba_handle *handle = opaque_handle;
+
+ if ((handle->filesize + size) > handle->allocsize) {
+ voprintf_error(" dump size > allocated size. file-size %lld allocate-size %lld\n", handle->filesize + size, handle->allocsize);
+ return -1;
+ }
+ handle->filesize += size;
+
+ // End of File, write the left Data in handle data buffer...
+ if ((buf == NULL) && (size == 0)) {
+ if (!handle->dumpdev->write(handle->dumpdev, ext4_lba_to_block_offset(handle->wlba), handle->data, handle->midx)) {
+ voprintf_error(" SDCard: Write dump data failed.\n");
+ return -1;
+ }
+ return 0;
+ }
+
+ // buf should not be NULL if not EOF
+ if (buf == NULL)
+ return -1;
+
+ // process of Store and write
+ len = size;
+ ret = len;
+ Ptr = (uint8_t *)buf;
+ while (1) {
+ ret = Do_Store_or_Write(handle, Ptr, len);
+ if (ret < 0) {
+ voprintf_error(" SDCard: Store and Write failed.\n");
+ return -1;
+ } else if (ret==0) {
+ break;
+ } else {
+ moves = len - ret;
+ Ptr += moves;
+ len = ret;
+ }
+ }
+ return size;
+}
+
+static inline uint16_t paf_version_extract(uint8_t pafinfo[MRDUMP_PAF_TOTAL_SIZE])
+{
+ return pafinfo[0] + (pafinfo[1] << 8);
+}
+
+static void dump_paf_info(uint8_t InfoLBA[MRDUMP_PAF_TOTAL_SIZE], const char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg);
+ voprintf('E', msg, ap);
+ va_end(ap);
+
+ uint32_t paf_version = paf_version_extract(InfoLBA);
+ uint32_t paf_info_lba = *(uint32_t *)(InfoLBA + MRDUMP_PAF_INFO_LBA);
+ uint32_t paf_addr_lba = *(uint32_t *)(InfoLBA + MRDUMP_PAF_ADDR_LBA);
+ uint64_t paf_alloc_size = *(uint64_t *)(InfoLBA + MRDUMP_PAF_ALLOCSIZE);
+ uint64_t paf_coredump_size = *(uint64_t *)(InfoLBA + MRDUMP_PAF_COREDUMPSIZE);
+ uint64_t paf_timestamp = *(uint64_t *)(InfoLBA + MRDUMP_PAF_TIMESTAMP);
+ uint32_t paf_crc32 = *(uint32_t *)(InfoLBA + MRDUMP_PAF_CRC32);
+
+ voprintf_info(" pafile ver %u info-lba %u addr-lba %u alloc-size %llu coredump-size %llu timestamp %llx crc %x\n",
+ paf_version, paf_info_lba, paf_addr_lba, paf_alloc_size, paf_coredump_size, paf_timestamp, paf_crc32);
+}
+
+int mrdump_ext4_output(const struct mrdump_control_block *mrdump_cb, const struct kzip_addlist *memlist, struct mrdump_dev *mrdump_dev)
+{
+ uint8_t InfoLBA[MRDUMP_PAF_TOTAL_SIZE];
+ unsigned int mycrc;
+
+ if (mrdump_dev == NULL) {
+ return -1;
+ }
+
+ voprintf_info("Output to EXT4 Partition %s\n", mrdump_dev->name);
+
+ // pre-work for ext4 LBA
+ bzero(InfoLBA, sizeof(InfoLBA));
+
+ // Error 1. InfoLBA starting address not available
+ if (mrdump_cb->output_fs_lbaooo == 0) {
+ voprintf_error(" Pre-Allocate has no LBA markers(lbaooo=%u). RAM-Dump stop!\n", mrdump_cb->output_fs_lbaooo);
+ return -1;
+ }
+ if (!mrdump_dev->read(mrdump_dev, ext4_lba_to_block_offset(mrdump_cb->output_fs_lbaooo), (uint8_t *)InfoLBA, sizeof(InfoLBA))) {
+ voprintf_error(" SDCard: Reading InfoLBA failed.\n");
+ return -1;
+ }
+
+ uint32_t paf_version = paf_version_extract(InfoLBA);
+ uint32_t paf_info_lba = *(uint32_t *)(InfoLBA + MRDUMP_PAF_INFO_LBA);
+ uint32_t paf_addr_lba = *(uint32_t *)(InfoLBA + MRDUMP_PAF_ADDR_LBA);
+ uint64_t paf_alloc_size = *(uint64_t *)(InfoLBA + MRDUMP_PAF_ALLOCSIZE);
+ uint64_t paf_coredump_size = *(uint64_t *)(InfoLBA + MRDUMP_PAF_COREDUMPSIZE);
+ uint64_t paf_timestamp = *(uint64_t *)(InfoLBA + MRDUMP_PAF_TIMESTAMP);
+ uint32_t paf_info_crc32 = *(uint32_t *)(InfoLBA + MRDUMP_PAF_CRC32);
+
+ if (paf_version != MRDUMP_PAF_VERSION) {
+ dump_paf_info(InfoLBA, " Unsupport PAF version %d (expected: %d)\n", paf_version, MRDUMP_PAF_VERSION);
+ return -1;
+ }
+ // Error 3. InfoLBA[EXT4_1ST_LBA] should be mrdump_cb->output_fs_lbaooo
+ if (mrdump_cb->output_fs_lbaooo != paf_info_lba) {
+ dump_paf_info(InfoLBA, " LBA Starting Address Error(LBA0=%u)! Abort!\n", paf_info_lba);
+ return -1;
+ }
+
+ // Error 4. EXT4_CORE_DUMP_SIZE is not zero --> want to hold 1st dump
+ if (paf_coredump_size != 0) {
+ dump_paf_info(InfoLBA, " CORE DUMP SIZE is not Zero! Abort!(coresize=%llu)\n", paf_coredump_size);
+ return -1;
+ }
+
+ // Error 5. EXT4_USER_FILESIZE is zero
+ if (paf_alloc_size == 0) {
+ dump_paf_info(InfoLBA, " Allocate file with zero size. Abort!(filesize=%llu)\n", paf_alloc_size);
+ return -1;
+ }
+
+ // get lba_marker_time as timestamp
+ lba_marker_time = paf_timestamp;
+
+ // Error 2. CRC not matched
+ mycrc = crc32(0L, Z_NULL, 0);
+ mycrc = crc32(mycrc, (const unsigned char *)InfoLBA, sizeof(InfoLBA) - 4);
+ if (mycrc != paf_info_crc32) {
+ dump_paf_info(InfoLBA, " InfoLBA CRC32 Error! Abort! (CRC1=0x%08x, CRC2=0x%08x)\n", mycrc, paf_info_crc32);
+ return -1;
+ }
+
+ //struct mrdump_lba_handle *handle = memalign(16, sizeof(struct mrdump_lba_handle));
+ /* return is auto align to CACHE_LINE: which is 64 */
+ struct mrdump_lba_handle *handle = mempool_alloc(sizeof(struct mrdump_lba_handle), MEMPOOL_ANY);
+ if ((handle == NULL) || (((unsigned long long)handle) & 0xf)) {
+ voprintf_error("No enough memory or alloc memory not align 16B\n");
+ return -1;
+ }
+ memset(handle, 0, sizeof(struct mrdump_lba_handle));
+ handle->dumpdev = mrdump_dev;
+ handle->rlba = mrdump_cb->output_fs_lbaooo;
+ handle->allocsize = paf_alloc_size;
+
+ // Starting Dumping Data
+ handle->rlba = paf_addr_lba;
+ if (!handle->dumpdev->read(handle->dumpdev, ext4_lba_to_block_offset(handle->rlba), (uint8_t *)handle->block_lba, BLKSIZE)) {
+ dump_paf_info(InfoLBA, " SDCard: Reading BlockLBA error.\n");
+ mempool_free(handle);
+ return -1;
+ }
+ handle->wlba = handle->block_lba[handle->midx];
+ handle->blknum = Num_to_Join(handle, handle->bidx);
+ if (handle->blknum == 0) {
+ voprintf_error("No continuous space.\n");
+ mempool_free(handle);
+ return -1;
+ }
+
+ voprintf_info(" Pre-Allocate starts at LBA: %u\n", paf_info_lba);
+ voprintf_info(" SYS_COREDUMP starts at LBA: %u\n", handle->wlba);
+
+ mtk_wdt_restart();
+
+ bool ok = true;
+ mtk_wdt_restart();
+
+ struct kzip_file *zf = kzip_open(handle, lba_write_cb);
+ if (zf != NULL) {
+ if (!kzip_add_file(zf, memlist, "SYS_COREDUMP")) {
+ ok = false;
+ }
+ mtk_wdt_restart();
+ kzip_close(zf);
+ lba_write_cb(handle, NULL, 0); /* really write onto emmc of the last part */
+ zf = NULL;
+ } else {
+ ok = false;
+ }
+
+ if (!ok) {
+ mempool_free(handle);
+ return -1;
+ }
+
+ voprintf_info(" SYS_COREDUMP ends at LBA: %u\n", handle->wlba);
+ voprintf_info(" Zip COREDUMP size is: %u\n", handle->filesize);
+
+ // Record File Size...
+ *(uint64_t *)(InfoLBA + MRDUMP_PAF_COREDUMPSIZE) = handle->filesize;
+
+ mycrc = crc32(0L, Z_NULL, 0);
+ *(uint32_t *)(InfoLBA + MRDUMP_PAF_CRC32) = crc32(mycrc, (const unsigned char *)InfoLBA, MRDUMP_LBA_DATAONLY);
+ if (!handle->dumpdev->write(handle->dumpdev, ext4_lba_to_block_offset(paf_info_lba), (uint8_t *)InfoLBA, sizeof(InfoLBA))) {
+ voprintf_error(" SDCard: Write InfoLBA error.\n");
+ mempool_free(handle);
+ return -1;
+ }
+ mempool_free(handle);
+
+ mtk_wdt_restart();
+ mrdump_status_ok("OUTPUT:%s\nMODE:%s\n", "EXT4_DATA", mrdump_mode2string(mrdump_cb->crash_record.reboot_mode));
+ return 0;
+}
+