Esempio n. 1
0
/**
 * This function will delete the data from CacheData list.
 *
 * @param cache the cache pointer
 * @param name the cache data name
 *
 * @return error code
 */
static CacheErrCode delData(pCache const cache, const char* name) {
    CacheErrCode errorCode = CACHE_NO_ERR;
    pCacheData data = cache->dataHead, dataTemp;
    /* lock the thread pool synchronized lock */
    cache->pool->lock(cache->pool);

    assert((name != NULL) && (strlen(name) <= CACHE_NAME_MAX));
    /* check cache initialize */
    if (cache->dataHead == NULL) {
        log_d("the %s's data list is NULL,delete data fail", cache->name);
        errorCode = CACHE_NO_VALUE;
    }
    /* search the data from list*/
    if (errorCode == CACHE_NO_ERR) {
        if (strcmp(data->name, name)) { /* list head  */
            for (;;) {
                if (data->next == NULL) {/* list tail */
                    log_d("could not find %s", name);
                    errorCode = CACHE_NAME_ERROR;
                    break;
                } else {
                    if (!strcmp(data->next->name, name)) {
                        break;
                    } else {
                        data = data->next;
                    }
                }
            }
        }
    }
    if (errorCode == CACHE_NO_ERR) {
        /* delete data is head node */
        if (data == cache->dataHead) {
            /* the list has one node */
            if ((cache->dataHead == cache->dataTail)
                    && (cache->dataHead != NULL)) {
                cache->dataHead = cache->dataTail = NULL;
            } else { /* the list has more than one node*/
                cache->dataHead = data->next;
            }
        } else if (data->next == cache->dataTail) {/* delete data is tail node */
            cache->dataTail = data;
            cache->dataTail->next = NULL;
            data = data->next; /* data will be freed in the end */
        } else {
            dataTemp = data->next;
            data->next = data->next->next;
            data = dataTemp; /* data will be freed in the end */
        }
        free(data->value);
        data->value = NULL;
        free(data);
        data = NULL;
        dataTemp = NULL;
        log_d("delete %s data node is success", name);
    }
    /* unlock the thread pool synchronized lock */
    cache->pool->unlock(cache->pool);
    return errorCode;
}
Esempio n. 2
0
/**
 * This function will initialize the thread pool.
 *
 * @param pool the ThreadPool pointer
 * @param name the ThreadPool name
 * @param maxThreadNum the max thread number in this ThreadPool
 * @param threadStackSize the thread stack size in this ThreadPool
 *
 * @return error code
 */
