T536_DTU/app_public/fuxi_public/rt_lite/source/rt_log.c

/******************************************************************************
版权所有：
文件名称：	rt_log.c
文件版本：	01.01
创建作者:	sunxi
创建日期：	2020-6-18
功能说明：	日志记录
其它说明：	没有资源竞争保护处理，只能在大循环级别使用。
修改记录：
*/
#include <rt.h>
#include "my_rtc.h"
#include <semaphore.h>

struct log_file g_log_file[] =
    {
        {"/app/data/log_err.txt",       50 * 1024, 0, 0},
        {"/app/data/log_operate.txt",   50 * 1024, 0, 0},
        {"/app/data/log_soe.txt",       50 * 1024, 0, 0},
        {"/app/data/log_yx.txt",        50 * 1024, 0, 0},
        {"/app/data/log_printf.txt",    100 * 1024, 0, 0},
	    {"/app/data/log_fixset.txt",    50 * 1024, 0, 0},
};

#define LOG_FILE_NUM ((int)(sizeof(g_log_file) / sizeof(g_log_file[0])))
#define LOG_FILE_BUFSIZE 1024

int g_logfile_update[LOG_FILE_NUM];
static char writebuf[LOG_FILE_NUM][LOG_FILE_BUFSIZE];     // 数据缓存区
static int writebuf_count[LOG_FILE_NUM];                  // 缓存已存字节数
static char g_malloc_buf[LOG_FILE_NUM][LOG_FILE_BUFSIZE]; // 数据缓存区

sem_t log_sem_buf[LOG_FILE_NUM]; // 信号量 对空指针进行读写操作会导致编译错误
static sem_t *log_sem[LOG_FILE_NUM];

int sem_for_type = 0;
int log_init(void)
{
    int i, j, file_length, max_length;
    char *file_buf;
    off_t pos;
    int err, ret;
    int len;

    pos = 0;

    // 找到最大的文件长度
    max_length = 0;
    for (i = 0; i < LOG_FILE_NUM; i++)
    {
        log_sem[i] = &log_sem_buf[i];
        if (g_log_file[i].size > max_length)
        {
            max_length = g_log_file[i].size;
        }

        writebuf_count[i] = 0; // 清零
        // if(sem_init(log_sem[i], sem_for_type, 0))
        if (sem_init(log_sem[i], sem_for_type, 1)) // 先创建一个1值信号量
            return -1;
    }

    // 分配内存
    file_buf = (char *)rt_malloc(max_length);
    if (file_buf == NULL)
    {
        return -111;
    }

    // 循环打开文件，找到00的位置
    err = 0;
    for (i = 0; i < LOG_FILE_NUM; i++)
    {
        // 打开文件
        g_log_file[i].handle = rt_file_open(g_log_file[i].name, O_CREAT | O_RDWR, 0);
        if (IS_ERR(g_log_file[i].handle))
        {
            printf("%s open error!\r\n", g_log_file[i].name);
            err++;
            continue;
        }
        len = rt_file_getfile_size(g_log_file[i].handle);
        if (len < 0)
        {
            printf("%s fstat error!\r\n", g_log_file[i].name);
            rt_file_close(g_log_file[i].handle, 0);
            g_log_file[i].handle = -1;
            err++;
            continue;
        }

        // 得到文件长度
        file_length = len;

        // 读出文件内容
        pos = 0;
        ret = rt_file_read(g_log_file[i].handle, file_buf, file_length, &pos);
        if (ret != file_length) // 读出log内容
        {
            rt_file_close(g_log_file[i].handle, 0);
            g_log_file[i].handle = -1;

            printf("%s read error:file_length=%d,ret=%d!\r\n", g_log_file[i].name, file_length, ret);
            err++;
            continue;
        }

        g_log_file[i].offset = 0;

        // 如果文件长度，偏移量为0
        if (file_length == 0)
        {
            g_log_file[i].offset = 0;
            continue;
        }

        // 找到00位置，得到偏移量
        for (j = 0; j < file_length - 1; j++)
        {
            if (file_buf[j] == 0 && (file_buf[j + 1] == 0))
            {
                g_log_file[i].offset = j + 1;
                break;
            }
        }
    }

    // 释放内存
    rt_free(file_buf);

    log_str_time(LOG_ERR, "装置上电", 1, 1);

    memset(g_logfile_update, 0, sizeof(g_logfile_update));

    return -err;
}

