osforlinux.c

用linux操作系统接口封装的兼容os20的操作系统接口

#include <stdio.h>
#include <time.h>
#include <stos.h>
#include "osforlinux.h"

//#define DEBUG_OSFORLINUX
#ifdef DEBUG_OSFORLINUX
	#define debug_osforlinux_print(x) printf x
#else
	#define debug_osforlinux_print(x)
#endif

//#define TIMEOUT_INFINITY    ((void *)NULL)
//#define TIMEOUT_IMMEDIATE   ((clock_t *)-1)

static U32 gs_all_thread_count;

static osforlinux_task_t *gsp_task_list_head;
static pthread_mutex_t gs_osforlinux_mutex;

static int find_from_id(task_t *tid,osforlinux_task_t **pelt);
//static int find_from_name(char *name,osforlinux_task_t **pelt);
static int delete_node(osforlinux_task_t **node);
static int add_node(osforlinux_task_t **node);


int  init_osforlinux()
{
	gsp_task_list_head=NULL;
	pthread_mutex_init(&gs_osforlinux_mutex,NULL);
	debug_osforlinux_print(("init_osforlinux OK \n"));
	return 0;
}

//====================task function====================
int osforlinux_task_create(void (*Function)(void* Param)
								, void* Param
								, partition_t* StackPartition
								,size_t StackSize
								,void** Stack
								,partition_t* TaskPartition
								,task_t** Task
								,tdesc_t* Tdesc
								,int Priority
								,const char* Name
								,task_flags_t Flags )
{
	int _err=0;
	osforlinux_task_t *_pelt;
	task_t *_ptid;
	pthread_attr_t _attr;
	struct sched_param  _sparam;

	UNUSED_PARAMETER(StackPartition);
	UNUSED_PARAMETER(StackSize);
	UNUSED_PARAMETER(Stack);
	UNUSED_PARAMETER(TaskPartition);
	UNUSED_PARAMETER(Tdesc);
//	UNUSED_PARAMETER(Flags);
//	UNUSED_PARAMETER(Name);

	printf("osforlinux_task_create: %s !\n",Name);
	pthread_attr_init(&_attr);
	pthread_attr_setschedpolicy(&_attr,SCHED_RR);

	//min = 1 ; max = 99
	if (Priority < sched_get_priority_min(SCHED_RR))
		Priority = sched_get_priority_min(SCHED_RR);

	if (Priority > sched_get_priority_max(SCHED_RR))
		Priority = sched_get_priority_max(SCHED_RR);

	_sparam.sched_priority = Priority;
	pthread_attr_setschedparam(&_attr,&_sparam);

	*Task = (task_t *)malloc(sizeof(task_t));
	
	_err = pthread_create(*Task,&_attr,(void*)Function,(void *)Param);
	
	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_create:pthread_create faild %d!\n",_err));
		free(*Task);
		return _err;
	}
	gs_all_thread_count++;
	debug_osforlinux_print(("osforlinux_task_create: pthread_create after %d!\n",**Task));
	
	_ptid=*Task;
	pthread_detach(*_ptid);//set thread auto free mem
	debug_osforlinux_print(("osforlinux_task_create: set detach !\n"));
//	
	_pelt=(osforlinux_task_t*)malloc(sizeof(osforlinux_task_t));
	if(_pelt == NULL)
	{
		debug_osforlinux_print(("osforlinux_task_create:malloc faild !\n"));
		free(*Task);
		return -1;
	}
	memset(_pelt,0,sizeof(osforlinux_task_t));

	if(NULL == Name)
	{
		debug_osforlinux_print(("osforlinux_task_create:name NULL !\n"));
		free(*Task);
		free(_pelt);
		return -1; 
	}
	strcpy(_pelt->task_name,Name);
	_pelt->tid=*_ptid;
	pthread_cond_init(&_pelt->cond,NULL);
	pthread_mutex_init(&_pelt->mutex,NULL);

	_err = add_node(&_pelt);
//
	if(_err == 0)
		debug_osforlinux_print(("osforlinux_task_create:OK !\n"));
	else
		debug_osforlinux_print(("osforlinux_task_create:add node Faild! \n"));

	return _err;
}

int osforlinux_task_delete(task_t* Task
								,partition_t* TaskPartition
								,void* Stack
								,partition_t* StackPartition )
{
	int _err=0;
	task_t _tid=0;
	osforlinux_task_t *_pelt=NULL;

	UNUSED_PARAMETER(TaskPartition);
	UNUSED_PARAMETER(Stack);
	UNUSED_PARAMETER(StackPartition);
	
	if(NULL == Task)
	{
		debug_osforlinux_print(("osforlinux_task_delete:Task NULL!\n"));
		return -1;
	}
	
	_tid=*Task;
	if (pthread_cancel(_tid))
	{
		debug_osforlinux_print(("ERROR: Couldn't delete Task - it may not have terminated...\n"));
		return -1;
	}
	gs_all_thread_count--;
//	
	_err=find_from_id(&_tid,&_pelt);
	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_delete: for no suspend option!\n"));
		return 0;//micahlee signed it for no suspend option
	}

	_err=delete_node(&_pelt);

	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_delete:delete_node Error !\n"));
		return -1;
	}
	
	pthread_cond_destroy(&_pelt->cond);
	pthread_mutex_destroy(&_pelt->mutex);
	free(_pelt);
