T536_DTU/app_public/fuxi_public/fuxi_bsp/source/watchdog.c

/******************************************************************************
版权所有：	
文件名称：	watchdog.c
文件版本：	01.00
创建作者:	   sunxi
创建日期：	2022-05-19
功能说明：	
			watchdog 的使用说明：
			1.本看门狗只侦察本进程中的各个线程的运行情况；
			2.如何使用，请参考watchdog_test();
			3. 在阻塞型的线程中，不能加入watchdog;
			4. 本狗为应用狗;

其它说明：	
修改记录：
*/

/*------------------------------- 头文件 --------------------------------------
*/

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <time.h>
#include <dirent.h>
#include <signal.h>
#include <sys/prctl.h>

#include "../include/bspconfig.h"
#include "rt.h"

#include "watchdog.h"
#include "shm_comm_packet.h"
#include "shm.h"


//#define WD_PATH	"/tmp/wdt_record"
#define WD_PATH	"/app/data/wdt_record" //noted by sunxi: 保存在flash中，重启后，不会掉失


#define WDT_MAX_ITEMS   64

#define wd_info_str ""

//心跳结构体
typedef struct HB_T
{
	uint16_t A;
	uint16_t B;
	uint16_t heartbeat_A; //每秒加1
	uint16_t heartbeat_B; //与heartbeat_A相同
	uint16_t crc;
}HB_T;

//裸核程序空间写完标志结构体
typedef struct SHM_E907_PRO_W_F_T
{
	uint16_t A;
	uint16_t B;
	uint16_t finish_flag; //裸核程序空间写完时，0x55写入finish_flag.
	uint32_t len;//裸核程序的实际长度
	uint16_t crc;
}SHM_E907_PRO_W_F_T;


typedef struct _wdt_item {
	const char *name;
	uint8_t     feed;
	uint32_t runing;//计时器
	uint32_t period;//秒
}wdt_item_t;

struct ap_watchdog_t
{
    int (*add_item)(const char *name, uint32_t *id, uint32_t period);
    int (*remove_item)(uint32_t id);
    int (*feed)(uint32_t id);
    int (*set_period)(uint32_t id, uint32_t seconds);
    uint32_t (*get_period)(uint32_t id);
    int (*start)(void);
    int (*stop)(void);
    int (*is_start)(void);
    int (*record)(const char *name);
    void (*set_debug)(int set);

	char appName[128];
    int _debug;
    wdt_item_t items[WDT_MAX_ITEMS];

    uint8_t runing_flag;

    pthread_mutex_t     mutex;
};

static pthread_t pthread_tid = 0;

int watchdog_feed_flag = 0;//放到心跳线程(与db进行心跳握手)，以确保watchdog_thread线程运行正常
struct ap_watchdog_t ap_watchdog;

extern uint32_t wdt_id_mainloop;

//检查文件夹是否存在
//不存在，创建
int CreateNewFolder(char* path)
{
	DIR *dir;

	if(path == NULL)
	{
		return -1;
	}

	//检查文件夹是否存在
	dir = opendir(path);
	if(NULL == dir)
 	{
 		//不存在，创建
 		mkdir(path,0775);
		
 	}
   	else
	{
		closedir(dir);
	}
	return 0;
}


int watchdog_init(void)
{
	int i;

	CreateNewFolder(WD_PATH);

    memset(ap_watchdog.items, 0, sizeof(ap_watchdog.items));

    for(i=0; i<WDT_MAX_ITEMS; i++)
        ap_watchdog.items[i].feed = 1;

    ap_watchdog.runing_flag = 0;
    ap_watchdog._debug = 0;

	strcpy(ap_watchdog.appName, "dtu_t536");

    pthread_mutex_init(&ap_watchdog.mutex, NULL);

	ap_watchdog.start();

	return 0;
}

int watchdog_exit(void)
{
	ap_watchdog.stop();

	pthread_join(pthread_tid, NULL);
	return 0;
}

//period:周期，单位为秒
static int add_item(const char *name, uint32_t *id, uint32_t period)
{
	int i;
	
    if(name ==  NULL)
        return -1;

    int ret = -1;

    // try to get mutex
    struct timespec tout;
    clock_gettime(CLOCK_REALTIME, &tout);
    tout.tv_sec += 5; //5s default

    if(pthread_mutex_timedlock(&ap_watchdog.mutex, &tout) != 0)
        return -1;

    for(i=0; i<WDT_MAX_ITEMS; i++) 
    {
        if(ap_watchdog.items[i].name == NULL) 
        {
            ap_watchdog.items[i].feed = 1;
			ap_watchdog.items[i].runing = 0;
			ap_watchdog.items[i].period = period;
            *id = i;
            ap_watchdog.items[i].name = name;
			rt_printf("WDT add_item i=%d,name= %s \r\n",i, ap_watchdog.items[i].name);
            ret = 0;
            break;
        }
    }

    pthread_mutex_unlock(&ap_watchdog.mutex);
	
    return ret;
}

