common_src/lib/liblynq-sdk-ready/lynq_sdk_ready.cpp

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <binder/Parcel.h>
#include <log/log.h>
#include <cutils/jstring.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <include/lynq_uci.h>
#include <lynq_misc/lynq_misc.h>
#include <stdlib.h>
#include <fcntl.h>
#include <assert.h>
#include "lynq_sdk_ready.h"

#define LOG_TAG "LYNQ_SDK_READY"
#define DEST_PORT 8088
#define LYNQ_BRODCAST_PORT 8086

#define SDK_READY_PORT 8157
#define DSET_IP_ADDRESS  "127.0.0.1"
#define RIL_REQUEST_DEVICE_IDENTITY 98
#define MAX_LEN 1024
#define TIMER 30
#define LOG_UCI_FILE "lynq_uci"
#define LOG_UCI_MODULE "debug_mode"
#define update_ril_digit 0x7 //The last three digits are reserved for RIL service,0x111
#define update_userdata_digit 1<<3
#define update_gnss_digit 1<<4

#define DEFAULT_PERIOD_RIL 30
#define DEFAULT_PERIOD_GNSS 300
#define DEFAULT_PERIOD_MD 60
#define DEFAULT_PERIOD_PTN 120
#define DEFAULT_PERIOD_SYS 120
#define DEFAULT_PERIOD_BOOT 60

#define MIN_PERIOD_RIL 10
#define MIN_PERIOD_GNSS 60
#define MIN_PERIOD_MD 30
#define MIN_PERIOD_PTN 120
#define MIN_PERIOD_SYS 120
#define RIL_UNSOL_TELEPHONY_RESTART 3113

#define GET_CPU_NUM "cat /proc/cpuinfo | grep processor | wc -l"
#define GET_LOAD_AVG_INFO "/proc/loadavg"
#define GET_INTR_INFO "/proc/stat"
#define GET_MEM_INFO "/proc/meminfo"
#define GET_MIN_FREE "/proc/sys/vm/min_free_kbytes"

#define BIT_EXCPT_RIL 1
#define BIT_EXCPT_MD 1 << 1
#define BIT_EXCPT_GNSS 1 << 2
#define BIT_EXCPT_PTN 1 << 3
#define BIT_EXCPT_SYS 1 << 4

using ::android::Parcel;

static pthread_mutex_t g_lynq_sim_sendto_mutex;
static pthread_mutex_t lock;
static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;

// 全局变量
static lynq_sdk_check_param_t *global_param = NULL;
static lynq_sdk_status_cb global_sdk_status_cb = NULL;
static lynq_sdk_ready_t global_sdk_status;
static int utoken = 0;
static int global_sdk_ready_status = 1;
static int s_ril_started = 0;
static int s_sys_started = 0;
static int s_ptn_started = 0;
static int s_gnss_started = 0;
static int boot_ril_check_timer[8] = {2,2,4,4,8,8,16,16};
enum in_ril_excpt {
    RIL_REQUEST_SUCCESS=0,
    RIL_MODEM_BOOT_EXCPT=1,
    RIL_RESP_ERROR_FAIL=2,
    RIL_SOCKET_CREATE_FAIL=3,
    RIL_SOCKET_SEND_REC_FAIL=4,
};

typedef struct{
    int uToken;
    int request;
    int paramLen;
    char param[MAX_LEN];
}lynq_client_t;


