ulog记录（RTTulog部分）

ulog.h

int ulog_init(void);
int ulog_async_init(void);
void ulog_output_lock_enabled(rt_bool_t enabled);
void ulog_deinit(void);

log初始化、异步初始化、输出锁初始化、log反初始化；

#define LOG_E(...)                      ulog_e(LOG_TAG, __VA_ARGS__)
#define LOG_W(...)                      ulog_w(LOG_TAG, __VA_ARGS__)
#define LOG_I(...)                      ulog_i(LOG_TAG, __VA_ARGS__)
#define LOG_D(...)                      ulog_d(LOG_TAG, __VA_ARGS__)
#define LOG_RAW(...)                    ulog_raw(__VA_ARGS__)
#define LOG_HEX(name, width, buf, size) ulog_hex(name, width, buf, size)

这段代码定义了一组宏，用于输出日志信息。这些宏的作用是将相应的日志级别和日志标签（`LOG_TAG`）与实际的日志输出函数关联起来。

- `LOG_E` 宏用于输出错误级别的日志信息，对应的日志输出函数是 `ulog_e`。
- `LOG_W` 宏用于输出警告级别的日志信息，对应的日志输出函数是 `ulog_w`。
- `LOG_I` 宏用于输出信息级别的日志信息，对应的日志输出函数是 `ulog_i`。
- `LOG_D` 宏用于输出调试级别的日志信息，对应的日志输出函数是 `ulog_d`。
- `LOG_RAW` 宏用于直接输出原始日志信息，对应的日志输出函数是 `ulog_raw`。
- `LOG_HEX` 宏用于以十六进制格式输出缓冲区的内容，对应的日志输出函数是 `ulog_hex`。

这些宏的定义通过传递可变参数 `__VA_ARGS__` 来支持不同数量和类型的参数。例如，使用 `LOG_I("Hello, %s!", "world")` 将会调用 `ulog_i` 函数输出信息级别的日志信息，其中的格式化字符串是 "Hello, %s!"，参数 "world" 会替换 `%s`。具体的日志输出函数的实现需要根据代码中的其他部分来确定。

rt_err_t ulog_backend_register(ulog_backend_t backend, const char *name, rt_bool_t support_color);
rt_err_t ulog_backend_unregister(ulog_backend_t backend);
rt_err_t ulog_backend_set_filter(ulog_backend_t backend, ulog_backend_filter_t filter);
ulog_backend_t ulog_backend_find(const char *name);
这段代码定义了一组函数，用于注册、注销、设置过滤器和查找日志后端。

- `rt_err_t ulog_backend_register(ulog_backend_t backend, const char *name, rt_bool_t support_color)` 函数用于注册一个日志后端。参数 `backend` 是要注册的日志后端对象，`name` 是该后端的名称，`support_color` 是一个布尔值，表示该后端是否支持颜色输出。函数返回一个错误码，表示注册是否成功。

- `rt_err_t ulog_backend_unregister(ulog_backend_t backend)` 函数用于注销一个已注册的日志后端。参数 `backend` 是要注销的日志后端对象。函数返回一个错误码，表示注销是否成功。

- `rt_err_t ulog_backend_set_filter(ulog_backend_t backend, ulog_backend_filter_t filter)` 函数用于设置日志后端的过滤器。参数 `backend` 是要设置过滤器的日志后端对象，`filter` 是一个函数指针，用于指定过滤器的实现。函数返回一个错误码，表示设置过滤器是否成功。

- `ulog_backend_t ulog_backend_find(const char *name)` 函数用于根据名称查找已注册的日志后端。参数 `name` 是要查找的后端名称。如果找到匹配的后端，则返回该后端对象；如果未找到匹配的后端，则返回 NULL。

这些函数的具体实现需要根据代码中的其他部分来确定。这些函数的作用是为日志系统提供灵活的后端管理和配置功能，可以根据需要注册、注销、设置过滤器和查找不同的日志输出后端。

#ifdef ULOG_USING_FILTER
/** log filter setting*/
int ulog_tag_lvl_filter_set(const char *tag, rt_uint32_t level);
rt_uint32_t ulog_tag_lvl_filter_get(const char *tag);
rt_slist_t *ulog_tag_lvl_list_get(void);
void ulog_global_filter_lvl_set(rt_uint32_t level);
rt_uint32_t ulog_global_filter_lvl_get(void);
void ulog_global_filter_tag_set(const char *tag);
const char *ulog_global_filter_tag_get(void);
void ulog_global_filter_kw_set(const char *keyword);
const char *ulog_global_filter_kw_get(void);
#endif /* ULOG_USING_FILTER */
这段代码是在条件编译宏 `ULOG_USING_FILTER` 的条件下定义的一组函数。这些函数用于设置和获取日志过滤器的配置，并提供了一些全局的过滤设置。

int ulog_tag_lvl_filter_set(const char *tag, rt_uint32_t level)` 设置指定标签（tag）的日志级别过滤器。参数 `tag` 是要设置过滤级别的标签，`level` 是要设置的日志级别。函数返回一个整数值，表示设置是否成功。

rt_uint32_t ulog_tag_lvl_filter_get(const char *tag)` 获取指定标签（tag）的日志级别过滤器配置。参数 `tag` 是要获取配置的标签。函数返回一个无符号 32 位整数，表示该标签的日志级别过滤器配置。

rt_slist_t *ulog_tag_lvl_list_get(void)` 获取所有日志标签和级别的链表。函数返回一个单项链表，该链表的每个节点包含一个日志标签（tag）和对应的日志级别。

void ulog_global_filter_lvl_set(rt_uint32_t level)` 设置全局日志级别过滤器的级别。参数 level 是要设置的全局日志级别。该过滤器将应用于所有日志输出，如果日志级别低于该设置的级别，则不会输出。

rt_uint32_t ulog_global_filter_lvl_get(void)` 获取全局日志级别过滤器的级别。函数返回一个无符号 32 位整数，表示全局日志级别过滤器的配置。

void ulog_global_filter_tag_set(const char *tag)` 设置全局日志标签过滤器。参数 `tag` 是要设置的全局日志标签。只有匹配该标签的日志才会输出。

const char *ulog_global_filter_tag_get(void)` 获取全局日志标签过滤器的配置。函数返回一个字符串，表示全局日志标签过滤器的配置。

void ulog_global_filter_kw_set(const char *keyword)` 设置全局日志关键字过滤器。参数 `keyword` 是要设置的全局日志关键字。只有包含该关键字的日志信息才会输出。