ThreadPoolErrCode initThreadPool(pThreadPool const pool, const char* name, uint8_t maxThreadNum, uint32_t threadStack) {
    ThreadPoolErrCode errorCode = THREAD_POOL_NO_ERR;
    uint8_t i = 0;

    if (maxThreadNum > THREAD_POOL_MAX_THREAD_NUM) {
        errorCode = THREAD_POOL_MAX_NUM_ERR;
    }
    if (errorCode == THREAD_POOL_NO_ERR) {
        pthread_mutex_init(&(pool->queueLock), NULL);
        pthread_mutex_init(&(pool->userLock), NULL);
        pthread_cond_init(&(pool->queueReady), NULL);
        pool->queueHead = NULL;
        pool->maxThreadNum = maxThreadNum;
        pool->curWaitThreadNum = 0;
        pool->isShutdown = false;
        pool->addTask = addTask;
        pool->delAll = delAll;
        pool->destroy = destroy;
        pool->lock = syncLock;
        pool->unlock = syncUnlock;
        pool->threadID = (pthread_t *) malloc(maxThreadNum * sizeof(pthread_t));
        assert(pool->threadID != NULL);
        for (i = 0; i < maxThreadNum; i++) {
            pthread_create(&(pool->threadID[i]), NULL, threadJob, pool);
            log_d("create thread success.Current total thread number is %d", i + 1);
        }
        log_d("initialize thread pool success!");
    }
    return errorCode;
}
Esempio n. 3
0
int read_task(const char *filename)
{

	log_d("read_task filename:%s", filename);
	FILE *fp = fopen(filename, "r");
	if (fp == NULL)
	{
		fprintf(stderr, "cannot open %s\n", filename);
		return 0;
	}

	char str_line[1024] =
	{ };             //每行最大读取的字符数
	while (!feof(fp))
	{
		if (fgets(str_line, 1024, fp) == NULL)             //读取一行
		{
			break;
		}
		if (strlen(str_line) > 0)
		{
			trim(str_line);
			add_task(parse_cmd(str_line));
			log_d("%s", str_line); //输出
		}
		memset(str_line, 0, 1024);
	}
	fclose(fp);
	return 1;
}
Esempio n. 4
0
static void dump_pollfds(int n, int r)
{
	char *buf, *b;
	int i;

	buf = malloc(5 * n + 10);
	if (buf == 0)
		return;
	if (r == 0) {
		b = buf + sprintf(buf, "fds:     ");
		for (i = 0; i < n; i++)
			b += sprintf(b, " %4d", pollfds[i].fd);
		log_d("%s", buf);
		b = buf + sprintf(buf, "events:  ");
		for (i = 0; i < n; i++)
			b += sprintf(b, " %4hd", pollfds[i].events);
		log_d("%s", buf);
	} else {
		b = buf + sprintf(buf, "revents: ");
		for (i = 0; i < n; i++)
			b += sprintf(b, " %4hd", pollfds[i].revents);
		log_d("%s", buf);
	}
	free(buf);
}
Esempio n. 5
0
int main(int argc, char *argv[])
{
    log_init(LOG_LEVEL_E, LOG_MODE_PRINT);

    log_v("log level is LOG_LEVEL_E version log\n");
    log_d("log level is LOG_LEVEL_E debug log\n");
    log_e("log level is LOG_LEVEL_E error log\n");

    log_init(LOG_LEVEL_D, LOG_MODE_PRINT);

    log_v("log level is LOG_LEVEL_D version log\n");
    log_d("log level is LOG_LEVEL_D debug log\n");
    log_e("log level is LOG_LEVEL_D error log\n");

    log_init(LOG_LEVEL_V, LOG_MODE_PRINT);

    log_v("log level is LOG_LEVEL_V version log\n");
    log_d("log level is LOG_LEVEL_V debug log\n");
    log_e("log level is LOG_LEVEL_V error log\n");

    log_init(LOG_LEVEL_V, LOG_MODE_FILE);

    log_v("log level is LOG_LEVEL_V version log\n");
    log_d("log level is LOG_LEVEL_V debug log\n");
    log_e("log level is LOG_LEVEL_V error log\n");


    return 0;
}
Esempio n. 6
0
static void reap_children(void)
{
	pid_t pid;
	int errno_save, status, exitstatus, termsig;

	errno_save = errno;
	while (1) {
		pid = waitpid(-1, &status, WNOHANG);
		if (pid <= 0)
			break;
		if (WIFEXITED(status)) {
			++stats.exited_children;
			exitstatus = WEXITSTATUS(status);
			if (exitstatus || debug)
				log_d("child process %d exited with status %d", (int) pid, exitstatus);
		} else if (WIFSIGNALED(status)) {
			++stats.exited_children;
			termsig = WTERMSIG(status);
			log_d("child process %d killed by signal %d", (int) pid, termsig);
		} else
			log_d("child process %d stopped!?", (int) pid);
	}
	if (pid < 0 && errno != ECHILD)
		lerror("waitpid");
	errno = errno_save;
}
Esempio n. 7
0
static int fill_connection(struct connection *cn)
{
	struct pool *p;
	int poolleft, n, m;
	intmax_t fileleft;

	if (cn->rfd == -1)
		return 0;
	p = &cn->output;
	poolleft = p->ceiling - p->end;
	fileleft = cn->left;
	n = fileleft > poolleft ? poolleft : (int) fileleft;
	if (n <= 0)
		return 0;
	cn->left -= n;
	m = read(cn->rfd, p->end, n);
	if (debug)
		log_d("fill_connection: %d %d %d %d", cn->rfd, (int) (p->end - p->floor), n, m);
	if (m != n) {
		if (m == -1)
			lerror("read");
		else
			log_d("premature end of file %s", cn->r->path_translated);
		return -1;
	}
	p->end += n;
	cn->file_offset += n;
	return n;
}
Esempio n. 8
0
int process_imap(struct request *r)
{
    FILE *fp;
    int fd;
    int retval;

    if (r->method == M_HEAD) {
        r->status = 204;
        return 0;
    } else if (r->method != M_GET) {
        r->status = 405;
        return 0;
    }
    fd = open(r->path_translated, O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        log_d("cannot open map file %s", r->path_translated);
        lerror("open");
        r->status = 500;
        return 0;
    }
    fcntl(fd, F_SETFD, FD_CLOEXEC);
    fp = fdopen(fd, "r");
    if (fp == 0) {
        log_d("process_imap: fdopen failed");
        close(fd);
        r->status = 500;
        return 0;
    }
    retval = f_process_imap(r, fp);
    fclose(fp);
    return retval;
}
Esempio n. 9
0
void exec_task()
{

	if (taskcount > 0)
	{
		int i = 0;
		time_t current;
		Interval_Task *task;
		while (1)
		{
			current = time(NULL);
			for (; i < taskcount; i++)
			{
				task = tasks[i];
				time_t j_time = (current - task->last_time);
				if (j_time >= task->interval)
				{
					log_d("exec cmdline:%s", task->cmdline);
					int result = system(task->cmdline);
					log_d("system result:%d", result);
					task->last_time = current;
				}
			}
			i = 0;
			sleep(1);

		}
	}
}
Esempio n. 10
0
/**
 * This function will add CacheData to list.
 *
 * @param cache the cache pointer
 * @param name the name of CacheData
 * @param length the value length
 * @param value the value point
 * @param valueChangedListener the changed value's callback function
 *
 * @return error code
 */