void unlock_with_s_start(int *s_start)
{
    pthread_mutex_lock(&s_startupMutex);
    *s_start = 1;
    pthread_cond_broadcast(&s_startupCond);
    pthread_mutex_unlock(&s_startupMutex);
}
long get_uptime()
{
    struct timespec start_time;
    clock_gettime(CLOCK_MONOTONIC, &start_time);
    return start_time.tv_sec;
}
const char * sdk_status_excpt_to_string(lynq_sdk_status_t excpt)
{
    switch(excpt)
    {
        case LYNQ_SDK_READY: return "LYNQ_SDK_READY";
        case LYNQ_SDK_MD_EXCPT: return "LYNQ_SDK_MD_EXCPT";
        case LYNQ_SDK_MD_REBOOT_EXCPT: return "LYNQ_SDK_MD_REBOOT_EXCPT";
        case LYNQ_SDK_RIL_EXCPT: return "LYNQ_SDK_RIL_EXCPT";
        case LYNQ_SDK_PARTITION_EXCPT: return "LYNQ_SDK_PARTITION_EXCPT";
        case LYNQ_SDK_MIN_FREE_EXCPT: return "LYNQ_SDK_MIN_FREE_EXCPT";
        case LYNQ_SDK_INTR_EXCPT: return "LYNQ_ACTION_INTR_EXCPT";
        case LYNQ_SDK_LOAD_AVG_EXCPT: return "LYNQ_SDK_LOAD_AVG_EXCPT";
        case LYNQ_SDK_NET_CHANNEL_EXCPT: return "LYNQ_SDK_NET_CHANNEL_EXCPT";
        case LYNQ_SDK_GNSS_EXCPT: return "LYNQ_SDK_GNSS_EXCPT";
        default: return "<unknown excpt>";
    }
}
const char * sdk_status_action_to_string(lynq_sdk_ref_action_t action)
{
    switch(action)
    {
        case LYNQ_ACTION_NOTHING: return "LYNQ_ACTION_NOTHING";
        case LYNQ_ACTION_REBOOT: return "LYNQ_ACTION_REBOOT";
        case LYNQ_ACTION_RESET_MD: return "LYNQ_ACTION_RESET_MD";
        case LYNQ_ACTION_RETRY_DATA_CALL: return "LYNQ_ACTION_RETRY_DATA_CALL";
        case LYNQ_ACTION_PTN_CLEAN: return "LYNQ_ACTION_PTN_CLEAN";
        case LYNQ_ACTION_SYS_WARNING: return "LYNQ_ACTION_SYS_WARNING";
        default: return "<unknown action>";
    }
}
void reset_sdk_ready_status()
{
    global_sdk_status.sdk_ready_status = LYNQ_SDK_READY;
    global_sdk_status.ref_action = LYNQ_ACTION_NOTHING;
}
void trigger_sdk_ready_cb(lynq_sdk_status_t excpt, lynq_sdk_ref_action_t action)
{
    pthread_mutex_lock(&lock);
    RLOGI("trigger sdk ready cb excpt:%s,action:%s",sdk_status_excpt_to_string(excpt),sdk_status_action_to_string(action));
    long uptime = get_uptime();
    if((excpt != LYNQ_SDK_READY) && (uptime < global_param->period.BOOT))
    {
        goto end;
    }
    //if((global_sdk_status.sdk_ready_status == excpt) && (global_sdk_status.ref_action == action))
    //{
    //    goto end;
    //}
    global_sdk_status.sdk_ready_status = excpt;
    global_sdk_status.ref_action = action;
    global_sdk_status_cb(&global_sdk_status,NULL);
end:
    pthread_mutex_unlock(&lock);
    return;
}
//maybe uci,or other
void set_sdk_ready_nv(int value)
{
    char cmd[64] = {0};
    RLOGI("set_sdk_ready_nv:%d",value);
    sprintf(cmd,"uci set lynq_uci.sdk_ready=%d",value);//set uci
    system(cmd);
    return;
}
void set_sdk_ready_status_bit(int bit,int status)
{
    pthread_mutex_lock(&lock);
    int old = 1;
    if((global_sdk_ready_status & bit) == 0)
    {
        old = 0;
    }
    if(old == status)
    {
        goto end;
    }
    if(status == 1)
    {
        global_sdk_ready_status |= bit;
    }
    else
    {
        global_sdk_ready_status &= ~bit;
    }
    set_sdk_ready_nv(global_sdk_ready_status);
end:
    pthread_mutex_unlock(&lock);
    return;
}
static int get_md_sta(void)
{
    FILE *fp;
    char buffer[64]={};
    fp = popen("cat /sys/kernel/ccci/boot","r");
    if(fp == NULL)
    {
        RLOGD("function %s fp is null\n", __FUNCTION__);
        return 0;
    }
    fgets(buffer,sizeof(buffer),fp);
    if(!strlen(buffer))
    {
        RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
        pclose(fp);
        return 0;
    }
    if(buffer[4] == '4')
    {
        pclose(fp);
        return 1;
    }
    RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
    pclose(fp);
    return 0;
}

static int check_service(const char *service)
{
    FILE *fp = NULL;
    char buffer[1024]={};
    if(!strcmp(service, "/usr/sbin/mtkfusionrild"))
    {
        fp = popen("ps -ef|grep rild","r");
    }
    else if(!strcmp(service, "lynq-ril-service"))
    {
        fp = popen("ps -ef|grep ril-service","r");
    }
    if(fp == NULL)
    {
        RLOGD("function %s fp is null\n", __FUNCTION__);
        return 0;
    }
    while(NULL != fgets(buffer,sizeof(buffer),fp))
    {
        if(strstr(buffer,service))
        {
            pclose(fp);
            RLOGD("check_service 1\n");
            return 1;
        }
    }
    RLOGD("check_service 0\n");
    pclose(fp);
    return 0;
}

/**
 * @brief find partition zhengshu for exzample 5.7M,get value 5
 * 
 * @param arg 
 * @return  
 */
