新建项目

middleware/easylogger/plugins/flash/elog_flash.c

@@ -0,0 +1,308 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015-2017, Armink, <armink.ztl@gmail.com>
+ *
+ * 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.
+ *
+ * Function: Save log to flash. Must use EasyFlash(https://github.com/armink/EasyFlash) library.
+ * Created on: 2015-06-05
+ */
+
+#define LOG_TAG    "elog.flash"
+
+#include "elog_flash.h"
+#include <easyflash.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+/* flash log buffer */
+static char log_buf[ELOG_FLASH_BUF_SIZE] = { 0 };
+/* current flash log buffer write position  */
+static size_t cur_buf_size = 0;
+#endif
+
+/* initialize OK flag */
+static bool init_ok = false;
+/* the flash log buffer lock enable or disable. default is enable */
+static bool log_buf_lock_enabled = true;
+/* the flash log buffer is locked before enable. */
+static bool log_buf_is_locked_before_enable = false;
+/* the flash log buffer is locked before disable. */
+static bool log_buf_is_locked_before_disable = false;
+static void log_buf_lock(void);
+static void log_buf_unlock(void);
+
+/**
+ * EasyLogger flash log plugin initialize.
+ *
+ * @return result
+ */
+ElogErrCode elog_flash_init(void) {
+    ElogErrCode result = ELOG_NO_ERR;
+
+    /* buffer size must be word alignment */
+    ELOG_ASSERT(ELOG_FLASH_BUF_SIZE % 4 == 0);
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+    /* initialize current flash log buffer write position */
+    cur_buf_size = 0;
+#endif
+
+    /* port initialize */
+    elog_flash_port_init();
+    /* initialize OK */
+    init_ok = true;
+
+    return result;
+}
+
+/**
+ * Read and output log which saved in flash.
+ *
+ * @param index index for saved log. @note It will auto word alignment.
+ *        Minimum index is 0.
+ *        Maximum index is log used flash total size - 1.
+ * @param size
+ */
+void elog_flash_output(size_t index, size_t size) {
+    /* 128 bytes buffer */
+    uint32_t buf[32] = { 0 };
+    size_t log_total_size = ef_log_get_used_size();
+    size_t buf_size = sizeof(buf);
+    size_t read_size = 0, read_overage_size = 0;
+
+    /* word alignment for index */
+    index = index / 4 * 4;
+    if (index + size > log_total_size) {
+        log_i("The output position and size is out of bound. The max size is %d.", log_total_size);
+        return;
+    }
+    /* must be call this function after initialize OK */
+    ELOG_ASSERT(init_ok);
+    /* lock flash log buffer */
+    log_buf_lock();
+    /* output all flash saved log. It will use filter */
+    while (true) {
+        if (read_size + buf_size < size) {
+            ef_log_read(index + read_size, buf, buf_size);
+            elog_flash_port_output((const char*)buf, buf_size);
+            read_size += buf_size;
+        } else {
+            /* flash read is word alignment */
+            if ((size - read_size) % 4 == 0) {
+                read_overage_size = 0;
+            } else {
+                read_overage_size = 4 - ((size - read_size) % 4);
+            }
+            ef_log_read(index + read_size, buf, size - read_size + read_overage_size);
+            elog_flash_port_output((const char*) buf + read_overage_size, size - read_size);
+            /* output newline sign */
+            elog_flash_port_output(ELOG_NEWLINE_SIGN, strlen(ELOG_NEWLINE_SIGN));
+            break;
+        }
+    }
+    /* unlock flash log buffer */
+    log_buf_unlock();
+}
+
+/**
+ * Read and output all log which saved in flash.
+ */
+void elog_flash_output_all(void) {
+    elog_flash_output(0, ef_log_get_used_size());
+}
+
+/**
+ * Read and output recent log which saved in flash.
+ *
+ * @param size recent log size
+ */
+void elog_flash_output_recent(size_t size) {
+    size_t max_size = ef_log_get_used_size();
+
+    if (size == 0) {
+        return;
+    }
+
+    if (size > max_size) {
+        log_i("The output size is out of bound. The max size is %d.", max_size);
+    } else {
+        elog_flash_output(max_size - size, size);
+    }
+}
+
+/**
+ * Write log to flash. The flash write use buffer mode.
+ *
+ * @param log log
+ * @param size log size
+ */
+void elog_flash_write(const char *log, size_t size) {
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+    size_t write_size = 0, write_index = 0;
+#else
+    size_t write_size_temp = 0;
+    EfErrCode result = EF_NO_ERR;
+    /* write some '\r' for word alignment */
+    char write_overage_c[4] = { '\r', '\r', '\r', '\r' };
+#endif
+
+    /* must be call this function after initialize OK */
+    ELOG_ASSERT(init_ok);
+
+    /* lock flash log buffer */
+    log_buf_lock();
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+    while (true) {
+        if (cur_buf_size + size > ELOG_FLASH_BUF_SIZE) {
+            write_size = ELOG_FLASH_BUF_SIZE - cur_buf_size;
+            elog_memcpy(log_buf + cur_buf_size, log + write_index, write_size);
+            write_index += write_size;
+            size -= write_size;
+            cur_buf_size += write_size;
+            /* unlock flash log buffer */
+            log_buf_unlock();
+            /* write all buffered log to flash, cur_buf_size will reset */
+            elog_flash_flush();
+            /* lock flash log buffer */
+            log_buf_lock();
+        } else {
+            elog_memcpy(log_buf + cur_buf_size, log + write_index, size);
+            cur_buf_size += size;
+            break;
+        }
+    }
+#else
+    /* calculate the word alignment write size */
+    write_size_temp = size / 4 * 4;
+    /* write log to flash */
+    result = ef_log_write((uint32_t *) log, write_size_temp);
+    /* write last word alignment data */
+    if ((result == EF_NO_ERR) && (write_size_temp != size)) {
+        elog_memcpy(write_overage_c, log + write_size_temp, size - write_size_temp);
+        ef_log_write((uint32_t *) write_overage_c, 4);
+    }
+#endif
+
+    /* unlock flash log buffer */
+    log_buf_unlock();
+}
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+/**
+ * write all buffered log to flash
+ */
+void elog_flash_flush(void) {
+    size_t write_overage_size = 0;
+
+    /* must be call this function after initialize OK */
+    ELOG_ASSERT(init_ok);
+    /* lock flash log buffer */
+    log_buf_lock();
+    /* flash write is word alignment */
+    if (cur_buf_size % 4 != 0) {
+        write_overage_size = 4 - (cur_buf_size % 4);
+    }
+    /* fill '\r' for word alignment */
+    memset(log_buf + cur_buf_size, '\r', write_overage_size);
+    /* write all buffered log to flash */
+    ef_log_write((uint32_t *) log_buf, cur_buf_size + write_overage_size);
+    /* reset position */
+    cur_buf_size = 0;
+    /* unlock flash log buffer */
+    log_buf_unlock();
+}
+#endif
+
+/**
+ * clean all log which in flash and ram buffer
+ */
+void elog_flash_clean(void) {
+    EfErrCode clean_result = EF_NO_ERR;
+
+    /* must be call this function after initialize OK */
+    ELOG_ASSERT(init_ok);
+    /* lock flash log buffer */
+    log_buf_lock();
+    /* clean all log which in flash */
+    clean_result = ef_log_clean();
+
+#ifdef ELOG_FLASH_USING_BUF_MODE
+    /* reset position */
+    cur_buf_size = 0;
+#endif
+
+    /* unlock flash log buffer */
+    log_buf_unlock();
+
+    if(clean_result == EF_NO_ERR) {
+        log_i("All logs which in flash is clean OK.");
+    } else {
+        log_e("Clean logs which in flash has an error!");
+    }
+}
+
+/**
+ * enable or disable flash plugin lock
+ * @note disable this lock is not recommended except you want output system exception log
+ *
+ * @param enabled true: enable  false: disable
+ */
+void elog_flash_lock_enabled(bool enabled) {
+    log_buf_lock_enabled = enabled;
+    /* it will re-lock or re-unlock before log buffer lock enable */
+    if (log_buf_lock_enabled) {
+        if (!log_buf_is_locked_before_disable && log_buf_is_locked_before_enable) {
+            /* the log buffer lock is unlocked before disable, and the lock will unlocking after enable */
+            elog_flash_port_lock();
+        } else if (log_buf_is_locked_before_disable && !log_buf_is_locked_before_enable) {
+            /* the log buffer lock is locked before disable, and the lock will locking after enable */
+            elog_flash_port_unlock();
+        }
+    }
+}
+
+/**
+ * lock flash log buffer
+ */
+static void log_buf_lock(void) {
+    if (log_buf_lock_enabled) {
+        elog_flash_port_lock();
+        log_buf_is_locked_before_disable = true;
+    } else {
+        log_buf_is_locked_before_enable = true;
+    }
+}
+/**
+ * unlock flash log buffer
+ */
+static void log_buf_unlock(void) {
+    if (log_buf_lock_enabled) {
+        elog_flash_port_unlock();
+        log_buf_is_locked_before_disable = false;
+    } else {
+        log_buf_is_locked_before_enable = false;
+    }
+}