// 退出函数
int log_exit(void)
{
    int i;

    // 循环关闭文件
    for (i = 0; i < LOG_FILE_NUM; i++)
    {
        if (log_sem[i])
        {
            sem_destroy(log_sem[i]);
            log_sem[i] = NULL;
        }
        if (g_log_file[i].handle != 0)
        {
            rt_file_close(g_log_file[i].handle, 0);
            g_log_file[i].handle = -1;
        }
    }
    return 0;
}

static int _log_str(int index, char *log_buf, int log_len)
{
    char flag[2], *buf, read_buf[2];
    int end_len, over_len, file_length;
    off_t pos;
    off_t write_pos;
    int write_len;
    int tmp = 0;
    int ret = 0;

    if (log_len == 0)
    {
        return 0;
    }

    if (log_len > LOG_FILE_BUFSIZE)
    {
        return -1;
    }
    // 检查参数
    if (index > LOG_FILE_NUM)
    {
        return -1;
    }

    if (g_log_file[index].handle < 0)
    {
        return -2;
    }

    if (log_buf == NULL)
    {
        return -3;
    }

    // 初始化
    end_len = 0;
    over_len = 0;
    memset(flag, 0x0, sizeof(flag));

    pos = g_log_file[index].offset;
    buf = g_malloc_buf[index];

    // 判断是否记录长度超过文件长度
    if (g_log_file[index].offset + log_len + 6 >= g_log_file[index].size)
    {
        // 得到最后剩余的长度
        end_len = g_log_file[index].size - g_log_file[index].offset;

        memset(buf, 0, end_len);

        // 将最后部分填0
        if (rt_file_write(g_log_file[index].handle, buf, end_len, &pos) != end_len)
        {
            return -5;
        }

        // 从头开始写入
        pos = 0;
    }

    write_pos = pos;

    pos = pos + 2 + log_len + 2;
    g_log_file[index].offset = pos - 1;

    pos += 2;

    write_len = 2 + log_len + 2 + 2;

    memcpy(buf, "\r\n", 2);
    tmp += 2;
    memcpy(buf + tmp, log_buf, log_len);
    tmp += log_len;
    memcpy(buf + tmp, flag, 2);
    tmp += 2;
    memcpy(buf + tmp, "\r\n", 2);

    memcpy(writebuf[index], buf, write_len);

    // 在文件长度小于最大长度时，需要找到当前文件长度
    fsync(g_log_file[index].handle);
    file_length = rt_file_getfile_size(g_log_file[index].handle);
    rt_file_llseek(g_log_file[index].handle, 0, SEEK_SET);

    // 从换行后开始查找，找到被覆盖剩余记录部分长度
    pos = g_log_file[index].offset + 3;

    while (pos <= (file_length - 2))
    {
        if (rt_file_read(g_log_file[index].handle, read_buf, 2, &pos) != 2)
        {
            rt_printf("%s read error!\r\n", g_log_file[index].name);
            ret = -10;
            goto END;
        }
        if (read_buf[0] == 0 && read_buf[1] != 0)
        {
            break;
        }
        pos -= 1;
    }
    over_len = pos - g_log_file[index].offset - 4;

    if (over_len < 0)
    {
        goto END;
    }
    // 将被覆盖剩余记录填0
    memset(writebuf[index] + write_len, 0, over_len);
    write_len += over_len;

END:

    if (rt_file_write(g_log_file[index].handle, writebuf[index], write_len, &write_pos) != write_len)
    {

        rt_printf("%s write error!\r\n", g_log_file[index].name);
        return -12;
    }

    // 文件已更新
    g_logfile_update[index] = 1;
    return ret;
}