static void removeSpaces(char* str) 
{
    char* dest = str;  
    while (*str) {
        if (*str != ' ') {
            *dest++ = *str;  
        }
        str++;  
    }
    *dest = '\0';
	return ;
}
void check_ril_sleep(int count)
{
    if((count < sizeof(boot_ril_check_timer)/sizeof(int)) && ((global_sdk_ready_status & 1) == 1))// total 60s
    {
        sleep(boot_ril_check_timer[count]);
    }
    else
    {
        sleep(global_param->period.RIL);
    }
    return;
}
void update_ril_value(int value)
{
    switch (value)
    {
        case RIL_REQUEST_SUCCESS:
        {
            trigger_sdk_ready_cb(LYNQ_SDK_READY, LYNQ_ACTION_NOTHING);
            set_sdk_ready_status_bit(BIT_EXCPT_RIL,0);
            set_sdk_ready_status_bit(BIT_EXCPT_MD, 0);
            break;
        }
        case RIL_MODEM_BOOT_EXCPT:
        {
            set_sdk_ready_status_bit(BIT_EXCPT_RIL,1);
            trigger_sdk_ready_cb(LYNQ_SDK_MD_EXCPT,LYNQ_ACTION_REBOOT);
            break;
        }
        case RIL_RESP_ERROR_FAIL:
        {
            set_sdk_ready_status_bit(BIT_EXCPT_RIL,1);
            trigger_sdk_ready_cb(LYNQ_SDK_RIL_EXCPT,LYNQ_ACTION_NOTHING);
            break;
        }
        case RIL_SOCKET_CREATE_FAIL:
        case RIL_SOCKET_SEND_REC_FAIL:
        {
            set_sdk_ready_status_bit(BIT_EXCPT_RIL,1);
            trigger_sdk_ready_cb(LYNQ_SDK_RIL_EXCPT,LYNQ_ACTION_REBOOT);
            break;
        }
        default:
            RLOGE("Not this case:%d",value);
    }
    return;
}

void update_userdata_value()
{
    pthread_mutex_lock(&lock);
    trigger_sdk_ready_cb(LYNQ_SDK_PARTITION_EXCPT, LYNQ_ACTION_REBOOT);
    set_sdk_ready_status_bit(BIT_EXCPT_PTN,1);
    pthread_mutex_unlock(&lock);
    return;
}

void update_gnss_value()
{
    pthread_mutex_lock(&lock);
    trigger_sdk_ready_cb(LYNQ_SDK_GNSS_EXCPT, LYNQ_ACTION_REBOOT);
    set_sdk_ready_status_bit(BIT_EXCPT_GNSS,1);
    pthread_mutex_unlock(&lock);
    return;
}
/**
 * @brief send request imei
 * 
 * @param arg 
 * 线程run起来后前两个60s 不做异常上报，这段时间是模组就绪时间因此只报ready 状态，60s 以后如果还是检测到异常，说明是真异常
 * @return void* 
 */
void * timer_request_imei(void * arg)
{
    unlock_with_s_start(&s_ril_started);
    int send_num = -1;
    int recv_num = -1;
    int resp_type = -1;
    int request = -1;
    int slot_id = -1;
    int token = -1;
    int res_error = -1;
    int count = 0;
    Parcel p;
    struct sockaddr_in addr_serv;
    struct sockaddr_in liblynq_sdk_ready_socket;
    memset(&liblynq_sdk_ready_socket, 0,sizeof(liblynq_sdk_ready_socket));
    memset(&addr_serv, 0, sizeof(addr_serv));
    addr_serv.sin_family = AF_INET;
    addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
    addr_serv.sin_port = htons(DEST_PORT);
    liblynq_sdk_ready_socket.sin_family = AF_INET;
    liblynq_sdk_ready_socket.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
    int len_addr_serv = sizeof(addr_serv);

    lynq_client_t client_t;
    char res_data[MAX_LEN] = {0};
    client_t.request = RIL_REQUEST_DEVICE_IDENTITY;
    client_t.paramLen = 0;
    client_t.uToken = utoken;
    memset(client_t.param, 0, sizeof(client_t.param));

    struct timeval timeOut;
    timeOut.tv_sec = 3;//timeout time 3s
    timeOut.tv_usec = 0;

    int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sock_fd)
    {
        RLOGD("__FUNCTION__ %s create  sock_fd failed %s\n", __FUNCTION__, strerror(errno));
        exit(EXIT_FAILURE);
        return NULL;
    }
    int ret = bind(sock_fd, (struct sockaddr *)&liblynq_sdk_ready_socket, sizeof(liblynq_sdk_ready_socket));
    if (-1 == ret)
    {
        RLOGE("liblynq_data_socket bind fail,errno:%d",errno);
        return NULL;
    }

    if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0) 
    {
        RLOGD("__FUNCTION__ %s time out setting failed %s\n", __FUNCTION__, strerror(errno));
        exit(EXIT_FAILURE);
        return NULL;
    }
    while (1)
    {
        bzero(res_data, MAX_LEN);
        pthread_mutex_lock(&g_lynq_sim_sendto_mutex);
        send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
        RLOGD("send_num %d\n", send_num);
        if(send_num == 0)  
        {
            RLOGD("__FUNCTION__ %s Close to end %s\n", __FUNCTION__, strerror(errno));
            //unknow
            update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
            pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
            continue;
        }
        if(send_num < 0)  
        {  
            RLOGD("__FUNCTION__ %s sendto error %s\n", __FUNCTION__, strerror(errno));
            //unknow
            update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
            pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
            continue;
        }
        //get data msg
        recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
        RLOGD("recv_num %d\n", recv_num);
        if(recv_num == -1 && errno == EAGAIN)
        {
            RLOGD("__FUNCTION__ %srecvfrom fail because timeout\n", __FUNCTION__);
            /*set uci*/
            if(!get_md_sta())
            {
                update_ril_value(RIL_MODEM_BOOT_EXCPT);
            }
            else
            {
                if(check_service("/usr/sbin/mtkfusionrild"))//rild work
                {
                    if(!check_service("lynq-ril-service"))//not find,must be socket error
                    {
                        update_ril_value(RIL_SOCKET_CREATE_FAIL);
                    }
                    else
                    {
                        //unknow error
                        update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
                    }
                }
                else//rild no work
                {
                    //unknow
                    update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
                }
            }
            pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
            check_ril_sleep(count);
            count++;
            continue;
        }
        if(recv_num <= 0)
        {
            RLOGD("__FUNCTION__ %s recvfrom fail %s\n", __FUNCTION__, strerror(errno));
            update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
            pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
            check_ril_sleep(count);
            count++;
            continue;
        }
        p.setData((uint8_t *)res_data,sizeof(char)*recv_num);
        p.setDataPosition(0);
        if(p.dataAvail() > 0)
        {
            p.readInt32(&resp_type);
            p.readInt32(&token);
            p.readInt32(&request);
            p.readInt32(&slot_id);
            p.readInt32(&res_error);
        }
        /*judge the res_error*/
        if(!res_error)
        {
            update_ril_value(RIL_REQUEST_SUCCESS);
        }
        else
        {
            update_ril_value(RIL_RESP_ERROR_FAIL);
        }
        count = 0;
        RLOGD("__FUNCTION__ %s res_error %d\n", __FUNCTION__, res_error);
        /*judge the res_error*/
        pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
        check_ril_sleep(sizeof(boot_ril_check_timer)/sizeof(int));
    }
    return NULL;
}