static CacheErrCode addData(pCache const cache, const char* name, uint8_t length,
        uint16_t* value, void* (*valueChangedListener)(void *arg)) {
    CacheErrCode errorCode = CACHE_NO_ERR;
    pCacheData data;
    /* lock the thread pool synchronized lock */
    cache->pool->lock(cache->pool);

    data = (pCacheData) malloc(sizeof(CacheData));
    assert(data != NULL);

    if (hasData(cache, name) != NULL) {/* the data must not exist in list */
        log_d("the name of %s data is already exist in cache data list", name);
        errorCode = CACHE_NAME_ERROR;
    } else {
        strcpy(data->name, name);
    }

    if (errorCode == CACHE_NO_ERR) {
        if (length > CACHE_LENGTH_MAX) {
            log_d("the name %s is too long,can't add to list", name);
            errorCode = CACHE_LENGTH_ERROR;
        } else {
            data->length = length;
        }
    }

    if (errorCode == CACHE_NO_ERR) {
        /* malloc data value space */
        data->value = (uint16_t*) malloc(length * sizeof(uint16_t));
        assert(data->value != NULL);
        memcpy(data->value, value, length * sizeof(uint16_t));
        data->valueChangedListener = valueChangedListener;
        data->next = NULL;
        /* if list is NULL ,then head node is equal of tail node*/
        if (cache->dataHead == NULL) {
            cache->dataHead = cache->dataTail = data;
        } else if ((cache->dataHead == cache->dataTail) /* the list has one node */
        && (cache->dataHead != NULL)) {
            cache->dataHead->next = data;
            cache->dataTail = data;
        } else { /* the list has more than one node*/
            cache->dataTail->next = data;
            cache->dataTail = data;
        }
        log_d("add %s to data list is success", name);
    } else if (errorCode != CACHE_NO_ERR) {
        free(data);
        data = NULL;
    }
    /* unlock the thread pool synchronized lock */
    cache->pool->unlock(cache->pool);
    return errorCode;
}
Esempio n. 11
0
void lerror(const char *s)
{
	int saved_errno;
	char *errmsg;

	saved_errno = errno;
	errmsg = strerror(errno);
	if (s && *s)
		log_d("%s: %s", s, errmsg ? errmsg : "???");
	else
		log_d("%s", errmsg ? errmsg : "???");
	errno = saved_errno;
}
Esempio n. 12
0
int open_log(const char *name)
{
	char converted_name[PATHLEN];
	const char *n;
	struct tm *tp;
	int rv;

	n = name;
	if (strchr(name, '%')) {
		current_time = time(0);
		if (log_gmt)
			tp = gmtime(&current_time);
		else
			tp = localtime(&current_time);
		if (tp) {
			if (strftime(converted_name, PATHLEN - 1, name, tp))
				n = converted_name;
		}
	}
	rv = open(n, O_WRONLY | O_CREAT | O_APPEND, 0666);
	if (rv == -1) {
		log_d("cannot open %s", n);
		lerror("open");
	}
	return rv;
}
Esempio n. 13
0
/**
 * This function will add a task to thread pool.
 *
 * @param pool the ThreadPool pointer
 * @param process task function pointer
 * @param arg task function arguments
 *
 * @return error code
 */