int log_str(int index, char *log_buf)
{
    int ret = 0, len;

    len = strlen(log_buf);
    sem_wait(log_sem[index]);
    ret = _log_str(index, log_buf, len); // 写内容到文件
    sem_post(log_sem[index]);
    return ret;
}

int log_str_len(int index, char *log_buf, int len)
{
    int ret = 0;
    sem_wait(log_sem[index]);
    ret = _log_str(index, log_buf, len); // 写内容到文件
    sem_post(log_sem[index]);
    return ret;
}

static int log_str_flush(int index, char *log_buf, int log_len)
{
    char flag[2], *buf, read_buf[2];
    int end_len, over_len, file_length;
    off_t pos;

    if (log_len == 0)
    {
        return 0;
    }

    // 检查参数
    if (index > LOG_FILE_NUM)
    {
        return -1;
    }

    if (g_log_file[index].handle == 0)
    {
        return -2;
    }

    if (log_buf == NULL)
    {
        return -3;
    }

    // 初始化
    end_len = 0;
    over_len = 0;
    memset(flag, 0x0, sizeof(flag));

    // log_len = strlen(log_buf);
    pos = g_log_file[index].offset;

    // 判断是否记录长度超过文件长度
    if (g_log_file[index].offset + log_len >= g_log_file[index].size)
    {
        // 得到最后剩余的长度
        end_len = g_log_file[index].size - g_log_file[index].offset;

        // 分配内存
        buf = (char *)rt_malloc(end_len);
        if (buf == 0)
        {
            return -4;
        }

        memset(buf, 0, end_len);

        // 将最后部分填0
        if (rt_file_write(g_log_file[index].handle, buf, end_len, &pos) != end_len)
        {
            rt_free(buf);
            return -5;
        }
        rt_free(buf);

        // 从头开始写入
        pos = 0;
    }

    // 写文件
    if (rt_file_write(g_log_file[index].handle, log_buf, log_len, &pos) != log_len)
    {
        return -9;
    }

    g_log_file[index].offset = pos - 3;

    // 在文件长度小于最大长度时，需要找到当前文件长度
    fsync(g_log_file[index].handle);
    file_length = rt_file_getfile_size(g_log_file[index].handle);
    rt_file_llseek(g_log_file[index].handle, 0, SEEK_SET);
    // rt_free(buf);
    // 从换行后开始查找，找到被覆盖剩余记录部分长度
    pos = g_log_file[index].offset + 3;

    while (pos <= (file_length - 2))
    {
        if (rt_file_read(g_log_file[index].handle, read_buf, 2, &pos) != 2)
        {
            rt_printf("%s read error!\r\n", g_log_file[index].name);
            return -10;
        }
        if (read_buf[0] == 0 && read_buf[1] != 0)
        {
            break;
        }
        pos -= 1;
    }

    over_len = pos - g_log_file[index].offset - 4;
    if (over_len < 0)
    {
        goto END;
    }

    // 分配内存
    buf = (char *)rt_malloc(over_len);
    if (buf == 0)
    {
        return -11;
    }

    memset(buf, 0, over_len);

    pos = g_log_file[index].offset + 3;

    // 将被覆盖剩余记录填0
    if (rt_file_write(g_log_file[index].handle, buf, over_len, &pos) != over_len)
    {
        rt_free(buf);
        rt_printf("%s write error!\r\n", g_log_file[index].name);
        return -12;
    }
    rt_free(buf);
END:
    // 文件已更新
    g_logfile_update[index] = 1;
    return 0;
}