void * wait_ril_event(void * arg)
{
    unlock_with_s_start(&s_ril_started);
    int REC_BUFF_LEN = 64;
    int recv_num = 0;
    char rec_data[REC_BUFF_LEN] = {0};
    int count = 0;
    struct sockaddr_in wait_ril_event_socket;
    struct sockaddr_in addr_client;
    memset(&wait_ril_event_socket, 0,sizeof(wait_ril_event_socket));
    memset(&addr_client, 0, sizeof(addr_client));
    wait_ril_event_socket.sin_family = AF_INET;
    wait_ril_event_socket.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
    wait_ril_event_socket.sin_port = htons(SDK_READY_PORT);
    int len_addr_serv = sizeof(addr_client);

    int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sock_fd)
    {
        RLOGD("__FUNCTION__ %s create  sock_fd failed %s\n", __FUNCTION__, strerror(errno));
        exit(EXIT_FAILURE);
        return NULL;
    }
    int ret = bind(sock_fd, (struct sockaddr *)&wait_ril_event_socket, sizeof(wait_ril_event_socket));
    if (-1 == ret)
    {
        RLOGE("liblynq_data_socket bind fail,errno:%d",errno);
        exit(EXIT_FAILURE);
        return NULL;
    }
    while(1)
    {
        memset(rec_data,0,REC_BUFF_LEN);
        recv_num = recvfrom(sock_fd,rec_data,sizeof(char)*REC_BUFF_LEN,0,(struct sockaddr *)&addr_client,(socklen_t*)&len_addr_serv);
        if(recv_num <= 0)
        {
            RLOGD("__FUNCTION__ %s Close to end\n", __FUNCTION__);
            update_ril_value(RIL_SOCKET_SEND_REC_FAIL);
            continue;
        }
        rec_data[recv_num] = '\0';
        if((atoi(rec_data) == RIL_UNSOL_TELEPHONY_RESTART) && (count%2 == 0))//this urc will be reported twice in a row
        {
            set_sdk_ready_status_bit(BIT_EXCPT_MD, 1);
            trigger_sdk_ready_cb(LYNQ_SDK_MD_REBOOT_EXCPT,LYNQ_ACTION_RETRY_DATA_CALL);
            count = 0;
        }
        count ++;
    }
    close(sock_fd);
}


void delete_enter(char data[])
{
    char *find = strchr(data, '\n');
    if(find)
        *find = '\0';
    return ;
}

unsigned long long get_interrupts(int fd,char *buffer,int size)
{
    char *line = NULL;
    unsigned long long intr_value = 0;
    memset(buffer,0,size);
    lseek(fd, 0, SEEK_SET);
    ssize_t bytes_intr_read = read(fd,buffer, size - 1);
    buffer[bytes_intr_read] = '\0';
    line = strstr(buffer, "intr");
    if (line == NULL)
    {
        RLOGE("get intr fail");
    }
    else
    {
        line += 5;
        sscanf(line,"%llu",&intr_value);
    }
    return intr_value;
}
unsigned long long get_mem_free(int fd,char *buffer,int size)
{
    char *line = NULL;
    unsigned long long mem_value = 0;
    lseek(fd, 0, SEEK_SET);
    memset(buffer,0,size);
    ssize_t bytes_mem_read = read(fd, buffer, size - 1);
    buffer[bytes_mem_read] = '\0';
    line = strstr(buffer, "MemFree:");
    if (line == NULL)
    {
        RLOGE("get MemFree fail");
    }
    else
    {
        line += 9;
        while (*line == ' ')
        {
            line++;
        }
        sscanf(line,"%llu",&mem_value);
    }
    return mem_value;
}