static int remove_item(uint32_t id)
{
    if(id > WDT_MAX_ITEMS)
        return -1;

    // try to get mutex
    struct timespec tout;
    clock_gettime(CLOCK_REALTIME, &tout);
    tout.tv_sec += 5; //5s default

    if(pthread_mutex_timedlock(&ap_watchdog.mutex, &tout) != 0)
        return -1;

    ap_watchdog.items[id].name = NULL;
    ap_watchdog.items[id].feed = 1;
	ap_watchdog.items[id].runing = 0;

    pthread_mutex_unlock(&ap_watchdog.mutex);
    return 0;
}

static int feed(uint32_t id)
{
    if(id > WDT_MAX_ITEMS)
        return -1;

    ap_watchdog.items[id].feed = 1;
    return 0;
}

static int set_period(uint32_t id, uint32_t seconds) 
{
    if(id > WDT_MAX_ITEMS)
        return -1;

    ap_watchdog.items[id].period = seconds;
    return 0;

}

static uint32_t get_period(uint32_t id) 
{
    if(id > WDT_MAX_ITEMS)
        return -1;

    return ap_watchdog.items[id].period;
}

//设置心跳
static int write_freq_hb(uint8_t *data)
{
	int ret = 0;
	int cnt = 0;

	if(data == NULL)
		return -1;
		
    while(1)
    {
    	ret = shm_comm_packet_write(SHM_ADDR_D_HB, data, sizeof(HB_T));
		if(ret > 0)	
		{
			break;
		}

		if(++cnt > 3)
			break;

        usleep(30);
    }
    return ret;
}

static int get_e907_PRO_W_F(void)
{
    SHM_E907_PRO_W_F_T flag;
	int ret = 0;
	int cnt = 0;
		
    while(1)
    {
		ret = shm_comm_packet_read(SHM_ADDR_U_PRO_W_F, sizeof(flag), (uint8_t *)&flag, sizeof(flag));
		if(ret > 0)	
		{
			if(flag.finish_flag == 0x55)
			 	return flag.len;
			else
				return -1;
		}

		if(++cnt > 3)
			break;

        usleep(30);
    }
    return ret;
}


static void *watchdog_thread(void *arg)
{
	int i = 0;
	static HB_T hb;
	int ret = 0;
	static int read_flag = 0;
	struct file * pfile;
	loff_t pos;

	memset(&hb,0,sizeof(hb));

    pthread_detach(pthread_self());

	prctl(PR_SET_NAME, "watchdog_thread");
    while (ap_watchdog.is_start()) {

        watchdog_feed_flag = 1;
        sleep(1);

		//把裸核程序读出来，并写到tmp文件夹中。
		if(read_flag == 0)
		{
			ret = get_e907_PRO_W_F();
			if(ret > 100)//返回裸核程序的实际长度，所以一定会大于100才有意义
			{
				//finish
				read_flag = 1;
				//从shm中读取裸核程序
				// 创建数据文件
				pfile = rt_file_open("/tmp/amp_rv0.bin",O_CREAT|O_RDWR,0);
				if(!IS_ERR(pfile))
				{
					pos = 0;
					rt_file_write(pfile, SHM_BASE_R+SHM_ADDR_U_E907_PRO, ret, &pos);
					rt_file_close(pfile,0);

				}

			}
		}

		hb.heartbeat_A++;
		hb.heartbeat_B = hb.heartbeat_A;
		write_freq_hb((uint8_t *)&hb); //给裸核的心跳

		for(i=0; i<WDT_MAX_ITEMS; i++) 
		{
			if(ap_watchdog.items[i].name != NULL) 
			{
				if(++ap_watchdog.items[i].runing > ap_watchdog.items[i].period)
				{
					if(ap_watchdog.items[i].feed != 1) 
					{
						ap_watchdog.record(ap_watchdog.items[i].name);

						rt_printf("WDT-------%s is timeout!!!\r\n",ap_watchdog.items[i].name);
						system("reboot -f");
                		//exit(EXIT_FAILURE);//TODO. noted by sunxi: 这里需要确认是，是重启应用程序，还是系统reboot!!!
					}
					else
					{
						if(ap_watchdog._debug) 
			            {
			                rt_printf("WDT-------%s is Runing.\r\n",ap_watchdog.items[i].name);
			            }
					}

					
					ap_watchdog.items[i].feed = 0;	
					ap_watchdog.items[i].runing = 0;

				}
			

			}
		}

    }
    return NULL;
}