int log_str_ext(int index, char *log_buf)
{
    int log_len = strlen(log_buf);

    sem_wait(log_sem[index]);

    // 缓存数据内容已经足够大,写到文件中
    if ((log_len + 3 + writebuf_count[index]) >= LOG_FILE_BUFSIZE)
    {

        // 最后一行结束字符00 00 0D 0A
        writebuf[index][writebuf_count[index] - 2] = 0;
        writebuf[index][writebuf_count[index] - 1] = (unsigned char)'\r';
        writebuf[index][writebuf_count[index]] = (unsigned char)'\n';
        // 写到文件中
        log_str_flush(index, writebuf[index], writebuf_count[index] + 1);
        writebuf_count[index] = 0; // 清零
    }

    // 文件开头填充0D 0A
    if (writebuf_count[index] == 0)
    {
        // 数据末尾00 00 0D 0A
        // 填充           0D 0A 数据
        writebuf[index][0] = '\r';
        writebuf[index][1] = '\n';
        writebuf_count[index] += 2;
    }

    // 缓存数据内容
    memcpy(writebuf[index] + writebuf_count[index], log_buf, log_len);
    writebuf_count[index] += log_len;

    // 一行内容以 00 0D 0A作为结束
    writebuf[index][writebuf_count[index]] = 0;
    writebuf_count[index]++;

    memcpy(writebuf[index] + writebuf_count[index], "\r\n", 2);
    writebuf_count[index] += 2;

    sem_post(log_sem[index]);

    return 0;
}

void log_str_ext_flush(int index)
{
    sem_wait(log_sem[index]);

    if (writebuf_count[index] > 0)
    {
        // 结束字符00 00 0D 0A
        writebuf[index][writebuf_count[index] - 2] = 0;
        writebuf[index][writebuf_count[index] - 1] = (unsigned char)'\r';
        writebuf[index][writebuf_count[index]] = (unsigned char)'\n';
        log_str_flush(index, writebuf[index], writebuf_count[index] + 1);
        writebuf_count[index] = 0;
    }
    sem_post(log_sem[index]);
}

int log_str_time(int index, char *log_buf, int is_rtc, u8 val)
{
    char *wirte_buf;
    int log_len;

    struct timespec ts = {0, 0};
    struct rtc_time_t tm;

#if 0 // jack.liu 20200911 获取rtc时间失能
	if(is_rtc) // 装置上电时才用到
	{
		// rtc_time_read(&tm);
	}
	else
#endif
    {
        clk_time_get(&ts);
        timespec_to_rtc(ts, &tm, 0);
    }

    // 检查参数
    if (index > LOG_FILE_NUM)
    {
        return -1;
    }
    if (log_buf == NULL)
    {
        return -2;
    }

    // 得到待写入字符串长度
    log_len = strlen(log_buf) + 16;
    wirte_buf = (char *)rt_malloc(log_len + strlen("2020-07-01 01:01:01.000000 "));
    if ((wirte_buf) == NULL)
    {
        return -1;
    }

    // 得到系统时间
    sprintf(wirte_buf, "20%02hu-%02hu-%02hu %02hu:%02hu:%02hu.%06lu ",
            tm.year, tm.month, tm.day, tm.hour, tm.min, tm.ms / 1000, ts.tv_nsec / 1000);

    strcat(wirte_buf, log_buf);

    log_str(index, wirte_buf);

    rt_free(wirte_buf);

    return 0;
}

int log_file_check(s8 *name)
{
    int i;

    for (i = 0; i < LOG_FILE_NUM; i++)
    {
        if (strstr(name, g_log_file[i].name) == 0)
        {
            return i;
        }
    }

    return -1;
}

int log_file_is_overrun(int index)
{
    int file_length;

    if (index >= LOG_FILE_NUM)
    {
        return 1;
    }

    if (g_log_file[index].handle == 0)
    {
        return 1;
    }

    // 得到文件长度
    fsync(g_log_file[index].handle);
    file_length = rt_file_getfile_size(g_log_file[index].handle);
    rt_file_llseek(g_log_file[index].handle, 0, SEEK_SET);

    if (g_log_file[index].offset + 128 > g_log_file[index].size)
    {
        return 1;
    }

    return 0;
}