void *check_system(void * arg)
{
    int fd_mem = 0;
    int fd_intr = 0;
    int fd_avg = 0;
    int fd_free = 0;
    int BUFFER_SIZE = 512;
    unsigned long long min_free = 0;
    unsigned long long mem_value = 0;
    unsigned long long intr_value_old = 0;
    unsigned long long intr_value_new = 0;
    float avg_value = 0;
    int excpt_flag = 0;
    char sys_buffer[BUFFER_SIZE];
    char min_free_buffer[BUFFER_SIZE];
    unlock_with_s_start(&s_sys_started);
    fd_mem = open(GET_MEM_INFO,O_RDONLY);
    fd_free = open(GET_MIN_FREE,O_RDONLY);
    fd_intr = open(GET_INTR_INFO,O_RDONLY);
    fd_avg = open(GET_LOAD_AVG_INFO,O_RDONLY);
    if((fd_mem < 0) || (fd_intr < 0) || (fd_avg < 0) || (fd_free < 0))
    {
        RLOGE("check system open fail");
        exit(EXIT_FAILURE);
    }
    memset(min_free_buffer,0,BUFFER_SIZE);
    ssize_t bytes_min_free_read = read(fd_free, min_free_buffer, BUFFER_SIZE - 1);
    if(bytes_min_free_read == -1)
    {
        RLOGE("get min free fail");
        exit(EXIT_FAILURE);
    }
    min_free = atoi(min_free_buffer);
    close(fd_free);
    ssize_t bytes_avg_read = 0;
    intr_value_old  = get_interrupts(fd_intr, sys_buffer, BUFFER_SIZE);
    while(1)
    {
        memset(sys_buffer,0,BUFFER_SIZE);
        lseek(fd_avg, 0, SEEK_SET);
        bytes_avg_read = read(fd_avg, sys_buffer, BUFFER_SIZE - 1);
        sys_buffer[bytes_avg_read] = '\0';
        sscanf(sys_buffer,"%*f %f",&avg_value);

        mem_value = get_mem_free(fd_mem, sys_buffer, BUFFER_SIZE);
        intr_value_new  = get_interrupts(fd_intr, sys_buffer, BUFFER_SIZE);
        //pages_min = /proc/sys/vm/min_free_kbytes
        //pages_low = pages_min*5/4
        //pages_high = pages_min*3/2
        if((mem_value >= min_free) && (mem_value < min_free*1.25))//pages_min-pages_low
        {
            trigger_sdk_ready_cb(LYNQ_SDK_MIN_FREE_EXCPT,LYNQ_ACTION_SYS_WARNING);
            excpt_flag = 1;
        }
        if(mem_value < min_free)
        {
            trigger_sdk_ready_cb(LYNQ_SDK_MIN_FREE_EXCPT,LYNQ_ACTION_REBOOT);
            excpt_flag = 1;
        }
        if(avg_value > global_param->threshold.load_average)
        {
            trigger_sdk_ready_cb(LYNQ_SDK_LOAD_AVG_EXCPT,LYNQ_ACTION_SYS_WARNING);
            excpt_flag = 1;
        }
        if((intr_value_new - intr_value_old) > global_param->threshold.interrupts)
        {
            trigger_sdk_ready_cb(LYNQ_SDK_INTR_EXCPT,LYNQ_ACTION_SYS_WARNING);
            excpt_flag = 1;
        }
        set_sdk_ready_status_bit(BIT_EXCPT_SYS,excpt_flag);
        RLOGI("memfree:%llu,intr_old:%llu,intr_new:%llu,intr_delat:%llu,avg:%.2f\n",mem_value,intr_value_old,intr_value_new,(intr_value_new - intr_value_old),avg_value);
        intr_value_old = intr_value_new;
        excpt_flag = 0;
        sleep(global_param->period.SYS);
    }
    close(fd_mem);
    close(fd_intr);
    close(fd_avg);
}