static ThreadPoolErrCode addTask(pThreadPool const pool, void *(*process)(void *arg),
        void *arg) {
    ThreadPoolErrCode errorCode = THREAD_POOL_NO_ERR;
    pTask member = NULL;
    pTask newtask = (pTask) malloc(sizeof(Task));
    assert(newtask != NULL);
    newtask->process = process;
    newtask->arg = arg;
    newtask->next = NULL;
    /* lock thread pool */
    pthread_mutex_lock(&(pool->queueLock));
    member = pool->queueHead;
    /* task queue is NULL */
    if (member == NULL) {
        pool->queueHead = newtask;
    } else {
        /* look up for queue tail */
        while (member->next != NULL) {
            member = member->next;
        }
        member->next = newtask;
    }
    /* add current waiting thread number */
    pool->curWaitThreadNum++;
    pthread_mutex_unlock(&(pool->queueLock));
    /* wake up a waiting thread to process task */
    pthread_cond_signal(&(pool->queueReady));
    log_d("add a task to task queue success.");
    return errorCode;
}
Esempio n. 14
0
	CMultiFileWatch()
	{
		m_fd = inotify_init1(IN_NONBLOCK);
		log_d(MODULE, "CMultiFileWatch(): m_fd=%i", m_fd);
		if(m_fd == -1){
			throw Exception(ss_()+"inotify_init() failed: "+strerror(errno));
		}
	}
Esempio n. 15
0
/**
 * Elog demo
 */
static void test_elog(void) {
    log_a("Hello EasyLogger!");
    log_e("Hello EasyLogger!");
    log_w("Hello EasyLogger!");
    log_i("Hello EasyLogger!");
    log_d("Hello EasyLogger!");
    log_v("Hello EasyLogger!");
    //elog_raw("Hello EasyLogger!");
}
Esempio n. 16
0
/**
 * EasyLogger demo
 */