//
	free(Task);
	debug_osforlinux_print(("osforlinux_task_delete:OK !\n"));
	return 0;
}

task_t  osforlinux_task_id(void)
{
	task_t _tid=0;
	_tid = pthread_self();
	debug_osforlinux_print(("osforlinux_task_id :_tid=%d \n",_tid));
	return _tid;
}

char*  osforlinux_task_name(task_t *tid)
{
	int _err=0;
	osforlinux_task_t *_pelt=NULL;

	_err=find_from_id(tid,&_pelt);
	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_name:find_from_id Error !\n"));
		return NULL;
	}
	debug_osforlinux_print(("osforlinux_task_name:OK !\n"));
	return (char*)_pelt->task_name;
}

int  osforlinux_task_suspendself(task_t *tid)
{
	int _err=0;
	task_t _tid=0;
	osforlinux_task_t *_pelt=NULL;
	
	if(NULL != tid)
	{
		_tid=*tid;
	}
	else
	{
		debug_osforlinux_print(("osforlinux_task_suspend:tid NULL !\n"));
		_tid=osforlinux_task_id();
	}
	_err=find_from_id(&_tid,&_pelt);
	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_suspend:find_from_id Error !\n"));
		return -1;
	}
	 
	_err=pthread_mutex_lock(&_pelt->mutex);
   
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_suspend:pthread_mutex_lock Error !\n"));
		return -1;
	}
	
	_err= pthread_cond_wait(&_pelt->cond,&_pelt->mutex);
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_suspend:pthread_cond_wait Error !\n"));
		return -1;
	}
    
	_err=pthread_mutex_unlock(&_pelt->mutex);
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_suspend:pthread_mutex_unlock Error !\n"));
		return -1;
	}

	debug_osforlinux_print(("osforlinux_task_suspend:OK !\n"));
	return 0;
}

int  osforlinux_task_resume(task_t *tid)
{
	int _err=0;
	task_t _tid=0;
	osforlinux_task_t *_pelt=NULL;

	if(NULL == tid)
	{
		debug_osforlinux_print(("osforlinux_task_resume:tid NULL !\n"));
		return -1;
	}
	_tid=*tid;
	debug_osforlinux_print(("osforlinux_task_resume: tid=%d \n",_tid));
	_err=find_from_id(&_tid,&_pelt);
	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_task_resume:find_from_id Error !\n"));
		return -1;
	}
	 
	_err=pthread_mutex_lock(&_pelt->mutex);
   
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_resume:pthread_mutex_lock Error !\n"));
		return -1;
	}
	
	_err= pthread_cond_signal(&_pelt->cond);
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_resume:pthread_cond_signal Error !\n"));
		return -1;
	}

	_err=pthread_mutex_unlock(&_pelt->mutex);
	if(0 != _err)
	{
		debug_osforlinux_print(("osforlinux_task_resume:pthread_mutex_unlock Error !\n"));
		return -1;
	}

	debug_osforlinux_print(("osforlinux_task_resume:OK !\n"));
	return 0;
}

static int find_from_id(task_t *tid,osforlinux_task_t **pelt)
{
	int _err=0;
	task_t _tid=0;
	osforlinux_task_t *_pelt=NULL;
	int _done=0;

	if(tid == NULL || pelt == NULL)
	{
		debug_osforlinux_print(("find_from_id:tid || pelt NULL !\n"));
		return -1;
	}
	_tid = *tid;
	debug_osforlinux_print(("find_from_id: tid = %d \n",_tid));
	_pelt=gsp_task_list_head;
	if(_pelt == NULL)
	{
		debug_osforlinux_print(("find_from_id:gsp_task_list_head NULL !\n"));
		return -1;
	}
	while(_pelt!=NULL)
	{
		if(_pelt->tid == _tid)
		{
			_done=1;
			break;
		}
		else
			_pelt=_pelt->next;
	}
	if(_done)
		*pelt=_pelt;
	else
	{
		debug_osforlinux_print(("find_from_id:Not Fund !\n"));
		return -2;
	}

	debug_osforlinux_print(("find_from_id:OK !\n"));
	return 0;
}

static int delete_node(osforlinux_task_t **node)
{
	osforlinux_task_t *_pre=NULL;
	osforlinux_task_t *_next=NULL;
	osforlinux_task_t *_node=NULL;
	int _err=0;
	int _done=0;

	pthread_mutex_lock(&gs_osforlinux_mutex);
	_node=*node;
	_pre=_next=gsp_task_list_head;
	if(_pre == NULL)
	{
		_err = -1;
	}
	else
	{
		while(_next != NULL)
		{
			if(_node == _next)
			{
				if(_next == gsp_task_list_head)
					gsp_task_list_head=_next->next;
				else
					_pre->next = _next->next;
				
				_done=1;
				break;
			}
			_pre=_next;
			_next=_next->next;
		}
		if(_done != 1)
			_err = -1;
	}
	pthread_mutex_unlock(&gs_osforlinux_mutex);
	if(_err != 0)
		debug_osforlinux_print(("delete_node:Faild: %d !\n",_err));
	else
		debug_osforlinux_print(("delete_node: OK \n"));