/* old code 2024/11/04 close
void *check(void * arg)
{

    char pid[200][8];
    char ffd[200][4];
    char buf[64];
    char check_time[4];
    char timebuf[32];
    int num = 1;
    int i=0;
    int j;
    FILE *fp,*fp_1;
    int ret;

    RLOGD("check cpu/pid/interrupts/fd!!!\n");
    system("mkdir /media/check_file");
    system("touch /media/check_time");
    fp_1 = popen("cat /media/check_time","r");
    if(fgets(check_time, 4, fp_1) != NULL)
    {
        num = atoi(check_time);
    }
    pclose(fp_1);
    while(1)
    {
        i = 0;
        system("date >>/media/check_file/cpu_moniter.txt");
        ret = system("top -b |head -n 25 >>/media/check_file/cpu_moniter.txt");
        RLOGD("cpu ret %d", ret);
        system("date >>/media/check_file/inter_moniter.txt");
        ret = system("cat /proc/interrupts |grep -v \":          0          0\" >>/media/check_file/inter_moniter.txt");
        RLOGD("interrupts ret %d", ret);

        system("date >>/media/check_file/pid_moniter.txt");
        ret = system("ps -eo \"%p %a\" | grep -v \"\\[\" >>/media/check_file/pid_moniter.txt");
        RLOGD("pid ret %d", ret);

        system("date >>/media/check_file/meminfo_moniter.txt");
        ret = system("cat /proc/meminfo >>/media/check_file/meminfo_moniter.txt");
        RLOGD("meminfo ret %d", ret);

        system("date >>/media/check_file/buddyinfo_moniter.txt");
        ret = system("cat /proc/buddyinfo >>/media/check_file/buddyinfo_moniter.txt");
        RLOGD("buddyinfo ret %d", ret);

        system("date >>/media/check_file/ps_auxw_moniter.txt");
        ret = system("ps -auxw|grep -v \"0.0  0.0\"|grep -v \"0.1  0.0\"|grep -v \"0.0  0.1\" >>/media/check_file/ps_auxw_moniter.txt");
        RLOGD("ps_auxw ret %d", ret);

        system("date >>/media/check_file/cur_freq_moniter.txt");
        ret = system("cat /sys/devices/system/cpu/cpufreq/policy0/scaling_cur_freq >>/media/check_file/cur_freq_moniter.txt");
        RLOGD("cur_freq ret %d", ret);

        system("date >>/media/check_file/available_frequencies_moniter.txt");
        ret = system("cat /sys/devices/system/cpu/cpufreq/policy0/scaling_available_frequencies >>/media/check_file/available_frequencies_moniter.txt");
        RLOGD("available_frequencies ret %d", ret);

        system("date >>/media/check_file/fd_moniter.txt");
        fp = popen("ps -eo \"%p %a\" | grep -v \"\\[\"|awk '{print $1}'","r");
        while(fgets(pid[i], 8, fp) != NULL)
        {
             delete_enter(pid[i]);
             i++;
        }
        pclose(fp);

        for(j=1;j<i;j++)
        {
            sprintf(buf, "ls /proc/%s/fd | wc -l", pid[j]);
            fp = popen(buf, "r");
            fgets(ffd[j], 4, fp);
            sprintf(buf,"echo \"pid: %s, fd_num: %s\" >>/media/check_file/fd_moniter.txt",pid[j], ffd[j]);
            system(buf);
            pclose(fp);
        }

        if(num > 228)
        {
            system("cp /media/check_file/cpu_moniter.txt /media/check_file/cpu_moniter_1.txt");
            system("cp /media/check_file/inter_moniter.txt /media/check_file/inter_moniter_1.txt");
            system("cp /media/check_file/pid_moniter.txt /media/check_file/pid_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/fd_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/meminfo_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/buddyinfo_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/ps_auxw_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/cur_freq_moniter_1.txt");
            system("cp /media/check_file/fd_moniter.txt /media/check_file/available_frequencies_moniter_1.txt");


            system("rm -rf /media/check_file/cpu_moniter.txt");
            system("rm -rf /media/check_file/inter_moniter.txt");
            system("rm -rf /media/check_file/pid_moniter.txt");
            system("rm -rf /media/check_file/fd_moniter.txt");
            system("rm -rf /media/check_file/meminfo_moniter.txt");
            system("rm -rf /media/check_file/buddyinfo_moniter.txt");
            system("rm -rf /media/check_file/ps_auxw_moniter.txt");
            system("rm -rf /media/check_file/cur_freq_moniter.txt");
            system("rm -rf /media/check_file/available_frequencies_moniter.txt");

            num = 0;
        }
        num++;
        sprintf(timebuf, "echo \"%d\" >/media/check_time", num);
        ret = system(timebuf);
        sleep(300);
    }
    return NULL;

}

int num = 0;
void *check_uci(void * arg)
{
    int ret[6];
    int result = 0;
    int flag = 0;

    char uci_0[]="/etc/config/lynq_uci";
    char uci_1[]="/etc/config/lynq_uci_ro";
    char uci_2[]="/etc/config/mdlog";
    char uci_3[]="/etc/config/radio_property";
    char uci_4[]="/etc/config/service";
    char uci_5[]="/etc/config/usb";
    RLOGD("start check uci\n");
    while(num++ < 4)
    {
        RLOGD("@@@@@@@num=%d\n", num);
        flag = 0;
        ret[0] = system("uci show | grep \"lynq_uci.lynq_ril\" > /dev/null");
        if(ret[0] != 0)
        {
            RLOGD("lynq_uci unload\n");
            flag = 1;
        }

        ret[1] = system("uci show | grep \"^lynq_uci_ro\.\" > /dev/null");
        if(ret[1] != 0)
        {
            RLOGD("lynq_uci_ro unload\n");
            flag = 1;
        }

        ret[2] = system("uci show | grep \"^mdlog\.\"");
        if(ret[2] != 0)
        {
            RLOGD("mdlog unload\n");
            flag = 1;
        }

        ret[3] = system("uci show | grep \"^radio_property\.\" > /dev/null");
        if(ret[3] != 0)
        {
            RLOGD("radio_property unload\n");
            flag = 1;
        }

        ret[4] = system("uci show | grep \"^service\.\" > /dev/null");
        if(ret[4] != 0)
        {
            RLOGD("service unload\n");
            flag = 1;
        }

        ret[5] = system("uci show | grep \"^usb\.\" > /dev/null");
        if(ret[5] != 0)
        {
            RLOGD("usb unload\n");
            flag = 1;
        }

        RLOGD("flag=%d\n",flag);
        if(flag != 0)
        {
            RLOGD("config reload\n");
            result = chdir("/data_backup/");
            result =system("tar -zxvf userdata.tar.gz -C /STATE/ >/dev/null");
            if(result!= 0)
            {
                RLOGD("cp config fail\n");
            }
            if(ret[0] != 0)
            {
                lynq_load_config(uci_0);
                RLOGD("reload lynq_uci\n");
                system("systemctl start autosuspend");
            }
            if(ret[1] != 0)
            {
                lynq_load_config(uci_1);
                RLOGD("reload lynq_uci_ro\n");
            }
            if(ret[2] != 0)
            {
                lynq_load_config(uci_2);
                RLOGD("reload mdlog\n");
            }
            if(ret[3] != 0)
            {
                lynq_load_config(uci_3);
                RLOGD("reload radio_property\n");
                system("systemctl restart mtkfusionrild");
            }
            if(ret[4] != 0)
            {
                lynq_load_config(uci_4);
                RLOGD("reload service\n");
            }
            if(ret[5] != 0)
            {
                lynq_load_config(uci_5);
                RLOGD("reload usb\n");
            }
        }
        else
        {
            RLOGD("uci check success, exit check!\n");
            break;
        }
        sleep(2);
    }
    return NULL;
}
old code 2024/11/04 close*/

