You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

187 lines
5.0 KiB

/*
* Copyright (C) 2013 SAMSUNG S.LSI
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*
*/
/************************************************************************
** OS interface for task handling
*************************************************************************/
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include "osi.h"
/************************************************************************
** Internal function prototype
*************************************************************************/
/************************************************************************
** Public functions
*************************************************************************/
void osi_task_entry(void* arg) {
tOSI_TASK_ENTRY task_entry = (tOSI_TASK_ENTRY)arg;
// pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
task_entry();
OSI_logt("%s : exit task", __func__);
pthread_exit(NULL);
}
tOSI_TASK_HANDLER OSI_task_allocate(const char* task_name,
tOSI_TASK_ENTRY task_entry) {
tOSI_TASK_HANDLER free_task = NULL;
int index;
/* Find free task */
osi_lock();
for (index = 0; index < OSI_MAX_TASK; index++) {
if (osi_info.task[index].state == OSI_FREE) {
if (free_task == NULL)
free_task = (tOSI_TASK_HANDLER)&osi_info.task[index];
} else {
if (osi_info.task[index].name == NULL) continue;
/* User can't not make same name of task */
if (strcmp((char const*)osi_info.task[index].name,
(char const*)task_name) == 0) {
OSI_loge("%s : %s task is already allocated [%d]", __func__, task_name,
index);
free_task = NULL;
break;
}
}
}
if (free_task == NULL) {
OSI_loge("%s : Failed to find free task(max: %d)", __func__, OSI_MAX_TASK);
} else {
free_task->state = OSI_ALLOCATED;
free_task->name = task_name;
free_task->task_entry = task_entry;
}
osi_unlock();
return free_task;
}
OSI_STATE OSI_task_run(tOSI_TASK_HANDLER task_handler) {
pthread_attr_t attr;
int ret = OSI_FAIL;
osi_lock();
if (!task_handler) {
OSI_loge("%s : task handler is not exist!!", __func__);
} else if (task_handler->state != OSI_ALLOCATED) {
OSI_loge("%s : task state is not ALLOCATED!! (%d)", __func__,
task_handler->state);
} else {
/* Thread attr configuration */
pthread_attr_init(&attr);
if (!pthread_create(&(task_handler->task), &attr,
(void* (*)(void*))osi_task_entry,
(void*)(task_handler->task_entry))) { //
task_handler->state = OSI_RUN;
ret = OSI_OK;
} else {
OSI_loge("%s : pthread_create failed(%d), %s", __func__, ret,
task_handler->name);
}
pthread_attr_destroy(&attr);
}
osi_unlock();
return ret;
}
OSI_STATE OSI_task_isRun(tOSI_TASK_HANDLER task_handler) {
OSI_STATE ret = OSI_FAIL;
osi_lock();
if (task_handler && task_handler->state == OSI_RUN) ret = OSI_RUN;
osi_unlock();
return ret;
}
OSI_STATE OSI_task_stop(tOSI_TASK_HANDLER task_handler) {
OSI_STATE ret = OSI_OK;
if (!task_handler) return OSI_OK;
osi_lock();
if (task_handler->state == OSI_RUN) {
osi_unlock();
// ret = pthread_cancel(task_handler->task);
ret = (OSI_STATE)pthread_join(task_handler->task, NULL);
osi_lock();
}
task_handler->state = OSI_ALLOCATED;
osi_unlock();
return ret;
}
OSI_STATE OSI_task_free(tOSI_TASK_HANDLER task_handler) {
OSI_STATE ret = OSI_OK;
OSI_task_stop(task_handler);
osi_lock();
task_handler->name = NULL;
task_handler->state = OSI_FREE;
osi_unlock();
return ret;
}
OSI_STATE OSI_task_kill(tOSI_TASK_HANDLER task_handler) {
OSI_STATE ret = OSI_OK;
if (!task_handler) return OSI_OK;
osi_lock();
if (task_handler->state == OSI_RUN) {
osi_unlock();
// ret = pthread_cancel(task_handler->task);
ret = (OSI_STATE)pthread_join(task_handler->task, NULL);
osi_lock();
}
task_handler->name = NULL;
task_handler->state = OSI_FREE;
osi_unlock();
return ret;
}
tOSI_TASK_HANDLER OSI_task_get_handler(char* name) {
tOSI_TASK_HANDLER task = NULL;
int index;
if (!name) return NULL;
osi_lock();
for (index = 0; index < OSI_MAX_TASK; index++) {
if ((char const*)osi_info.task[index].name == NULL) continue;
if (strcmp((char const*)osi_info.task[index].name, (char const*)name) ==
0) {
task = &osi_info.task[index];
break;
}
}
osi_unlock();
return task;
}