void test_elog(void) {
    /* test log output for all level */
    log_a("Hello EasyLogger!");
    log_e("Hello EasyLogger!");
    log_w("Hello EasyLogger!");
    log_i("Hello EasyLogger!");
    log_d("Hello EasyLogger!");
    log_v("Hello EasyLogger!");
//    elog_raw("Hello EasyLogger!");
}
Esempio n. 17
0
void element::Render()
{
	lock();


	if (m_parent)
	{
		m_parent->lock();
		if (GetHide() == 0)
		{
			log_d("%s doRender",GetName());
			doRender();
		}
		else
		{
			log_d("Render %s hide\r\n", GetName());
		}
		//printf("draw %s parent %s  %d %d %d %d\n",m_parent->GetName(),GetName(),GetWidth(), GetHeight(), GetX(), GetY());
		m_parent->RenderFrom(this, 0, 0, GetWidth(), GetHeight(), GetX(), GetY());	//控件输出到父亲
		m_parent->unlock();
		//m_parent->Flush();
	}
	else
	{
		RenderEB();

		if (GetHide() == 0)
		{
			log_d("%s doRender\n",GetName());
			doRender();
		}
		else
		{
			log_d("Render %s hide\r\n", GetName());
		}
		//printf("draw %s %d %d %d %d\n",GetName(),GetWidth(), GetHeight(), GetX(), GetY());
		m_proc->Draw(this, 0, 0, GetWidth(), GetHeight(), GetX(), GetY());//控件输出到容器

		RenderET();
	}

	unlock();
}
Esempio n. 18
0
void WiFiSTAClass::_smartConfigCallback(uint32_t st, void* result) {
    smartconfig_status_t status = (smartconfig_status_t) st;
    log_d("Status: %s", sc_status_strings[st % 5]);
    if (status == SC_STATUS_GETTING_SSID_PSWD) {
        smartconfig_type_t * type = (smartconfig_type_t *)result;
        log_d("Type: %s", sc_type_strings[*type % 3]);
    } else if (status == SC_STATUS_LINK) {
        wifi_sta_config_t *sta_conf = reinterpret_cast<wifi_sta_config_t *>(result);
        log_d("SSID: %s", (char *)(sta_conf->ssid));
        esp_wifi_set_config(WIFI_IF_STA, (wifi_config_t *)sta_conf);
        esp_wifi_connect();
        _smartConfigDone = true;
    } else if (status == SC_STATUS_LINK_OVER) {
        if(result){
            ip4_addr_t * ip = (ip4_addr_t *)result;
            log_d("Sender IP: " IPSTR, IP2STR(ip));
        }
        WiFi.stopSmartConfig();
    }
}
Esempio n. 19
0
int init_pollfds(size_t n)
{
	if (n == 0)
		return 0;
	pollfds = malloc(n * sizeof *pollfds);
	if (pollfds == 0) {
		log_d("init_pollfds: out of memory");
		return -1;
	}
	return 0;
}
Esempio n. 20
0
static void pool_adjust(struct pool *p, size_t s)
{
	size_t n;

	n = p->size;
	if (s > 0 && s < n)
		n -= n % s;
	if (debug)
		log_d("pool_adjust: n=%u", (unsigned) n);
	p->ceiling = p->floor + n;
}
Esempio n. 21
0
int shell_exec(const ss_ &command, const ExecOptions &opts)
{
	log_d(MODULE, "shell_exec(\"%s\")", cs(command));
	int f = fork();
	if(f == 0){
		execl("/bin/sh", "sh", "-c", command.c_str(), (const char*)nullptr);
	}
	int exit_status;
	while(wait(&exit_status) > 0);
	return exit_status;
}
Esempio n. 22
0
File: main.c Progetto: jtheoof/bina
void
bina_exit()
{
    renderer_destroy();

    if (m.window) {
        sdl_destroy_window(m.window);
    }

    log_d("exiting library");
    sdl_quit();
}
Esempio n. 23
0
int init_log_buffer(size_t size)
{
	log_buffer_size = size;
	if (size == 0)
		return 0;
	log_buffer = malloc(size);
	if (log_buffer == 0) {
		log_d("init_log_buffer: out of memory");
		return -1;
	}
	return 0;
}
Esempio n. 24
0
void hidc_wait_for_empty_service_class(int timeout)
{
	int dd;
	uint32_t cur_cls = 0;  /* current Device Class */
	time_t timeout_end = time(NULL) + timeout;

	log_d("start waiting for empty service class");

	if ((dd = open_hci_dev()) < 0)
		return;

	get_device_class(dd, &cur_cls);
	while (((cur_cls & 0x00fff000) != 0) && (time(NULL) <= timeout_end)) {
		usleep(10 * 1000);
		get_device_class(dd, &cur_cls);
	}

	close_hci_dev(dd);

	log_d("stop waiting for empty service class");
}
Esempio n. 25
0
	void add(const ss_ &path, std::function<void(const ss_ &path)> cb)
	{
		for(auto &pair : m_watch){
			sp_<WatchThing> &watch = pair.second;
			if(watch->path == path){
				log_d(MODULE, "Adding callback to path \"%s\" (inotify fd=%i)",
						cs(path), pair.first);
				watch->cbs.push_back(cb);
				return;
			}
		}
		int r = inotify_add_watch(m_fd, path.c_str(), IN_CLOSE_WRITE |
				IN_MOVED_TO | IN_CREATE | IN_MOVED_FROM | IN_DELETE |
				IN_MODIFY | IN_ATTRIB);
		if(r == -1){
			throw Exception(ss_()+"inotify_add_watch() failed: "+
					strerror(errno)+" (path="+path+")");
		}
		log_d(MODULE, "Watching path \"%s\" (inotify fd=%i)", cs(path), m_fd);
		m_watch[r] = sp_<WatchThing>(new WatchThing(path, {cb}));
	}