static void t800_check_partition()
{
    char buf[64] = {0};
    FILE *fp = NULL;
    int q = 22*1024;
    int ubisize = 0;

    fp = popen("df -l| grep '/data$' | awk '{print $3}'","r");
    if(fp == NULL)
    {
        RLOGD("Failed to run command\n");
        return;
    }
    fgets(buf, sizeof(buf) - 1, fp);
    RLOGD("buf is: %s\n",buf);
    ubisize = atoi(buf);
    if(ubisize >= q)
    {
        RLOGD(">set ready 5,userdata size is %d M\n",ubisize);
        update_userdata_value();
    }
    else
    {
        set_sdk_ready_status_bit(BIT_EXCPT_PTN, 0);
    }
    pclose(fp);
    return;
}
void t800_check_mnld()
{
    FILE *fp = NULL;
    const char *symble = "NRestarts=";
    const char *cmd = "systemctl show -p NRestarts mnld.service";
    char buf[64];
    int count_old = 0;
    int count_new = 0;
    while(1)
    {
        fp = popen(cmd,"r");
        if(NULL == fp)
        {
            RLOGE("run cmd:%s fail",cmd);
            sleep(1);
            continue;
        }
        while(fgets(buf, sizeof(buf) - 1, fp) != NULL)
        {
            if(strncmp(buf,symble,strlen(symble)) == 0)
                count_new = atoi(buf+strlen(symble));
            memset(buf,0,sizeof(buf));
        }
        if((count_new - count_old) > 1)
        {
            update_gnss_value();//out put mnld severe abnormal state
            RLOGD("mnld is severe abnormal state = %d\n",count_new - count_old);
        }
        else
        {
            set_sdk_ready_status_bit(BIT_EXCPT_GNSS,0);
        }
        pclose(fp);
        count_old = count_new;
        sleep(global_param->period.GNSS);
    }
    return;
}
void *check_partition(void *arg)
{
    unlock_with_s_start(&s_ptn_started);
    while(1)
    {
        t800_check_partition();
        sleep(global_param->period.PTN);
    }
    return NULL;
}