static int start(void)
{
    int ret;

    if(ap_watchdog.runing_flag == 1)
    {
        return 0;
    }

	ap_watchdog._debug = 0;
    ap_watchdog.runing_flag = 1;

    ret = pthread_create(&pthread_tid, NULL, watchdog_thread, NULL);
    if(ret != 0) {
        rt_printf("can not create thread any more: %d\r\n",errno);
        ap_watchdog.runing_flag = 0;
        return -1;
    }
    return 0;
}

static int stop(void)
{
    ap_watchdog.runing_flag = 0;
    return 0;
}

static int is_start(void) 
{
    return ap_watchdog.runing_flag;
}

static int record(const char *name)
{
    time_t   tt;
	char buf[512];
	FILE * f = NULL;
	char  rec[256];
	char tmpBuf[128];
	int size;

    if(name == NULL)
        return -1;

    tt = time(NULL);

	memset(buf,0,sizeof(buf));
	sprintf(buf, "%s/wdt_record_%s", WD_PATH,ap_watchdog.appName);

    f = fopen(buf, "a");
	if(f == NULL) {
		perror("fopen");
        rt_printf("fopen is error!!!\r\n");
        return -1;
    }

	memset(tmpBuf, 0, sizeof(tmpBuf));
	strftime(tmpBuf, 128, "%Y-%m-%d %H:%M:%S", localtime(&tt));
	memset(rec, 0, sizeof(rec));
    size = snprintf(rec, sizeof(rec), "%s %s fuck you up; \r\n", tmpBuf, name);

    fwrite(rec, size, 1,  f);
    fclose(f);

    return 0;
}

static void set_debug(int set) 
{
    ap_watchdog._debug = set;
}

struct ap_watchdog_t ap_watchdog = 
{
    .add_item = add_item,
    .remove_item = remove_item,
    .feed = feed,
    .set_period = set_period,
    .get_period = get_period,
    .start = start,
    .stop = stop,
    .is_start = is_start,
    .record = record,
    .set_debug = set_debug,
};


/*
period: 看门狗的喂狗周期
因为可能存在某些线程，其运行过程很长，运行的中间，没有合里加sleep等休息函数，
造成占用时间较长。
于是，这里的period，可以尽量设置长一点的时间。

*/
int watchdog_add_item(const char *name, uint32_t *id, uint32_t period)
{

	int ret = 0;

	ret = ap_watchdog.add_item(name, id,period);

	return ret;

}

int watchdog_feed(uint32_t id)
{
	int ret = 0;

    ret = ap_watchdog.feed(id);

	
    return ret;
}

int watchdog_remove_item(uint32_t id)
{
	int ret = 0;

    ret = ap_watchdog.remove_item(id);

	
    return ret;
}


//===================================================================================================================
//test


void *watchdog_test_pthread(void *arg)
{

    pthread_detach(pthread_self());


    uint32_t wdt_id;
    int rc = watchdog_add_item("watchdog_test_pthread", &wdt_id,10);
    if(rc != 0) {
        printf("can not add watchdog_test_pthread task to wdt\r\n");
        return NULL;
    }


    while(1)
    {
    	//把喂狗操作放在首行，确保每个循环都有喂狗
    	watchdog_feed(wdt_id);// 去掉本行喂狗，就可以产生记录
    
        sleep(1);
	
    }

    watchdog_remove_item(wdt_id);

	return NULL;

}

int watchdog_test(void)
{
	int ret;
	watchdog_init();

	pthread_t ConnectCheck_id;
    ret = pthread_create(&ConnectCheck_id, NULL, watchdog_test_pthread, NULL);
    if(ret != 0) {
        printf("can not create watchdog_test_pthread\r\n");
        return -1;
    }
	return 0;
}













void watchdog_feed_mainloop(void)
{
	watchdog_feed(wdt_id_mainloop);

}
void watchdog_feed_protect(void)
{

}
void watchdog_reset_cpu(int i)
{
	printf("reboot code: %d .\n", i);
	system("reboot -f");
}
void watchdog_feed_mainloop_50s(void)
{
	watchdog_feed(wdt_id_mainloop);
}

/*------------------------------- 文件结束 -------------------------------*/