diff options
| -rw-r--r-- | inc/MESA_shm_ring_queue.h | 19 | ||||
| -rw-r--r-- | shm_consumer/MESA_shm_consumer.c | 214 | ||||
| -rw-r--r-- | src/MESA_handle_logger.c | 6 | ||||
| -rw-r--r-- | src/MESA_shm_ring_queue.c | 75 |
4 files changed, 257 insertions, 57 deletions
diff --git a/inc/MESA_shm_ring_queue.h b/inc/MESA_shm_ring_queue.h index 7d82d8d..7b7c3df 100644 --- a/inc/MESA_shm_ring_queue.h +++ b/inc/MESA_shm_ring_queue.h @@ -15,15 +15,19 @@ #define MESA_CONSUMER_RUNNING 1 #define MESA_CONSUMER_NOT_RUNNING 0 -#define MESA_CONSUMER_CARE_PID_NUM 128 +#define MESA_SHM_PID_NUM 128 #define MESA_MATCH_CONSUMER_RULE_SUCCESS 0 #define MESA_MATCH_CONSUMER_RULE_FAIL -1 #define MESA_MATCH_CONSUMER_RULE_FAIL_STATUS -2 #define MESA_MATCH_CONSUMER_RULE_FAIL_LEVEL -3 #define MESA_MATCH_CONSUMER_RULE_FAIL_PID -4 +#define MESA_MATCH_CONSUMER_RULE_FAIL_MODULE -5 +#define MESA_SHM_MODULE_NUM 32 +#define MESA_SHM_MODULE_NAME_LEN 128 + #define MESA_CONSUMER_LEVEL_ALL 0 #define MESA_CONSUMER_LEVEL_DEBUG (1 << 0) @@ -49,14 +53,15 @@ struct MESA_shm_queue_head{ int ovw_idx; }; -struct MESA_consumer{ +struct MESA_shm_consumer{ int status; int log_level; unsigned long long reload_age; - int care_pid[MESA_CONSUMER_CARE_PID_NUM]; + int pid[MESA_SHM_PID_NUM]; + char module[MESA_SHM_MODULE_NUM][sizeof(int) + MESA_SHM_MODULE_NAME_LEN]; }; -struct MESA_log_buf{ +struct MESA_shm_log_buf{ char *buf; char *log_file; char *module; @@ -66,18 +71,18 @@ struct MESA_log_buf{ int level; }; -int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct MESA_consumer **consumer_status); +int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct MESA_shm_consumer **consumer_status); struct MESA_shm_queue_head *MESA_shm_get_ring_queue(); void MESA_shm_init(); void MESA_shm_recycle_ring_queue(struct MESA_shm_queue_head *ring_queue_head); -int MESA_shm_copy_buf_to_ring_queue(struct MESA_shm_queue_head *head, struct MESA_log_buf *lbuf); +int MESA_shm_copy_buf_to_ring_queue(struct MESA_shm_queue_head *head, struct MESA_shm_log_buf *lbuf); int MESA_shm_ring_queue_is_empty(struct MESA_shm_queue_head *head); int MESA_shm_ring_queue_is_full(struct MESA_shm_queue_head *head); void *MESA_shm_ring_queue_get_read_pos(struct MESA_shm_queue_head *head); void *MESA_shm_ring_queue_get_write_pos(struct MESA_shm_queue_head *head); void MESA_shm_ring_queue_push_read_pos(struct MESA_shm_queue_head *head); void MESA_shm_ring_queue_push_write_pos(struct MESA_shm_queue_head *head); -int MESA_shm_match_consumer_rule(int level, int pid); +int MESA_shm_match_consumer_rule(int level, int pid, const char *module); void MESA_shm_unlink(struct MESA_shm_overview *ovw, int ovw_shmid); const char *loglevel_to_name(int level); diff --git a/shm_consumer/MESA_shm_consumer.c b/shm_consumer/MESA_shm_consumer.c index 2a67c84..66b3710 100644 --- a/shm_consumer/MESA_shm_consumer.c +++ b/shm_consumer/MESA_shm_consumer.c @@ -22,7 +22,7 @@ #define CONSUMER_OUTPUT_MODE_FILE 0 #define CONSUMER_OUTPUT_MODE_TERMINAL 1 -#define CONSUMER_CARE_PID_MAX_LEN 128 +#define CONSUMER_PID_MAX_LEN 128 #ifdef CONSUMER_DEBUG #define consumer_debug(...) \ @@ -47,14 +47,19 @@ struct log_file_list{ ino_t ino; struct list_head list; }; -struct care_pid_list{ +struct pid_list{ int pid; struct list_head list; }; +struct module_list{ + char module[MESA_SHM_MODULE_NAME_LEN]; + struct list_head list; +}; struct log_file_list g_log_file_list; -struct care_pid_list g_care_pid_list; +struct pid_list g_pid_list; +struct module_list g_module_list; int g_output_mode = CONSUMER_OUTPUT_MODE_FILE; -struct MESA_consumer *g_status = NULL; +struct MESA_shm_consumer *g_status = NULL; int g_tmp_lv = MESA_CONSUMER_LEVEL_ALL; int g_cur_tty_fd = -1; struct MESA_shm_overview *g_shm_overview = NULL; @@ -325,32 +330,33 @@ void consumer_ring_queue_to_terminal(struct MESA_shm_queue_head *head, int produ return ; } -int producer_pid_is_cared(int producer_pid) +int pid_is_exist(int producer_pid) { - struct care_pid_list *tmp; - struct care_pid_list *n; - list_for_each_entry_safe(tmp, n, &g_care_pid_list.list, list){ + struct pid_list *tmp; + struct pid_list *n; + list_for_each_entry_safe(tmp, n, &g_pid_list.list, list){ if(tmp->pid == producer_pid){ return 1; } } return 0; } -struct care_pid_list *create_care_pid_node(int pid) +struct pid_list *create_pid_node(int pid) { - struct care_pid_list *node; - node = (struct care_pid_list *)malloc(sizeof(struct care_pid_list)); + struct pid_list *node; + node = (struct pid_list *)malloc(sizeof(struct pid_list)); if(node == NULL){ printf("malloc pid node error\n"); return NULL; } + memset(node, 0 ,sizeof(struct pid_list)); node->pid = pid; return node; } -int add_care_pid_node(struct care_pid_list *node, int pid) +int add_pid_node(struct pid_list *node) { - if(!producer_pid_is_cared(pid)){ - list_add(&node->list, &g_care_pid_list.list); + if(!pid_is_exist(node->pid)){ + list_add(&node->list, &g_pid_list.list); }else{ free(node); printf("pid repeat\n"); @@ -358,13 +364,15 @@ int add_care_pid_node(struct care_pid_list *node, int pid) } return CONSUMER_SUCCESS; } -int move_care_pid_list_to_shm(int *pid, int max_num) + + +int move_pid_list_to_shm(int *pid) { - struct care_pid_list *tmp; - struct care_pid_list *n; + struct pid_list *tmp; + struct pid_list *n; int pid_num = 0; - list_for_each_entry_safe(tmp, n, &g_care_pid_list.list, list){ - if(pid_num < max_num){ + list_for_each_entry_safe(tmp, n, &g_pid_list.list, list){ + if(pid_num < MESA_SHM_PID_NUM){ pid[pid_num] = tmp->pid; pid_num ++; } @@ -373,15 +381,14 @@ int move_care_pid_list_to_shm(int *pid, int max_num) } return CONSUMER_SUCCESS; } - -int parse_care_pid(char *p_pid) +int parse_pid(char *p_pid) { char *cur; char *p; - char tmp_pid_str[CONSUMER_CARE_PID_MAX_LEN] = {0}; + char tmp_pid_str[CONSUMER_PID_MAX_LEN] = {0}; int tmp_pid; int argcc = 0; - struct care_pid_list *node = NULL;; + struct pid_list *node = NULL; cur = p_pid; p = p_pid; int pid_num = 0; @@ -411,17 +418,17 @@ int parse_care_pid(char *p_pid) while(isspace(*cur)){ cur++; } - if(pid_num >= MESA_CONSUMER_CARE_PID_NUM){ + if(pid_num >= MESA_SHM_PID_NUM){ printf("pid num overload\n"); return CONSUMER_ERROR; } pid_num ++; tmp_pid = atoi(tmp_pid_str); - node = create_care_pid_node(tmp_pid); + node = create_pid_node(tmp_pid); if(node == NULL){ return CONSUMER_ERROR; } - if(add_care_pid_node(node,tmp_pid) == CONSUMER_ERROR){ + if(add_pid_node(node) == CONSUMER_ERROR){ printf("add pid error\n"); return CONSUMER_ERROR; } @@ -433,16 +440,16 @@ int parse_care_pid(char *p_pid) return CONSUMER_ERROR; } if(*cur == 0 && tmp_pid_str[0] != '\0'){ - if(pid_num >= MESA_CONSUMER_CARE_PID_NUM){ + if(pid_num >= MESA_SHM_PID_NUM){ printf("pid num overload\n"); return CONSUMER_ERROR; } tmp_pid = atoi(tmp_pid_str); - node = create_care_pid_node(tmp_pid); + node = create_pid_node(tmp_pid); if(node == NULL){ return CONSUMER_ERROR; } - if(add_care_pid_node(node,tmp_pid) == CONSUMER_ERROR){ + if(add_pid_node(node) == CONSUMER_ERROR){ printf("add pid error\n"); return CONSUMER_ERROR; } @@ -450,6 +457,120 @@ int parse_care_pid(char *p_pid) } return CONSUMER_SUCCESS; } +struct module_list *create_module_node(char *module) +{ + struct module_list *node; + node = (struct module_list *)malloc(sizeof(struct module_list)); + if(node == NULL){ + printf("malloc module node error\n"); + return NULL; + } + memset(node, 0, sizeof(struct module_list)); + memcpy(node->module, module, strlen(module)); + return node; +} +int module_is_exist(char *module) +{ + struct module_list *tmp; + struct module_list *n; + list_for_each_entry_safe(tmp, n, &g_module_list.list, list){ + if(strcmp(tmp->module, module) == 0){ + return 1; + } + } + return 0; +} +int add_module_node(struct module_list *node) +{ + if(!module_is_exist(node->module)){ + list_add(&node->list, &g_module_list.list); + }else{ + free(node); + printf("module repeat\n"); + return CONSUMER_ERROR; + } + return CONSUMER_SUCCESS; +} +int move_module_list_to_shm(char module[MESA_SHM_MODULE_NUM][sizeof(int) + MESA_SHM_MODULE_NAME_LEN]) +{ + struct module_list *tmp; + struct module_list *n; + int module_num = 0; + int module_len = 0; + list_for_each_entry_safe(tmp, n, &g_module_list.list, list){ + if(module_num < MESA_SHM_MODULE_NUM){ + module_len = strlen(tmp->module); + if(module_len < MESA_SHM_MODULE_NAME_LEN){ + *((int *)module[module_num]) = module_len; + memcpy(module[module_num] + sizeof(int), tmp->module, module_len); + module_num ++ ; + } + } + list_del(&tmp->list); + free(tmp); + } + return CONSUMER_SUCCESS; +} +int parse_module(char *module) +{ + char tmp_module[MESA_SHM_MODULE_NAME_LEN] = {0}; + int argcc = 0; + char *cur = module; + int module_num = 0; + struct module_list *node = NULL; + while(isspace(*cur)){ + cur++; + } + while(1){ + if(*cur == '\0'){ + break ; + } + if(!isspace(*cur)){ + tmp_module[argcc] = *cur; + argcc++; + cur++; + }else{ + while(isspace(*cur)){ + cur++; + } + if(module_num >= MESA_SHM_MODULE_NUM){ + printf("module num overload\n"); + return CONSUMER_ERROR; + } + module_num ++; + node = create_module_node(tmp_module); + if(node == NULL){ + return CONSUMER_ERROR; + } + if(add_module_node(node) == CONSUMER_ERROR){ + printf("add module error\n"); + return CONSUMER_ERROR; + } + memset(tmp_module, 0 ,sizeof(tmp_module)); + argcc = 0; + } + if(argcc >= sizeof(tmp_module)){ + printf("invalid module\n"); + return CONSUMER_ERROR; + } + if(*cur == 0 && tmp_module[0] != '\0'){ + if(module_num >= MESA_SHM_MODULE_NUM){ + printf("module num overload\n"); + return CONSUMER_ERROR; + } + node = create_module_node(tmp_module); + if(node == NULL){ + return CONSUMER_ERROR; + } + if(add_module_node(node) == CONSUMER_ERROR){ + printf("add module error\n"); + return CONSUMER_ERROR; + } + } + } + +} + int check_level(char *level) { if(level == NULL || level[0] == '\0'){ @@ -508,6 +629,7 @@ int parse_log_level(char *level) } return CONSUMER_SUCCESS; } + int get_options(int argc, char **argv) { char *p; @@ -522,7 +644,7 @@ int get_options(int argc, char **argv) if(strcmp(argv[i], "all") == 0){ /*do nothing now*/ }else{ - if(parse_care_pid(argv[i]) == CONSUMER_ERROR){ + if(parse_pid(argv[i]) == CONSUMER_ERROR){ printf("parse pid error\n"); return CONSUMER_ERROR; } @@ -555,6 +677,19 @@ int get_options(int argc, char **argv) printf("miss parameter\n"); return CONSUMER_ERROR; } + }else if(strcmp(p, "module") == 0){ + if(argv[++i]){ + if(strcmp(argv[i], "all") == 0){ + /*do nothing now*/ + }else{ + if(parse_module(argv[i]) == CONSUMER_ERROR){ + return CONSUMER_ERROR; + } + } + }else{ + printf("miss parameter\n"); + return CONSUMER_ERROR; + } }else{ printf("invalid option:%s\n",p); return CONSUMER_ERROR; @@ -662,10 +797,12 @@ void register_sginal_handler() } void print_help(char *exe_name) { - printf("-pid default all, optional parameter\n"); - printf("-mode default file, optional parameter\n"); - printf("-level default all, optional parameter\n"); - printf("./%s -pid [ '$pid1 $pid2 $pid3...' | all ] -mode [ file | terminal ] -level [ all | 'debug info...']\n",exe_name); + printf("-pid filter producer process pid, default all\n"); + printf("-mode set the output to where, default file\n"); + printf("-level filter log level, default all\n"); + printf("-module filter module name, support wildcard character '*', default all\n"); + printf("./%s -pid [ all | '$pid1 $pid2 $pid3...' ] -mode [ file | terminal ] -level [ all | 'debug info fatal...'] -module [ all | 'module module* *module* *module*name*...' ]\n",exe_name); + printf("./%s stop exit the consumer process\n", exe_name); return ; } int main(int argc, char **argv) @@ -679,7 +816,8 @@ int main(int argc, char **argv) kill_old_process(exe_name); return 0; } - INIT_LIST_HEAD(&g_care_pid_list.list); + INIT_LIST_HEAD(&g_pid_list.list); + INIT_LIST_HEAD(&g_module_list.list); if(get_options(argc, argv) < 0){ printf("parse options error\n"); return 0; @@ -700,8 +838,10 @@ int main(int argc, char **argv) return 0; } g_status->log_level = g_tmp_lv; - memset(g_status->care_pid, 0 ,sizeof(g_status->care_pid)); - move_care_pid_list_to_shm(g_status->care_pid, MESA_CONSUMER_CARE_PID_NUM); + memset(g_status->pid, 0 ,sizeof(g_status->pid)); + memset(g_status->module, 0, sizeof(g_status->module)); + move_pid_list_to_shm(g_status->pid); + move_module_list_to_shm(g_status->module); if(g_status->reload_age < ULLONG_MAX){ g_status->reload_age ++; } diff --git a/src/MESA_handle_logger.c b/src/MESA_handle_logger.c index f472a38..b0f910b 100644 --- a/src/MESA_handle_logger.c +++ b/src/MESA_handle_logger.c @@ -332,15 +332,15 @@ void MESA_handle_runtime_log(void *handle, int level, const char *module, const log_handle_t *p_handle = (log_handle_t *)handle; int n = 0; int payload_len = 0; - struct MESA_log_buf lbuf; - if(p_handle == NULL || p_handle->runtime_log_file == NULL){ + struct MESA_shm_log_buf lbuf; + if(p_handle == NULL || p_handle->runtime_log_file == NULL || module == NULL){ return; } if(p_handle->zc == NULL){ return; } struct MESA_pthread_private *pri = (struct MESA_pthread_private *)pthread_getspecific(MESA_pthread_key); - int match_result = MESA_shm_match_consumer_rule(level, p_handle->pid); + int match_result = MESA_shm_match_consumer_rule(level, p_handle->pid, module); if(match_result != MESA_MATCH_CONSUMER_RULE_SUCCESS){ if(pri != NULL && match_result == MESA_MATCH_CONSUMER_RULE_FAIL_PID){ /*the process pid will not be consumed, we need to free the memory and recycle the ring queue*/ diff --git a/src/MESA_shm_ring_queue.c b/src/MESA_shm_ring_queue.c index 13cb23e..94f10ca 100644 --- a/src/MESA_shm_ring_queue.c +++ b/src/MESA_shm_ring_queue.c @@ -15,7 +15,7 @@ struct MESA_shm_overview *MESA_shm_ovw = NULL; struct MESA_shm_queue_head *MESA_ring_queue_head[MESA_SHM_RING_QUEUE_NUM] = {NULL}; int MESA_shm_ovw_id = -1; -struct MESA_consumer *MESA_consumer_status = NULL; +struct MESA_shm_consumer *MESA_consumer_status = NULL; void MESA_shm_init_ring_queue_mutex(struct MESA_shm_overview *ovw) @@ -82,9 +82,9 @@ void MESA_shm_register_sginal_handler() signal(SIGQUIT, MESA_shm_check_unlink); return ; } -int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct MESA_consumer **consumer_status) +int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct MESA_shm_consumer **consumer_status) { - int shmsize = (sizeof(struct MESA_shm_overview) * MESA_SHM_RING_QUEUE_NUM) + sizeof(struct MESA_consumer); + int shmsize = (sizeof(struct MESA_shm_overview) * MESA_SHM_RING_QUEUE_NUM) + sizeof(struct MESA_shm_consumer); struct MESA_shm_overview *shm_overview = NULL; struct MESA_shm_overview *tmp_ovw = NULL; int i = 0; @@ -108,7 +108,7 @@ int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct } *ovw = shm_overview; *ovw_id = shmid; - *consumer_status = (struct MESA_consumer *)(shm_overview + MESA_SHM_RING_QUEUE_NUM); + *consumer_status = (struct MESA_shm_consumer *)(shm_overview + MESA_SHM_RING_QUEUE_NUM); } }else{ @@ -118,7 +118,7 @@ int MESA_shm_alloc_overview(struct MESA_shm_overview **ovw, int *ovw_id, struct } *ovw = shm_overview; *ovw_id = shmid; - *consumer_status = (struct MESA_consumer *)(shm_overview + MESA_SHM_RING_QUEUE_NUM); + *consumer_status = (struct MESA_shm_consumer *)(shm_overview + MESA_SHM_RING_QUEUE_NUM); } return 0; } @@ -274,7 +274,7 @@ void MESA_shm_ring_queue_push_write_pos(struct MESA_shm_queue_head *head) /* (int)log_file_len + (str)log_file + '\0' + (int)level + (int)module_len + (str)module + '\0' + (int)payload_len + (str)payload + '\0' */ -int MESA_shm_copy_buf_to_ring_queue(struct MESA_shm_queue_head *head, struct MESA_log_buf *lbuf) +int MESA_shm_copy_buf_to_ring_queue(struct MESA_shm_queue_head *head, struct MESA_shm_log_buf *lbuf) { int available_len = 0, payload_len = 0; int *pi = NULL;; @@ -375,7 +375,7 @@ int MESA_shm_match_pid(int *p_pid, int cur_pid) if(p_pid[0] == 0){ return MESA_MATCH_CONSUMER_RULE_SUCCESS; } - for(i = 0; i < MESA_CONSUMER_CARE_PID_NUM; i++){ + for(i = 0; i < MESA_SHM_PID_NUM; i++){ if(p_pid[i] == 0){ break ; } @@ -385,7 +385,58 @@ int MESA_shm_match_pid(int *p_pid, int cur_pid) } return MESA_MATCH_CONSUMER_RULE_FAIL; } -int MESA_shm_match_consumer_rule(int level, int pid) +int MESA_shm_string_match_success(char *src, int src_len, char *pattern, int pattern_len) { + int i = 0; + int j = 0; + int start_pos = -1; + int match = -1; + while(i < src_len){ + if(j < pattern_len && src[i] == pattern[j]){ + i++; + j++; + } + else if(j < pattern_len && pattern[j] == '*'){ + start_pos = j; + match = i; + j = start_pos + 1; + } + else if(start_pos != -1){ + match++; + i = match; + j = start_pos + 1; + } + else{ + return 0; + } + } + while(j < pattern_len && pattern[j] == '*'){ + j++ ; + }; + return (j==pattern_len); +} + +int MESA_shm_match_module(const char *module) +{ + int i; + int shn_module_len; + char *shm_module; + int enable = *((int *)MESA_consumer_status->module[0]); + if(enable == 0){ + return MESA_MATCH_CONSUMER_RULE_SUCCESS; + } + for(i = 0; i < MESA_SHM_MODULE_NUM; i++){ + shn_module_len = *((int *)MESA_consumer_status->module[i]); + if(shn_module_len == 0){ + break ; + } + shm_module = MESA_consumer_status->module[i] + sizeof(int); + if(MESA_shm_string_match_success((char *)module, (int)strlen(module), shm_module, shn_module_len)){ + return MESA_MATCH_CONSUMER_RULE_SUCCESS; + } + } + return MESA_MATCH_CONSUMER_RULE_FAIL; +} +int MESA_shm_match_consumer_rule(int level, int pid, const char *module) { static __thread unsigned long long reload_age = 0; static __thread int last_pid_match_result = MESA_MATCH_CONSUMER_RULE_SUCCESS; @@ -399,12 +450,12 @@ int MESA_shm_match_consumer_rule(int level, int pid) return MESA_MATCH_CONSUMER_RULE_FAIL_LEVEL; } /* - only need to match pid once after the consumer restart, + only need to match pid once after consumer or producer restart, in order to improve matching speed for producer process */ if(MESA_consumer_status->reload_age != reload_age){ reload_age = MESA_consumer_status->reload_age; - if(MESA_shm_match_pid(MESA_consumer_status->care_pid, pid) == MESA_MATCH_CONSUMER_RULE_FAIL){ + if(MESA_shm_match_pid(MESA_consumer_status->pid, pid) == MESA_MATCH_CONSUMER_RULE_FAIL){ last_pid_match_result = MESA_MATCH_CONSUMER_RULE_FAIL; return MESA_MATCH_CONSUMER_RULE_FAIL_PID; } @@ -414,6 +465,10 @@ int MESA_shm_match_consumer_rule(int level, int pid) return MESA_MATCH_CONSUMER_RULE_FAIL_PID; } } + if(MESA_shm_match_module(module) == MESA_MATCH_CONSUMER_RULE_FAIL){ + return MESA_MATCH_CONSUMER_RULE_FAIL_MODULE; + } + return MESA_MATCH_CONSUMER_RULE_SUCCESS; } |