void *check_gnss(void * arg)
{
    unlock_with_s_start(&s_gnss_started);
    t800_check_mnld();
    return NULL;
}
int get_cpu_info()
{
    FILE *CPU_FD = NULL;
    int cpu_num = 0;
    char cpu_info[8];
    CPU_FD = popen(GET_CPU_NUM,"r");
    if(CPU_FD == NULL)
    {
        RLOGD("get cpu info fail:%s",GET_CPU_NUM);
        return -1;
    }
    fgets(cpu_info, sizeof(cpu_info) - 1, CPU_FD);
    cpu_num = atoi(cpu_info);
    pclose(CPU_FD);
    return cpu_num;
}
int set_default_sdk_check_param(lynq_sdk_check_param_t *param)
{
    int cpu_num = 0;
    param->period.RIL = DEFAULT_PERIOD_RIL;
    param->period.GNSS = DEFAULT_PERIOD_GNSS;
    param->period.MD = DEFAULT_PERIOD_MD;
    param->period.PTN = DEFAULT_PERIOD_PTN;
    param->period.SYS = DEFAULT_PERIOD_SYS;
    param->period.BOOT = DEFAULT_PERIOD_BOOT;
    cpu_num = get_cpu_info();
    if(cpu_num <= 0)
    {
        RLOGE("set default sdk check param fail");
        return -1;
    }
    param->threshold.interrupts = (DEFAULT_PERIOD_SYS/30)*cpu_num*5000;
    param->threshold.load_average = cpu_num*2;
    return 0;
}
int create_check_threads(void)
{
    pthread_t thid,thid_1,thid_2,thid_3,thid_4;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    int ret;
    pthread_mutex_lock(&s_startupMutex);
    ret = pthread_create(&thid, &attr, timer_request_imei, NULL);
    if(ret != 0)
    {
        RLOGE("timer_request_imei error!!!");
        goto excp;
    }
    while (s_ril_started == 0)
    {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }
    ret = pthread_create(&thid_1, &attr, check_system, NULL);
    if(ret != 0)
    {
        RLOGE("check_system error!!!");
        goto excp;
    }
    while (s_sys_started == 0)
    {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }

    ret = pthread_create(&thid_2, &attr,check_gnss,NULL);
    if(ret != 0)
    {
        RLOGD("check_gnss error!!!");
        goto excp;
    }
    while (s_gnss_started == 0)
    {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }
    ret = pthread_create(&thid_3, &attr,check_partition,NULL);
    if(ret != 0)
    {
        RLOGD("check_partition error!!!");
        goto excp;
    }
    while (s_ptn_started == 0)
    {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }
    s_ril_started = 0;
    ret = pthread_create(&thid_4, &attr,wait_ril_event,NULL);
    if(ret != 0)
    {
        RLOGD("wait_ril_event error!!!");
        goto excp;
    }
    while (s_ril_started == 0)
    {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }
    pthread_mutex_unlock(&s_startupMutex);
    return 0;
excp:
    pthread_mutex_unlock(&s_startupMutex);
    return LYNQ_E_NORMAL;
}
int lynq_sdk_ready_register(const int uToken,const lynq_sdk_check_param_t* param,lynq_sdk_status_cb sdk_status_cb)
{
    int ret = 0;
    if (param == NULL || sdk_status_cb == NULL)
    {
        RLOGE("input null");
        return LYNQ_E_NULL_ANONALY;
    }
    utoken = uToken;
    global_param = (lynq_sdk_check_param_t *)malloc(sizeof(lynq_sdk_check_param_t));
    if(global_param == NULL)
    {
        RLOGE("malloc global_param fail");
        goto end;
    }
    memset(global_param,0,sizeof(lynq_sdk_check_param_t));
    if(param->isvalid == 0)
    {
        ret = set_default_sdk_check_param(global_param);
        if (ret < 0)
        {
            RLOGE("get default param fail");
            goto end;
        }
    }
    else
    {
        if((param->period.RIL < MIN_PERIOD_RIL) || (param->period.GNSS < MIN_PERIOD_GNSS) || (param->period.MD < MIN_PERIOD_MD) 
        || (param->period.PTN < MIN_PERIOD_PTN) || (param->period.SYS < MIN_PERIOD_SYS))
        {
            RLOGE("param excption");
            goto end;
        }
        global_param->period.RIL = param->period.RIL;
        global_param->period.GNSS = param->period.GNSS;
        global_param->period.MD = param->period.MD;
        global_param->period.PTN = param->period.PTN;
        global_param->period.SYS = param->period.SYS;
        global_param->period.BOOT = param->period.BOOT;
        global_param->threshold.interrupts = param->threshold.interrupts;
        global_param->threshold.load_average = param->threshold.load_average;
    }
    RLOGI("period.RIL:%d,period.GNSS:%d,period.MD:%d,period.PTN:%d,period.SYS:%d,threshold.interrupts:%llu,threshold.load_average:%d",
    global_param->period.RIL,global_param->period.GNSS,global_param->period.MD,global_param->period.PTN,
    global_param->period.SYS,global_param->threshold.interrupts,global_param->threshold.load_average);
    global_sdk_status_cb = sdk_status_cb;
    global_sdk_status.sdk_ready_status = (lynq_sdk_status_t)-1;
    global_sdk_status.ref_action = (lynq_sdk_ref_action_t)-1;
    set_sdk_ready_nv(1);//开机默认RIL 异常，第一次检测完成之后更新正确值
    ret = create_check_threads();
    if(ret != 0)
    {
        goto end;
    }
    return ret;
end:
    exit(EXIT_FAILURE);
}
int lynq_get_sdk_ready_status(int *status)
{
    if (status == NULL)
    {
        RLOGE("sdk_ready_status is null");
        return LYNQ_E_NULL_ANONALY;
    }
    *status = global_sdk_ready_status;
    return 0;
}