Esempio n. 26
0
static int read_connection(struct connection *cn)
{
	size_t bytestoread, bytestomove, offset;
	ssize_t nr;

	bytestoread = cn->header_input.ceiling - cn->header_input.end;
	if (bytestoread == 0) {
		offset = cn->header_input.start - cn->header_input.floor;
		if (offset == 0) {
			log_d("input buffer full");
			close_connection(cn);
			return -1;
		}
		bytestomove = cn->header_input.end - cn->header_input.start;
		memmove(cn->header_input.floor, cn->header_input.start, bytestomove);
		cn->header_input.start -= offset;
		cn->header_input.middle -= offset;
		cn->header_input.end -= offset;
		bytestoread = cn->header_input.ceiling - cn->header_input.end;
	}
	nr = read(cn->fd, cn->header_input.end, bytestoread);
	if (debug)
		log_d("read_connection: %d %d %u %d", cn->fd, (int) (cn->header_input.end - cn->header_input.floor), (unsigned) bytestoread, (int) nr);
	if (nr == -1) {
		if (errno == EAGAIN)
			return 0;
		if (debug)
			lerror("read");
		close_connection(cn);
		return -1;
	}
	if (nr == 0) {
		close_connection(cn);
		return -1;
	}
	cn->nread += nr;
	cn->header_input.end += nr;
	cn->t = current_time;
	return 0;
}
Esempio n. 27
0
void BrucoSession::on_recv_proxy(const char *buf, int buf_size)
{
	std::string target_str(buf, buf_size);
	if (dump_stream_) {
		log_d("dump_stream : session=%ld : [out_bound] %s", session_id_, escape(target_str).c_str());
	}

	if (outbound_key_check_xor256_) {
		std::string key = read_key_();
		if (check_contain_key_xor256_(key, target_str)) {
			log_w("break_session : type=outbound_contain_key_xor256, outbound_key_file=%s",
				outbound_key_file_.c_str());
			break_session();
			return;
		}
	}
	else if (outbound_key_check_) {
		std::string key = read_key_();
		if (check_contain_key_(key, target_str)) {
			log_w("break_session : %s, type=outbound_contain_key, outbound_key_file=%s",
				outbound_key_file_.c_str());
			break_session();
			return;
		}
	}

	if (outbound_pass_re_ != NULL) {
		bool rv = RE2::PartialMatch(target_str, *outbound_pass_re_);
		if (rv) {
			BrucoPipe::on_recv_proxy(buf, buf_size);
			return;
		}
	}

	if (outbound_deny_re_ != NULL) {
		bool rv = RE2::PartialMatch(target_str, *outbound_deny_re_);
		if (rv) {
			log_w("break_session : type=outbound_deny_re, outbound_re=%s",
				outbound_deny_re_->pattern().c_str());
			break_session();
			return;
		}
	}

	// default policy
	if (outbound_default_pass_) {
		BrucoPipe::on_recv_proxy(buf, buf_size);
	}
	else {
		break_session();
	}
}
Esempio n. 28
0
static int new_pool(struct pool *p, size_t s)
{
	char *t;

	t = malloc(s);
	if (t == 0) {
		log_d("new_pool: out of memory");
		return -1;
	}
	p->floor = p->start = p->middle = p->end = t;
	p->ceiling = t + s;
	p->size = s;
	return 0;
}
Esempio n. 29
0
/**
 * This function will find the data in CacheData list.
 *
 * @param cache the cache pointer
 * @param name the name of CacheData
 *
 * @return the CacheData point which has found,If not found will return NULL.
 */
static pCacheData hasData(pCache const cache, const char* name) {
    pCacheData data = cache->dataHead;

    assert((name != NULL) && (strlen(name) <= CACHE_NAME_MAX));
    //this cache is null
    if (cache->dataHead == NULL) {
        log_d("the %s's data list is NULL,find data fail", cache->name);
        return NULL;
    }
    /* search the data from list*/
    for (;;) {
        if (!strcmp(data->name, name)) {
            return data;
        } else {
            if (data->next == NULL) {/* list tail */
                log_d("could not find %s", name);
                break;
            }
            data = data->next;
        }
    }
    return NULL;
}
Esempio n. 30
0
/**
 * Elog demo
 */
static void test_elog(void) {
    /* output all saved log from flash */
    elog_flash_output_all();
    /* test log output for all level */
    log_a("Hello EasyLogger!");
    log_e("Hello EasyLogger!");
    log_w("Hello EasyLogger!");
    log_i("Hello EasyLogger!");
    log_d("Hello EasyLogger!");
    log_v("Hello EasyLogger!");
    elog_raw("Hello EasyLogger!");
    /* trigger assert. Now will run elog_user_assert_hook. All log information will save to flash. */
    ELOG_ASSERT(0);
}