const char *ulog_global_filter_kw_get(void)` 获取全局日志关键字过滤器的配置。函数返回一个字符串，表示全局日志关键字过滤器的配置。

这些函数的具体实现需要根据代码中的其他部分来确定。通过使用这些函数，可以在运行时动态配置日志过滤器，控制哪些日志信息应该被输出。这为日志输出提供了更加灵活的配置能力。需要注意的是，这些函数只有在条件编译宏 `ULOG_USING_FILTER` 被定义时才会生效。

ulog.c工作流程

39-69：设置不一样的info颜色

70：规定最大log line buffer长度

73-109：rt_ulog {创建一个ulog本地对象，表示日志记录系统，包括输出互斥锁，存储后端信息的链表，异步输出设置，过滤器设置tag|keyword、level}

111-136：分配输出信息颜色

142-203：设置互斥锁保证输出日志的互斥访问；（？？？）

249-302：格式化日志输出的函数ulog_formater，其中主要包括日志缓冲区、级别、日志、日志标签tag、是否换行newline，格式化字符串format和参数列表arge；同时添加日志时间，主要是gettimeofday获取时间，通过rt_snprintf函数将格式化后的时间字符串写入日志缓冲区。

336-393：添加日志标签和线程信息（这里包含对中断日志的处理）：主要就是首先考虑当前是否在中断上下文中，如果不在中断上下文中，就先获取当前线程名称，然后拷贝到日志缓冲区中，如果当前在中断上下文中，就先将ISR字符串拷贝到日志缓冲区中，然后使用rt_vsnprintf函数将格式化后的日志消息写入日志缓冲区，计算日志长度加上格式化结果不超过ULOG_LINE_BUF_SIZE，若日志过长，则将日志长度设置为ULOG_LINE_BUF_SIZE，溢出时，也需要先CSI结束符、换行符和字符串结束符预留一些空间。如果使用颜色输出，且日志长度加上CSI结束符、换行符和字符串结束符的长度超过ULOG_LINE_BUF_SIZE，则将日志长度设置为ULOG_LINE_BUF_SIZE，并为CSI结束符预留一些空间。

426-483：将日志输出到所有后端的函数和执行日志输出的函数。ulog_output_to_all_backend输出到所有后端（先判断是否ulog已经初始化，然后检查后端，匹配输出级别，选择颜色，判断后端的过滤器函数，否则重新计算日志输出的起始地址和长度。首先计算颜色信息的长度，然后根据颜色信息的长度确定新的日志起始地址和日志长度，去除颜色输出的标记后，再调用后端的输出函数），输出函数ulog_output_to_all_backend相关参数主要包括：日志级别，标签，是否为原始日志，缓冲区，长度。

558-617：格式化并输出日志消息，同时处理了递归调用和日志过滤的情况，并通过调用相应的函数将消息输出到所有已注册的日志后端。格式化并输出日志消息，包括日志级别、标签、是否添加换行符、日志消息的格式字符串。函数执行逻辑：检查日志级别和标签是否满足过滤条件，调用get_log_buf获取一个缓冲区 锁定日志输出，防止并发访问冲突，使用 rt_vsnprintf 函数将格式化后的消息从可变参数列表 args 填充到日志缓冲区中。调用 ulog_output_to_all_backend 函数将日志缓冲区中的内容输出到所有已注册的日志后端。解锁日志输出。

660-720：ulog_output 函数用于格式化并输出日志消息。它接受日志级别 level、日志标签 tag、是否换行 newline、以及格式化字符串 format 和可变参数列表 args。ulog_raw 函数用于以原始形式输出日志消息，不进行格式化。它接受一个格式化字符串 format 和可变参数列表 args。这两个函数的作用是提供了不同的方式来输出日志消息。ulog_output 函数进行格式化输出而 ulog_raw 函数直接输出原始日志消息。它们都使用可变参数列表来接收日志消息的参数，可以根据需要输出不同级别和格式的日志信息。

730-874：hexdump函数用于以十六进制形式输出数据的转储。它接受日志标签 tag、每行显示的字节数 width、待转储数据的起始地址 buf，以及待转储数据的大小 size。日志输出中添加时间戳信息，方便记录日志的时间信息。同时，它也展示了根据编译选项的不同，如何选择不同的时间戳格式。

889-910：遍历 ulog.backend_list 链表（即所有注册的日志后端），找到与输入名称相匹配的后端，然后设置其输出级别为指定的值。通过这种方式，可以动态地控制每个日志后端的输出级别，以便过滤和管理日志的输出。最后，返回函数执行结果。

934-997：通过遍历已注册的标签级别过滤器链表，根据输入的标签和级别来进行添加、更新或移除标签级别过滤器的操作。通过设置标签级别过滤器，可以动态地控制特定标签的日志输出级别。最后，返回函数执行结果

1010-1070：提供获取指定标签的日志级别过滤器配置、获取全局日志过滤器级别、设置全局日志过滤器级别的功能。通过这些功能，可以动态地控制特定标签的日志输出级别，并设置全局的日志输出级别。

1078-1137：提供了设置和获取全局日志过滤器标签和关键字的功能，并提供一个用于调试输出日志级别信息的函数。通过这些功能，可以灵活地配置和获取全局日志过滤器的标签和关键字，并调试输出不同日志级别的相关信息。

函数 ulog_global_filter_tag_set 用于设置全局日志过滤器的标签。

函数 ulog_global_filter_tag_get 用于获取全局日志过滤器的标签

函数 ulog_global_filter_kw_set 用于设置全局日志过滤器的关键字

函数 ulog_global_filter_kw_get 用于获取全局日志过滤器的关键字

函数 _print_lvl_info 是一个用于调试输出的函数，用于打印不同日志级别的相关信息。

1140-1201：三个函数 ulog_be_lvl、ulog_tag_lvl 和 ulog_lvl，它们是用于设置日志过滤器级别的命令函数，并通过 MSH_CMD_EXPORT 宏将这些函数导出为命令行命令

函数 ulog_be_lvl 用于设置指定后端（backend）的日志过滤器级别

函数 ulog_tag_lvl 用于设置指定标签（tag）的日志过滤器级别

函数 ulog_lvl 用于设置全局日志过滤器级别

1255-1317：注册日志输出后端ulog_backend_register：调用该函数，可以将自定义的日志输出后端注册到 ulog 中，以便在日志输出时使用该后端进行实际的输出操作。

1320-1371：实现已注册的日志输出后端的注销、过滤器设置和查找操作，以便进行相应的管理和控制
ulog_backend_unregister 函数用于注销一个已注册的日志输出后端

ulog_backend_set_filter 函数用于设置日志输出后端的过滤器。

ulog_backend_find 函数用于根据名称查找已注册的日志输出后端。

1374-1424：可以实现日志的异步输出，从而提高系统的响应性能。异步输出模式下，日志会先存储在缓冲区中，然后在适当的时机进行输出，而不会阻塞当前线程的执行。

1434-1503：日志输出的刷新与初始化；

ulog_flush 函数用于刷新所有后端的日志。

ulog_init 函数用于初始化 ulog。

1506-1570：实现了 ulog 的初始化、异步输出的初始化和反初始化操作。

/** Copyright (c) 2006-2022, RT-Thread Development Team** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date           Author       Notes* 2018-08-25     armink       the first version*/#ifndef _ULOG_H_
#define _ULOG_H_#include <rtthread.h>
#include "ulog_def.h"#ifdef __cplusplus
extern "C" {
#endif/** ulog init and deint*/
int ulog_init(void);
int ulog_async_init(void);
void ulog_output_lock_enabled(rt_bool_t enabled);
void ulog_deinit(void);/** output different level log by LOG_X API** NOTE: The `LOG_TAG` and `LOG_LVL` must be defined before including the <ulog.h> when you want to use LOG_X API.** #define LOG_TAG              "example"* #define LOG_LVL              LOG_LVL_DBG* #include <ulog.h>** Then you can using LOG_X API to output log** LOG_D("this is a debug log!");* LOG_E("this is a error log!");*/
#define LOG_E(...)                      ulog_e(LOG_TAG, __VA_ARGS__)
#define LOG_W(...)                      ulog_w(LOG_TAG, __VA_ARGS__)
#define LOG_I(...)                      ulog_i(LOG_TAG, __VA_ARGS__)
#define LOG_D(...)                      ulog_d(LOG_TAG, __VA_ARGS__)
#define LOG_RAW(...)                    ulog_raw(__VA_ARGS__)
#define LOG_HEX(name, width, buf, size) ulog_hex(name, width, buf, size)/** backend register and unregister*/
rt_err_t ulog_backend_register(ulog_backend_t backend, const char *name, rt_bool_t support_color);
rt_err_t ulog_backend_unregister(ulog_backend_t backend);
rt_err_t ulog_backend_set_filter(ulog_backend_t backend, ulog_backend_filter_t filter);
ulog_backend_t ulog_backend_find(const char *name);#ifdef ULOG_USING_FILTER
/** log filter setting*/
int ulog_tag_lvl_filter_set(const char *tag, rt_uint32_t level);
rt_uint32_t ulog_tag_lvl_filter_get(const char *tag);
rt_slist_t *ulog_tag_lvl_list_get(void);
void ulog_global_filter_lvl_set(rt_uint32_t level);
rt_uint32_t ulog_global_filter_lvl_get(void);
void ulog_global_filter_tag_set(const char *tag);
const char *ulog_global_filter_tag_get(void);
void ulog_global_filter_kw_set(const char *keyword);
const char *ulog_global_filter_kw_get(void);
#endif /* ULOG_USING_FILTER *//** flush all backends's log*/
void ulog_flush(void);#ifdef ULOG_USING_ASYNC_OUTPUT
/** asynchronous output API*/
void ulog_async_output(void);
void ulog_async_output_enabled(rt_bool_t enabled);
rt_err_t ulog_async_waiting_log(rt_int32_t time);
#endif/** dump the hex format data to log*/
void ulog_hexdump(const char *tag, rt_size_t width, rt_uint8_t *buf, rt_size_t size);/** Another log output API. This API is more difficult to use than LOG_X API.*/
void ulog_voutput(rt_uint32_t level, const char *tag, rt_bool_t newline, const char *format, va_list args);
void ulog_output(rt_uint32_t level, const char *tag, rt_bool_t newline, const char *format, ...);
void ulog_raw(const char *format, ...);#ifdef __cplusplus
}
#endif#endif /* _ULOG_H_ */

/** Copyright (c) 2006-2022, RT-Thread Development Team** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date           Author       Notes* 2018-08-25     armink       the first version*/#include <stdarg.h>
#include "ulog.h"
#include "rthw.h"#ifdef ULOG_USING_SYSLOG
#include <syslog.h>
#endif#ifdef ULOG_TIME_USING_TIMESTAMP
#include <sys/time.h>
#endif#ifdef ULOG_USING_ASYNC_OUTPUT
#include <rtdevice.h>
#endif#ifdef RT_USING_ULOG/* the number which is max stored line logs */
#ifndef ULOG_ASYNC_OUTPUT_STORE_LINES
#define ULOG_ASYNC_OUTPUT_STORE_LINES  (ULOG_ASYNC_OUTPUT_BUF_SIZE * 3 / 2 / 80)
#endif#ifdef ULOG_USING_COLOR
/*** CSI(Control Sequence Introducer/Initiator) sign* more information on https://en.wikipedia.org/wiki/ANSI_escape_code*/
#define CSI_START                      "\033["
#define CSI_END                        "\033[0m"
/* output log front color */
#define F_BLACK                        "30m"
#define F_RED                          "31m"
#define F_GREEN                        "32m"
#define F_YELLOW                       "33m"
#define F_BLUE                         "34m"
#define F_MAGENTA                      "35m"
#define F_CYAN                         "36m"
#define F_WHITE                        "37m"/* output log default color definition */
#ifndef ULOG_COLOR_DEBUG
#define ULOG_COLOR_DEBUG               RT_NULL
#endif
#ifndef ULOG_COLOR_INFO
#define ULOG_COLOR_INFO                (F_GREEN)
#endif
#ifndef ULOG_COLOR_WARN
#define ULOG_COLOR_WARN                (F_YELLOW)
#endif
#ifndef ULOG_COLOR_ERROR
#define ULOG_COLOR_ERROR               (F_RED)
#endif
#ifndef ULOG_COLOR_ASSERT
#define ULOG_COLOR_ASSERT              (F_MAGENTA)
#endif
#endif /* ULOG_USING_COLOR */#if ULOG_LINE_BUF_SIZE < 80
#error "the log line buffer size must more than 80"
#endifstruct rt_ulog
{rt_bool_t init_ok;rt_bool_t output_lock_enabled;struct rt_mutex output_locker;/* all backends */rt_slist_t backend_list;/* the thread log's line buffer */char log_buf_th[ULOG_LINE_BUF_SIZE + 1];#ifdef ULOG_USING_ISR_LOG/* the ISR log's line buffer */rt_base_t output_locker_isr_lvl;char log_buf_isr[ULOG_LINE_BUF_SIZE + 1];
#endif /* ULOG_USING_ISR_LOG */#ifdef ULOG_USING_ASYNC_OUTPUTrt_bool_t async_enabled;rt_rbb_t async_rbb;/* ringbuffer for log_raw function only */struct rt_ringbuffer *async_rb;rt_thread_t async_th;struct rt_semaphore async_notice;
#endif#ifdef ULOG_USING_FILTERstruct{/* all tag's level filter */rt_slist_t tag_lvl_list;/* global filter level, tag and keyword */rt_uint32_t level;char tag[ULOG_FILTER_TAG_MAX_LEN + 1];char keyword[ULOG_FILTER_KW_MAX_LEN + 1];} filter;
#endif /* ULOG_USING_FILTER */
};/* level output info */
static const char * const level_output_info[] =
{"A/",RT_NULL,RT_NULL,"E/","W/",RT_NULL,"I/","D/",
};#ifdef ULOG_USING_COLOR
/* color output info */
static const char * const color_output_info[] =
{ULOG_COLOR_ASSERT,RT_NULL,RT_NULL,ULOG_COLOR_ERROR,ULOG_COLOR_WARN,RT_NULL,ULOG_COLOR_INFO,ULOG_COLOR_DEBUG,
};
#endif /* ULOG_USING_COLOR *//* ulog local object */
static struct rt_ulog ulog = { 0 };rt_size_t ulog_strcpy(rt_size_t cur_len, char *dst, const char *src)
{const char *src_old = src;RT_ASSERT(dst);RT_ASSERT(src);while (*src != 0){/* make sure destination has enough space */if (cur_len++ < ULOG_LINE_BUF_SIZE){*dst++ = *src++;}else{break;}}return src - src_old;
}rt_size_t ulog_ultoa(char *s, unsigned long int n)
{rt_size_t i = 0, j = 0, len = 0;char swap;do{s[len++] = n % 10 + '0';} while (n /= 10);s[len] = '\0';/* reverse string */for (i = 0, j = len - 1; i < j; ++i, --j){swap = s[i];s[i] = s[j];s[j] = swap;}return len;
}static void output_unlock(void)
{/* earlier stage */if (ulog.output_lock_enabled == RT_FALSE){return;}/* If the scheduler is started and in thread context */if (rt_interrupt_get_nest() == 0 && rt_thread_self() != RT_NULL){rt_mutex_release(&ulog.output_locker);}else{
#ifdef ULOG_USING_ISR_LOGrt_hw_interrupt_enable(ulog.output_locker_isr_lvl);
#endif}
}static void output_lock(void)
{/* earlier stage */if (ulog.output_lock_enabled == RT_FALSE){return;}/* If the scheduler is started and in thread context */if (rt_interrupt_get_nest() == 0 && rt_thread_self() != RT_NULL){rt_mutex_take(&ulog.output_locker, RT_WAITING_FOREVER);}else{
#ifdef ULOG_USING_ISR_LOGulog.output_locker_isr_lvl = rt_hw_interrupt_disable();
#endif}
}void ulog_output_lock_enabled(rt_bool_t enabled)
{ulog.output_lock_enabled = enabled;
}static char *get_log_buf(void)
{/* is in thread context */if (rt_interrupt_get_nest() == 0){return ulog.log_buf_th;}else{
#ifdef ULOG_USING_ISR_LOGreturn ulog.log_buf_isr;
#elsert_kprintf("Error: Current mode not supported run in ISR. Please enable ULOG_USING_ISR_LOG.\n");return RT_NULL;
#endif}
}RT_WEAK rt_size_t ulog_formater(char *log_buf, rt_uint32_t level, const char *tag, rt_bool_t newline,const char *format, va_list args)
{/* the caller has locker, so it can use static variable for reduce stack usage */static rt_size_t log_len, newline_len;static int fmt_result;RT_ASSERT(log_buf);RT_ASSERT(level <= LOG_LVL_DBG);RT_ASSERT(tag);RT_ASSERT(format);log_len = 0;newline_len = rt_strlen(ULOG_NEWLINE_SIGN);#ifdef ULOG_USING_COLOR/* add CSI start sign and color info */if (color_output_info[level]){log_len += ulog_strcpy(log_len, log_buf + log_len, CSI_START);log_len += ulog_strcpy(log_len, log_buf + log_len, color_output_info[level]);}
#endif /* ULOG_USING_COLOR */log_buf[log_len] = '\0';#ifdef ULOG_OUTPUT_TIME/* add time info */{
#ifdef ULOG_TIME_USING_TIMESTAMPstatic struct timeval now;static struct tm *tm, tm_tmp;static rt_bool_t check_usec_support = RT_FALSE, usec_is_support = RT_FALSE;time_t t = (time_t)0;if (gettimeofday(&now, RT_NULL) >= 0){t = now.tv_sec;}tm = localtime_r(&t, &tm_tmp);/* show the time format MM-DD HH:MM:SS */rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, "%02d-%02d %02d:%02d:%02d", tm->tm_mon + 1,tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);/* check the microseconds support when kernel is startup */if (t > 0 && !check_usec_support && rt_thread_self() != RT_NULL){long old_usec = now.tv_usec;/* delay some time for wait microseconds changed */rt_thread_mdelay(10);gettimeofday(&now, RT_NULL);check_usec_support = RT_TRUE;/* the microseconds is not equal between two gettimeofday calls */if (now.tv_usec != old_usec)usec_is_support = RT_TRUE;}if (usec_is_support){/* show the millisecond */log_len += rt_strlen(log_buf + log_len);rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, ".%03d", now.tv_usec / 1000);}#elsestatic rt_size_t tick_len = 0;log_buf[log_len] = '[';tick_len = ulog_ultoa(log_buf + log_len + 1, rt_tick_get());log_buf[log_len + 1 + tick_len] = ']';log_buf[log_len + 1 + tick_len + 1] = '\0';
#endif /* ULOG_TIME_USING_TIMESTAMP */log_len += rt_strlen(log_buf + log_len);}
#endif /* ULOG_OUTPUT_TIME */#ifdef ULOG_OUTPUT_LEVEL#ifdef ULOG_OUTPUT_TIMElog_len += ulog_strcpy(log_len, log_buf + log_len, " ");
#endif/* add level info */log_len += ulog_strcpy(log_len, log_buf + log_len, level_output_info[level]);
#endif /* ULOG_OUTPUT_LEVEL */#ifdef ULOG_OUTPUT_TAG#if !defined(ULOG_OUTPUT_LEVEL) && defined(ULOG_OUTPUT_TIME)log_len += ulog_strcpy(log_len, log_buf + log_len, " ");
#endif/* add tag info */log_len += ulog_strcpy(log_len, log_buf + log_len, tag);
#endif /* ULOG_OUTPUT_TAG */#ifdef ULOG_OUTPUT_THREAD_NAME/* add thread info */{#if defined(ULOG_OUTPUT_TIME) || defined(ULOG_OUTPUT_LEVEL) || defined(ULOG_OUTPUT_TAG)log_len += ulog_strcpy(log_len, log_buf + log_len, " ");
#endif/* is not in interrupt context */if (rt_interrupt_get_nest() == 0){rt_size_t name_len = 0;const char *thread_name = "N/A";if (rt_thread_self()){thread_name = rt_thread_self()->name;}name_len = rt_strnlen(thread_name, RT_NAME_MAX);rt_strncpy(log_buf + log_len, thread_name, name_len);log_len += name_len;}else{log_len += ulog_strcpy(log_len, log_buf + log_len, "ISR");}}
#endif /* ULOG_OUTPUT_THREAD_NAME */log_len += ulog_strcpy(log_len, log_buf + log_len, ": ");fmt_result = rt_vsnprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, format, args);/* calculate log length */if ((log_len + fmt_result <= ULOG_LINE_BUF_SIZE) && (fmt_result > -1)){log_len += fmt_result;}else{/* using max length */log_len = ULOG_LINE_BUF_SIZE;}/* overflow check and reserve some space for CSI end sign, newline sign and string end sign */
#ifdef ULOG_USING_COLORif (log_len + (sizeof(CSI_END) - 1) + newline_len + sizeof((char)'\0') > ULOG_LINE_BUF_SIZE){/* using max length */log_len = ULOG_LINE_BUF_SIZE;/* reserve some space for CSI end sign */log_len -= (sizeof(CSI_END) - 1);
#elseif (log_len + newline_len + sizeof((char)'\0') > ULOG_LINE_BUF_SIZE){/* using max length */log_len = ULOG_LINE_BUF_SIZE;
#endif /* ULOG_USING_COLOR *//* reserve some space for newline sign */log_len -= newline_len;/* reserve some space for string end sign */log_len -= sizeof((char)'\0');}/* package newline sign */if (newline){log_len += ulog_strcpy(log_len, log_buf + log_len, ULOG_NEWLINE_SIGN);}#ifdef ULOG_USING_COLOR/* add CSI end sign  */if (color_output_info[level]){log_len += ulog_strcpy(log_len, log_buf + log_len, CSI_END);}
#endif /* ULOG_USING_COLOR *//* add string end sign */log_buf[log_len] = '\0';return log_len;
}static void ulog_output_to_all_backend(rt_uint32_t level, const char *tag, rt_bool_t is_raw, const char *log, rt_size_t len)
{rt_slist_t *node;ulog_backend_t backend;if (!ulog.init_ok)return;/* if there is no backend */if (!rt_slist_first(&ulog.backend_list)){rt_kputs(log);return;}/* output for all backends */for (node = rt_slist_first(&ulog.backend_list); node; node = rt_slist_next(node)){backend = rt_slist_entry(node, struct ulog_backend, list);if (backend->out_level < level){continue;}
#if !defined(ULOG_USING_COLOR) || defined(ULOG_USING_SYSLOG)backend->output(backend, level, tag, is_raw, log, len);
#elseif (backend->filter && backend->filter(backend, level, tag, is_raw, log, len) == RT_FALSE){/* backend's filter is not match, so skip output */continue;}if (backend->support_color || is_raw){backend->output(backend, level, tag, is_raw, log, len);}else{/* recalculate the log start address and log size when backend not supported color */rt_size_t color_info_len = 0, output_len = len;const char *output_log = log;if (color_output_info[level] != RT_NULL)color_info_len = rt_strlen(color_output_info[level]);if (color_info_len){rt_size_t color_hdr_len = rt_strlen(CSI_START) + color_info_len;output_log += color_hdr_len;output_len -= (color_hdr_len + (sizeof(CSI_END) - 1));}backend->output(backend, level, tag, is_raw, output_log, output_len);}
#endif /* !defined(ULOG_USING_COLOR) || defined(ULOG_USING_SYSLOG) */}
}static void do_output(rt_uint32_t level, const char *tag, rt_bool_t is_raw, const char *log_buf, rt_size_t log_len)
{
#ifdef ULOG_USING_ASYNC_OUTPUTrt_size_t log_buf_size = log_len + sizeof((char)'\0');if (is_raw == RT_FALSE){rt_rbb_blk_t log_blk;ulog_frame_t log_frame;/* allocate log frame */log_blk = rt_rbb_blk_alloc(ulog.async_rbb, RT_ALIGN(sizeof(struct ulog_frame) + log_buf_size, RT_ALIGN_SIZE));if (log_blk){/* package the log frame */log_frame = (ulog_frame_t) log_blk->buf;log_frame->magic = ULOG_FRAME_MAGIC;log_frame->is_raw = is_raw;log_frame->level = level;log_frame->log_len = log_len;log_frame->tag = tag;log_frame->log = (const char *)log_blk->buf + sizeof(struct ulog_frame);/* copy log data */rt_strncpy((char *)(log_blk->buf + sizeof(struct ulog_frame)), log_buf, log_buf_size);/* put the block */rt_rbb_blk_put(log_blk);/* send a notice */rt_sem_release(&ulog.async_notice);}else{static rt_bool_t already_output = RT_FALSE;if (already_output == RT_FALSE){rt_kprintf("Warning: There is no enough buffer for saving async log,"" please increase the ULOG_ASYNC_OUTPUT_BUF_SIZE option.\n");already_output = RT_TRUE;}}}else if (ulog.async_rb){rt_ringbuffer_put(ulog.async_rb, (const rt_uint8_t *)log_buf, log_buf_size);/* send a notice */rt_sem_release(&ulog.async_notice);}
#else/* is in thread context */if (rt_interrupt_get_nest() == 0){/* output to all backends */ulog_output_to_all_backend(level, tag, is_raw, log_buf, log_len);}else{
#ifdef ULOG_BACKEND_USING_CONSOLE/* We can't ensure that all backends support ISR context output.* So only using rt_kprintf when context is ISR */extern void ulog_console_backend_output(struct ulog_backend *backend, rt_uint32_t level, const char *tag,rt_bool_t is_raw, const char *log, rt_size_t len);ulog_console_backend_output(RT_NULL, level, tag, is_raw, log_buf, log_len);
#endif /* ULOG_BACKEND_USING_CONSOLE */}
#endif /* ULOG_USING_ASYNC_OUTPUT */
}/*** output the log by variable argument list** @param level level* @param tag tag* @param newline has_newline* @param format output format* @param args variable argument list*/
void ulog_voutput(rt_uint32_t level, const char *tag, rt_bool_t newline, const char *format, va_list args)
{static rt_bool_t ulog_voutput_recursion = RT_FALSE;char *log_buf = RT_NULL;rt_size_t log_len = 0;RT_ASSERT(tag);RT_ASSERT(format);
#ifndef ULOG_USING_SYSLOGRT_ASSERT(level <= LOG_LVL_DBG);
#elseRT_ASSERT(LOG_PRI(level) <= LOG_DEBUG);
#endif /* ULOG_USING_SYSLOG */if (!ulog.init_ok){return;}#ifdef ULOG_USING_FILTER/* level filter */
#ifndef ULOG_USING_SYSLOGif (level > ulog.filter.level || level > ulog_tag_lvl_filter_get(tag)){return;}
#elseif (((LOG_MASK(LOG_PRI(level)) & ulog.filter.level) == 0)|| ((LOG_MASK(LOG_PRI(level)) & ulog_tag_lvl_filter_get(tag)) == 0)){return;}
#endif /* ULOG_USING_SYSLOG */else if (!rt_strstr(tag, ulog.filter.tag)){/* tag filter */return;}
#endif /* ULOG_USING_FILTER *//* get log buffer */log_buf = get_log_buf();/* lock output */output_lock();/* If there is a recursion, we use a simple way */if (ulog_voutput_recursion == RT_TRUE){rt_kprintf(format, args);if(newline == RT_TRUE){rt_kprintf(ULOG_NEWLINE_SIGN);}output_unlock();return;}ulog_voutput_recursion = RT_TRUE;#ifndef ULOG_USING_SYSLOGlog_len = ulog_formater(log_buf, level, tag, newline, format, args);
#elseextern rt_size_t syslog_formater(char *log_buf, rt_uint8_t level, const char *tag, rt_bool_t newline, const char *format, va_list args);log_len = syslog_formater(log_buf, level, tag, newline, format, args);
#endif /* ULOG_USING_SYSLOG */#ifdef ULOG_USING_FILTER/* keyword filter */if (ulog.filter.keyword[0] != '\0'){/* add string end sign */log_buf[log_len] = '\0';/* find the keyword */if (!rt_strstr(log_buf, ulog.filter.keyword)){ulog_voutput_recursion = RT_FALSE;/* unlock output */output_unlock();return;}}
#endif /* ULOG_USING_FILTER *//* do log output */do_output(level, tag, RT_FALSE, log_buf, log_len);ulog_voutput_recursion = RT_FALSE;/* unlock output */output_unlock();
}/*** output the log** @param level level* @param tag tag* @param newline has newline* @param format output format* @param ... args*/
void ulog_output(rt_uint32_t level, const char *tag, rt_bool_t newline, const char *format, ...)
{va_list args;/* args point to the first variable parameter */va_start(args, format);ulog_voutput(level, tag, newline, format, args);va_end(args);
}/*** output RAW string format log** @param format output format* @param ... args*/
void ulog_raw(const char *format, ...)
{rt_size_t log_len = 0;char *log_buf = RT_NULL;va_list args;int fmt_result;RT_ASSERT(ulog.init_ok);#ifdef ULOG_USING_ASYNC_OUTPUTif (ulog.async_rb == RT_NULL){ulog.async_rb = rt_ringbuffer_create(ULOG_ASYNC_OUTPUT_BUF_SIZE);}
#endif/* get log buffer */log_buf = get_log_buf();/* lock output */output_lock();/* args point to the first variable parameter */va_start(args, format);fmt_result = rt_vsnprintf(log_buf, ULOG_LINE_BUF_SIZE, format, args);va_end(args);/* calculate log length */if ((fmt_result > -1) && (fmt_result <= ULOG_LINE_BUF_SIZE)){log_len = fmt_result;}else{log_len = ULOG_LINE_BUF_SIZE;}/* do log output */do_output(LOG_LVL_DBG, "", RT_TRUE, log_buf, log_len);/* unlock output */output_unlock();
}/*** dump the hex format data to log** @param tag name for hex object, it will show on log header* @param width hex number for every line, such as: 16, 32* @param buf hex buffer* @param size buffer size*/
void ulog_hexdump(const char *tag, rt_size_t width, rt_uint8_t *buf, rt_size_t size)
{
#define __is_print(ch)       ((unsigned int)((ch) - ' ') < 127u - ' ')rt_size_t i, j;rt_size_t log_len = 0, name_len = rt_strlen(tag);
#ifdef ULOG_OUTPUT_TIMErt_size_t time_head_len = 0;
#endifchar *log_buf = RT_NULL, dump_string[8];int fmt_result;RT_ASSERT(ulog.init_ok);#ifdef ULOG_USING_FILTER/* level filter */
#ifndef ULOG_USING_SYSLOGif (LOG_LVL_DBG > ulog.filter.level || LOG_LVL_DBG > ulog_tag_lvl_filter_get(tag)){return;}
#elseif ((LOG_MASK(LOG_DEBUG) & ulog.filter.level) == 0){return;}
#endif /* ULOG_USING_SYSLOG */else if (!rt_strstr(tag, ulog.filter.tag)){/* tag filter */return;}
#endif /* ULOG_USING_FILTER */#ifdef ULOG_USING_ASYNC_OUTPUTif (ulog.async_rb == RT_NULL){ulog.async_rb = rt_ringbuffer_create(ULOG_ASYNC_OUTPUT_BUF_SIZE);}
#endif/* get log buffer */log_buf = get_log_buf();/* lock output */output_lock();for (i = 0, log_len = 0; i < size; i += width){/* package header */if (i == 0){
#ifdef ULOG_OUTPUT_TIME/* add time info */
#ifdef ULOG_TIME_USING_TIMESTAMPstatic time_t now;static struct tm *tm, tm_tmp;now = time(RT_NULL);tm = gmtime_r(&now, &tm_tmp);#ifdef RT_USING_SOFT_RTCrt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, "%02d-%02d %02d:%02d:%02d.%03d ", tm->tm_mon + 1,tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, rt_tick_get() % 1000);
#elsert_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, "%02d-%02d %02d:%02d:%02d ", tm->tm_mon + 1,tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
#endif /* RT_USING_SOFT_RTC */#elsestatic rt_size_t tick_len = 0;log_buf[log_len] = '[';tick_len = ulog_ultoa(log_buf + log_len + 1, rt_tick_get());log_buf[log_len + 1 + tick_len] = ']';log_buf[log_len + 2 + tick_len] = ' ';log_buf[log_len + 3 + tick_len] = '\0';
#endif /* ULOG_TIME_USING_TIMESTAMP */time_head_len = rt_strlen(log_buf + log_len);log_len += time_head_len;
#endif /* ULOG_OUTPUT_TIME */log_len += ulog_strcpy(log_len, log_buf + log_len, "D/HEX ");log_len += ulog_strcpy(log_len, log_buf + log_len, tag);log_len += ulog_strcpy(log_len, log_buf + log_len, ": ");}else{log_len = 6 + name_len + 2;
#ifdef ULOG_OUTPUT_TIMElog_len += time_head_len;
#endifrt_memset(log_buf, ' ', log_len);}fmt_result = rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE, "%04X-%04X: ", i, i + width - 1);/* calculate log length */if ((fmt_result > -1) && (fmt_result <= ULOG_LINE_BUF_SIZE)){log_len += fmt_result;}else{log_len = ULOG_LINE_BUF_SIZE;}/* dump hex */for (j = 0; j < width; j++){if (i + j < size){rt_snprintf(dump_string, sizeof(dump_string), "%02X ", buf[i + j]);}else{rt_strncpy(dump_string, "   ", sizeof(dump_string));}log_len += ulog_strcpy(log_len, log_buf + log_len, dump_string);if ((j + 1) % 8 == 0){log_len += ulog_strcpy(log_len, log_buf + log_len, " ");}}log_len += ulog_strcpy(log_len, log_buf + log_len, "  ");/* dump char for hex */for (j = 0; j < width; j++){if (i + j < size){rt_snprintf(dump_string, sizeof(dump_string), "%c", __is_print(buf[i + j]) ? buf[i + j] : '.');log_len += ulog_strcpy(log_len, log_buf + log_len, dump_string);}}/* overflow check and reserve some space for newline sign */if (log_len + rt_strlen(ULOG_NEWLINE_SIGN) > ULOG_LINE_BUF_SIZE){log_len = ULOG_LINE_BUF_SIZE - rt_strlen(ULOG_NEWLINE_SIGN);}/* package newline sign */log_len += ulog_strcpy(log_len, log_buf + log_len, ULOG_NEWLINE_SIGN);/*add string end sign*/log_buf[log_len] = '\0';/* do log output */do_output(LOG_LVL_DBG, RT_NULL, RT_TRUE, log_buf, log_len);}/* unlock output */output_unlock();
}#ifdef ULOG_USING_FILTER
/*** Set the filter's level by different backend.* The log on this backend which level is less than it will stop output.** @param be_name backend name* @param level The filter level. When the level is LOG_FILTER_LVL_SILENT, the log enter silent mode.*        When the level is LOG_FILTER_LVL_ALL, it will remove this tag's level filer.*        Then all level log will resume output.** @return  0 : success*         -10: level is out of range*/
int ulog_be_lvl_filter_set(const char *be_name, rt_uint32_t level)
{rt_slist_t *node = RT_NULL;ulog_backend_t backend;int result = RT_EOK;if (level > LOG_FILTER_LVL_ALL)return -RT_EINVAL;if (!ulog.init_ok)return result;for (node = rt_slist_first(&ulog.backend_list); node; node = rt_slist_next(node)){backend = rt_slist_entry(node, struct ulog_backend, list);if (rt_strncmp(backend->name, be_name, RT_NAME_MAX) == 0){backend->out_level = level;}}return result;
}/*** Set the filter's level by different tag.* The log on this tag which level is less than it will stop output.** example:*     // the example tag log enter silent mode*     ulog_set_filter_lvl("example", LOG_FILTER_LVL_SILENT);*     // the example tag log which level is less than INFO level will stop output*     ulog_set_filter_lvl("example", LOG_LVL_INFO);*     // remove example tag's level filter, all level log will resume output*     ulog_set_filter_lvl("example", LOG_FILTER_LVL_ALL);** @param tag log tag* @param level The filter level. When the level is LOG_FILTER_LVL_SILENT, the log enter silent mode.*        When the level is LOG_FILTER_LVL_ALL, it will remove this tag's level filer.*        Then all level log will resume output.** @return  0 : success*         -5 : no memory*         -10: level is out of range*/
int ulog_tag_lvl_filter_set(const char *tag, rt_uint32_t level)
{rt_slist_t *node;ulog_tag_lvl_filter_t tag_lvl = RT_NULL;int result = RT_EOK;if (level > LOG_FILTER_LVL_ALL)return -RT_EINVAL;if (!ulog.init_ok)return result;/* lock output */output_lock();/* find the tag in list */for (node = rt_slist_first(ulog_tag_lvl_list_get()); node; node = rt_slist_next(node)){tag_lvl = rt_slist_entry(node, struct ulog_tag_lvl_filter, list);if (!rt_strncmp(tag_lvl->tag, tag, ULOG_FILTER_TAG_MAX_LEN)){break;}else{tag_lvl = RT_NULL;}}/* find OK */if (tag_lvl){if (level == LOG_FILTER_LVL_ALL){/* remove current tag's level filter when input level is the lowest level */rt_slist_remove(ulog_tag_lvl_list_get(), &tag_lvl->list);rt_free(tag_lvl);}else{/* update level */tag_lvl->level = level;}}else{/* only add the new tag's level filer when level is not LOG_FILTER_LVL_ALL */if (level != LOG_FILTER_LVL_ALL){/* new a tag's level filter */tag_lvl = (ulog_tag_lvl_filter_t)rt_malloc(sizeof(struct ulog_tag_lvl_filter));if (tag_lvl){rt_memset(tag_lvl->tag, 0 , sizeof(tag_lvl->tag));rt_strncpy(tag_lvl->tag, tag, ULOG_FILTER_TAG_MAX_LEN);tag_lvl->level = level;rt_slist_append(ulog_tag_lvl_list_get(), &tag_lvl->list);}else{result = -RT_ENOMEM;}}}/* unlock output */output_unlock();return result;
}/*** get the level on tag's level filer** @param tag log tag** @return It will return the lowest level when tag was not found.*         Other level will return when tag was found.*/
rt_uint32_t ulog_tag_lvl_filter_get(const char *tag)
{rt_slist_t *node;ulog_tag_lvl_filter_t tag_lvl = RT_NULL;rt_uint32_t level = LOG_FILTER_LVL_ALL;if (!ulog.init_ok)return level;/* lock output */output_lock();/* find the tag in list */for (node = rt_slist_first(ulog_tag_lvl_list_get()); node; node = rt_slist_next(node)){tag_lvl = rt_slist_entry(node, struct ulog_tag_lvl_filter, list);if (!rt_strncmp(tag_lvl->tag, tag, ULOG_FILTER_TAG_MAX_LEN)){level = tag_lvl->level;break;}}/* unlock output */output_unlock();return level;
}/*** get the tag's level list on filter** @return tag's level list*/
rt_slist_t *ulog_tag_lvl_list_get(void)
{return &ulog.filter.tag_lvl_list;
}/*** set log global filter level** @param level log level: LOG_LVL_ASSERT, LOG_LVL_ERROR, LOG_LVL_WARNING, LOG_LVL_INFO, LOG_LVL_DBG*              LOG_FILTER_LVL_SILENT: disable all log output, except assert level*              LOG_FILTER_LVL_ALL: enable all log output*/
void ulog_global_filter_lvl_set(rt_uint32_t level)
{RT_ASSERT(level <= LOG_FILTER_LVL_ALL);ulog.filter.level = level;
}/*** get log global filter level** @return log level: LOG_LVL_ASSERT, LOG_LVL_ERROR, LOG_LVL_WARNING, LOG_LVL_INFO, LOG_LVL_DBG*              LOG_FILTER_LVL_SILENT: disable all log output, except assert level*              LOG_FILTER_LVL_ALL: enable all log output*/
rt_uint32_t ulog_global_filter_lvl_get(void)
{return ulog.filter.level;
}/*** set log global filter tag** @param tag tag*/
void ulog_global_filter_tag_set(const char *tag)
{RT_ASSERT(tag);rt_strncpy(ulog.filter.tag, tag, ULOG_FILTER_TAG_MAX_LEN);
}/*** get log global filter tag** @return tag*/
const char *ulog_global_filter_tag_get(void)
{return ulog.filter.tag;
}/*** set log global filter keyword** @param keyword keyword*/
void ulog_global_filter_kw_set(const char *keyword)
{RT_ASSERT(keyword);rt_strncpy(ulog.filter.keyword, keyword, ULOG_FILTER_KW_MAX_LEN);
}/*** get log global filter keyword** @return keyword*/
const char *ulog_global_filter_kw_get(void)
{return ulog.filter.keyword;
}#ifdef RT_USING_FINSH
#include <finsh.h>static void _print_lvl_info(void)
{
#ifndef ULOG_USING_SYSLOGrt_kprintf("Assert  : 0\n");rt_kprintf("Error   : 3\n");rt_kprintf("Warning : 4\n");rt_kprintf("Info    : 6\n");rt_kprintf("Debug   : 7\n");
#elsert_kprintf("EMERG   :   1 (1 << 0)\n");rt_kprintf("ALERT   :   2 (1 << 1)\n");rt_kprintf("CRIT    :   4 (1 << 2)\n");rt_kprintf("ERR     :   8 (1 << 3)\n");rt_kprintf("WARNING :  16 (1 << 4)\n");rt_kprintf("NOTICE  :  32 (1 << 5)\n");rt_kprintf("INFO    :  64 (1 << 6)\n");rt_kprintf("DEBUG   : 128 (1 << 7)\n");
#endif /* ULOG_USING_SYSLOG */
}static void ulog_be_lvl(uint8_t argc, char **argv)
{if (argc > 2){if ((atoi(argv[2]) <= LOG_FILTER_LVL_ALL) && (atoi(argv[2]) >= 0)){ulog_be_lvl_filter_set(argv[1], atoi(argv[2]));}else{rt_kprintf("Please input correct level (0-%d).\n", LOG_FILTER_LVL_ALL);}}else{rt_kprintf("Please input: ulog_be_lvl <be_name> <level>.\n");_print_lvl_info();}
}
MSH_CMD_EXPORT(ulog_be_lvl, Set ulog filter level by different backend.);static void ulog_tag_lvl(uint8_t argc, char **argv)
{if (argc > 2){if ((atoi(argv[2]) <= LOG_FILTER_LVL_ALL) && (atoi(argv[2]) >= 0)){ulog_tag_lvl_filter_set(argv[1], atoi(argv[2]));}else{rt_kprintf("Please input correct level (0-%d).\n", LOG_FILTER_LVL_ALL);}}else{rt_kprintf("Please input: ulog_tag_lvl <tag> <level>.\n");_print_lvl_info();}
}
MSH_CMD_EXPORT(ulog_tag_lvl, Set ulog filter level by different tag.);static void ulog_lvl(uint8_t argc, char **argv)
{if (argc > 1){if ((atoi(argv[1]) <= LOG_FILTER_LVL_ALL) && (atoi(argv[1]) >= 0)){ulog_global_filter_lvl_set(atoi(argv[1]));}else{rt_kprintf("Please input correct level (0-%d).\n", LOG_FILTER_LVL_ALL);}}else{rt_kprintf("Please input: ulog_lvl <level>.\n");_print_lvl_info();}
}
MSH_CMD_EXPORT(ulog_lvl, Set ulog global filter level.);static void ulog_tag(uint8_t argc, char **argv)
{if (argc > 1){if (rt_strlen(argv[1]) <= ULOG_FILTER_TAG_MAX_LEN){ulog_global_filter_tag_set(argv[1]);}else{rt_kprintf("The tag length is too long. Max is %d.\n", ULOG_FILTER_TAG_MAX_LEN);}}else{ulog_global_filter_tag_set("");}
}
MSH_CMD_EXPORT(ulog_tag, Set ulog global filter tag);static void ulog_kw(uint8_t argc, char **argv)
{if (argc > 1){if (rt_strlen(argv[1]) <= ULOG_FILTER_KW_MAX_LEN){ulog_global_filter_kw_set(argv[1]);}else{rt_kprintf("The keyword length is too long. Max is %d.\n", ULOG_FILTER_KW_MAX_LEN);}}else{ulog_global_filter_kw_set("");}
}
MSH_CMD_EXPORT(ulog_kw, Set ulog global filter keyword);static void ulog_filter(uint8_t argc, char **argv)
{
#ifndef ULOG_USING_SYSLOGconst char *lvl_name[] = { "Assert ", "Error  ", "Error  ", "Error  ", "Warning", "Info   ", "Info   ", "Debug  " };
#endifconst char *tag = ulog_global_filter_tag_get(), *kw = ulog_global_filter_kw_get();rt_slist_t *node;ulog_tag_lvl_filter_t tag_lvl = RT_NULL;rt_kprintf("--------------------------------------\n");rt_kprintf("ulog global filter:\n");#ifndef ULOG_USING_SYSLOGrt_kprintf("level   : %s\n", lvl_name[ulog_global_filter_lvl_get()]);
#elsert_kprintf("level   : %d\n", ulog_global_filter_lvl_get());
#endifrt_kprintf("tag     : %s\n", rt_strlen(tag) == 0 ? "NULL" : tag);rt_kprintf("keyword : %s\n", rt_strlen(kw) == 0 ? "NULL" : kw);rt_kprintf("--------------------------------------\n");rt_kprintf("ulog tag's level filter:\n");if (rt_slist_isempty(ulog_tag_lvl_list_get())){rt_kprintf("settings not found\n");}else{/* lock output */output_lock();/* show the tag level list */for (node = rt_slist_first(ulog_tag_lvl_list_get()); node; node = rt_slist_next(node)){tag_lvl = rt_slist_entry(node, struct ulog_tag_lvl_filter, list);rt_kprintf("%-*.s: ", ULOG_FILTER_TAG_MAX_LEN, tag_lvl->tag);#ifndef ULOG_USING_SYSLOGrt_kprintf("%s\n", lvl_name[tag_lvl->level]);
#elsert_kprintf("%d\n", tag_lvl->level);
#endif}/* unlock output */output_unlock();}
}
MSH_CMD_EXPORT(ulog_filter, Show ulog filter settings);
#endif /* RT_USING_FINSH */
#endif /* ULOG_USING_FILTER */rt_err_t ulog_backend_register(ulog_backend_t backend, const char *name, rt_bool_t support_color)
{rt_base_t level;RT_ASSERT(backend);RT_ASSERT(name);RT_ASSERT(ulog.init_ok);RT_ASSERT(backend->output);if (backend->init){backend->init(backend);}backend->support_color = support_color;backend->out_level = LOG_FILTER_LVL_ALL;rt_strncpy(backend->name, name, RT_NAME_MAX);level = rt_hw_interrupt_disable();rt_slist_append(&ulog.backend_list, &backend->list);rt_hw_interrupt_enable(level);return RT_EOK;
}rt_err_t ulog_backend_unregister(ulog_backend_t backend)
{rt_base_t level;RT_ASSERT(backend);RT_ASSERT(ulog.init_ok);if (backend->deinit){backend->deinit(backend);}level = rt_hw_interrupt_disable();rt_slist_remove(&ulog.backend_list, &backend->list);rt_hw_interrupt_enable(level);return RT_EOK;
}rt_err_t ulog_backend_set_filter(ulog_backend_t backend, ulog_backend_filter_t filter)
{rt_base_t level;RT_ASSERT(backend);level = rt_hw_interrupt_disable();backend->filter = filter;rt_hw_interrupt_enable(level);return RT_EOK;
}ulog_backend_t ulog_backend_find(const char *name)
{rt_base_t level;rt_slist_t *node;ulog_backend_t backend;RT_ASSERT(ulog.init_ok);level = rt_hw_interrupt_disable();for (node = rt_slist_first(&ulog.backend_list); node; node = rt_slist_next(node)){backend = rt_slist_entry(node, struct ulog_backend, list);if (rt_strncmp(backend->name, name, RT_NAME_MAX) == 0){rt_hw_interrupt_enable(level);return backend;}}rt_hw_interrupt_enable(level);return RT_NULL;
}#ifdef ULOG_USING_ASYNC_OUTPUT
/*** asynchronous output logs to all backends** @note you must call this function when ULOG_ASYNC_OUTPUT_BY_THREAD is disable*/
void ulog_async_output(void)
{rt_rbb_blk_t log_blk;ulog_frame_t log_frame;if (!ulog.async_enabled){return;}while ((log_blk = rt_rbb_blk_get(ulog.async_rbb)) != RT_NULL){log_frame = (ulog_frame_t) log_blk->buf;if (log_frame->magic == ULOG_FRAME_MAGIC){/* output to all backends */ulog_output_to_all_backend(log_frame->level, log_frame->tag, log_frame->is_raw, log_frame->log,log_frame->log_len);}rt_rbb_blk_free(ulog.async_rbb, log_blk);}/* output the log_raw format log */if (ulog.async_rb){rt_size_t log_len = rt_ringbuffer_data_len(ulog.async_rb);char *log = rt_malloc(log_len + 1);if (log){rt_size_t len = rt_ringbuffer_get(ulog.async_rb, (rt_uint8_t *)log, log_len);log[log_len] = '\0';ulog_output_to_all_backend(LOG_LVL_DBG, "", RT_TRUE, log, len);rt_free(log);}}
}/*** enable or disable asynchronous output mode* the log will be output directly when mode is disabled** @param enabled RT_TRUE: enabled, RT_FALSE: disabled*/
void ulog_async_output_enabled(rt_bool_t enabled)
{ulog.async_enabled = enabled;
}/*** waiting for get asynchronous output log** @param time the waiting time** @return the operation status, RT_EOK on successful*/
rt_err_t ulog_async_waiting_log(rt_int32_t time)
{rt_sem_control(&ulog.async_notice, RT_IPC_CMD_RESET, RT_NULL);return rt_sem_take(&ulog.async_notice, time);
}static void async_output_thread_entry(void *param)
{ulog_async_output();while (1){ulog_async_waiting_log(RT_WAITING_FOREVER);while (1){ulog_async_output();/* If there is no log output for a certain period of time,* refresh the log buffer*/if (ulog_async_waiting_log(RT_TICK_PER_SECOND * 2) == RT_EOK){continue;}else{ulog_flush();break;}}}
}
#endif /* ULOG_USING_ASYNC_OUTPUT *//*** flush all backends's log*/
void ulog_flush(void)
{rt_slist_t *node;ulog_backend_t backend;if (!ulog.init_ok)return;#ifdef ULOG_USING_ASYNC_OUTPUTulog_async_output();
#endif/* flush all backends */for (node = rt_slist_first(&ulog.backend_list); node; node = rt_slist_next(node)){backend = rt_slist_entry(node, struct ulog_backend, list);if (backend->flush){backend->flush(backend);}}
}int ulog_init(void)
{if (ulog.init_ok)return 0;rt_mutex_init(&ulog.output_locker, "ulog", RT_IPC_FLAG_PRIO);ulog.output_lock_enabled = RT_TRUE;rt_slist_init(&ulog.backend_list);#ifdef ULOG_USING_FILTERrt_slist_init(ulog_tag_lvl_list_get());
#endif#ifdef ULOG_USING_ASYNC_OUTPUTRT_ASSERT(ULOG_ASYNC_OUTPUT_STORE_LINES >= 2);ulog.async_enabled = RT_TRUE;/* async output ring block buffer */ulog.async_rbb = rt_rbb_create(RT_ALIGN(ULOG_ASYNC_OUTPUT_BUF_SIZE, RT_ALIGN_SIZE), ULOG_ASYNC_OUTPUT_STORE_LINES);if (ulog.async_rbb == RT_NULL){rt_kprintf("Error: ulog init failed! No memory for async rbb.\n");rt_mutex_detach(&ulog.output_locker);return -RT_ENOMEM;}rt_sem_init(&ulog.async_notice, "ulog", 0, RT_IPC_FLAG_FIFO);
#endif /* ULOG_USING_ASYNC_OUTPUT */#ifdef ULOG_USING_FILTERulog_global_filter_lvl_set(LOG_FILTER_LVL_ALL);
#endifulog.init_ok = RT_TRUE;return 0;
}
INIT_BOARD_EXPORT(ulog_init);#ifdef ULOG_USING_ASYNC_OUTPUT
int ulog_async_init(void)
{if (ulog.async_th == RT_NULL){/* async output thread */ulog.async_th = rt_thread_create("ulog_async", async_output_thread_entry, &ulog, ULOG_ASYNC_OUTPUT_THREAD_STACK,ULOG_ASYNC_OUTPUT_THREAD_PRIORITY, 20);if (ulog.async_th == RT_NULL){rt_kprintf("Error: ulog init failed! No memory for async output thread.\n");return -RT_ENOMEM;}/* async output thread startup */rt_thread_startup(ulog.async_th);}return 0;
}
INIT_PREV_EXPORT(ulog_async_init);
#endif /* ULOG_USING_ASYNC_OUTPUT */void ulog_deinit(void)
{rt_slist_t *node;ulog_backend_t backend;if (!ulog.init_ok)return;/* deinit all backends */for (node = rt_slist_first(&ulog.backend_list); node; node = rt_slist_next(node)){backend = rt_slist_entry(node, struct ulog_backend, list);if (backend->deinit){backend->deinit(backend);}}#ifdef ULOG_USING_FILTER/* deinit tag's level filter */{ulog_tag_lvl_filter_t tag_lvl;for (node = rt_slist_first(ulog_tag_lvl_list_get()); node; node = rt_slist_next(node)){tag_lvl = rt_slist_entry(node, struct ulog_tag_lvl_filter, list);rt_free(tag_lvl);}}
#endif /* ULOG_USING_FILTER */rt_mutex_detach(&ulog.output_locker);#ifdef ULOG_USING_ASYNC_OUTPUTrt_rbb_destroy(ulog.async_rbb);rt_thread_delete(ulog.async_th);if (ulog.async_rb)rt_ringbuffer_destroy(ulog.async_rb);
#endifulog.init_ok = RT_FALSE;
}#endif /* RT_USING_ULOG */