osforlinux.c

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

	return _err;
}

static int add_node(osforlinux_task_t **node)
{
	osforlinux_task_t *_tail=NULL;
	osforlinux_task_t *_node=NULL;
	int _err=-1;

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

	return _err;
}

int osforlinux_task_getcount(void)
{
	return gs_all_thread_count;
}

void osforlinux_task_print()
{
	osforlinux_task_t *last=NULL;
	last = gsp_task_list_head;
	int _index=0;
	
	printf("\n\tAll Thread: %d \n\n",gs_all_thread_count);
	while(last != NULL)
	{
		printf("\ttask name:%d --> %s \n",++_index,last->task_name);
		last=last->next;
	}
}
//====================semahore function====================

osforlinux_sem_t *osforlinux_sem_create(partition_t * partition_p, int value)
{
	osforlinux_sem_t *_sem=NULL;

	UNUSED_PARAMETER(partition_p);
	
	_sem = (osforlinux_sem_t*)malloc(sizeof(osforlinux_sem_t));
	if(NULL == _sem)
	{
		debug_osforlinux_print(("osforlinux_create_sem: malloc Faild !\n"));
		return (osforlinux_sem_t*)NULL;
	}

	if(SEM_VALUE_MAX < value)
	{
		debug_osforlinux_print(("osforlinux_create_sem: value(%d) > SEM_VALUE_MAX(%d) !\n",value,SEM_VALUE_MAX));
		return (osforlinux_sem_t*)NULL;
	}
	
	if(sem_init(_sem,0,value) != 0)
	{
		debug_osforlinux_print(("osforlinux_create_sem: init Faild !\n"));
		return (osforlinux_sem_t*)NULL;
	}

	return (osforlinux_sem_t *)_sem;
}

int osforlinux_sem_delete(partition_t *partition_p, osforlinux_sem_t *sem_p)
{
	UNUSED_PARAMETER(partition_p);

	if(NULL == sem_p)
	{
		debug_osforlinux_print(("osforlinux_delete_sem: sem_p NULL !\n"));
		return -1;
	}

	return sem_destroy(sem_p);
}

int osforlinux_sem_signal(osforlinux_sem_t * sem_p)
{
	if(sem_p == NULL)
	{
		debug_osforlinux_print(("osforlinux_signal: sem_p NULL !\n"));
		return -1;
	}

	return sem_post(sem_p);
}

int osforlinux_sem_wait(osforlinux_sem_t * sem_p)
{
	if(sem_p == NULL)
	{
		task_t tid = osforlinux_task_id();
		debug_osforlinux_print(("osforlinux_sem_wait: sem_p NULL ! taskid=%d,taskname=%s\n",tid,osforlinux_task_name(&tid)));
		return -1;
	}

	return sem_wait(sem_p);
}

int osforlinux_sem_waittimeout(osforlinux_sem_t * sem_p, clock_t * millisecond_p)
{
	struct timespec _ts;
	U32 _sec=0,_msec=0;
			
	if(NULL == sem_p)
	{
		debug_osforlinux_print(("osforlinux_wait_timeout: sem_p NULL !\n"));
		return -1;
	}
	
	if((clock_t*)NULL == millisecond_p)
	{
		return osforlinux_sem_wait(sem_p);
	}

	if((clock_t*)-1 == millisecond_p)
	{
		return sem_trywait(sem_p);
	}

	if(clock_gettime(CLOCK_REALTIME, &_ts) == -1)
	{
		debug_osforlinux_print(("osforlinux_wait_timeout: clock_gettime error !\n"));
		return -1;
	}

	_msec =	*millisecond_p;
	_sec=_msec/1000; //get second count;
	_msec = _msec%1000;
	
	_ts.tv_sec +=  _sec;
	_ts.tv_nsec += (_msec*1000000);

	return sem_timedwait(sem_p,&_ts);
}

int osforlinux_sem_getvalue(osforlinux_sem_t *sem_p, int *value)
{
	if(sem_p == NULL )
	{
		debug_osforlinux_print(("osforlinux_getvalue: sem_p NULL !\n"));
		return -1;
	}

	return sem_getvalue(sem_p,value);
}

//====================message function====================

#define FILE_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
//#define FILE_MODE (S_IRUSR|S_IWUSR)
osforlinux_mq_t *osforlinux_mq_create(size_t element_size, unsigned int no_elements)
{
	static U32 s_count=0;
	char _mq_name[14];
	struct mq_attr _attr={0};
	int _oflag=0;
	osforlinux_mq_t *p_mq=NULL;

	sprintf(_mq_name,"/linuxmq%d",s_count++);
	debug_osforlinux_print(("osforlinux_mq_create: name is -> %s\n",_mq_name));
	_oflag = O_CREAT | O_RDWR;
	_attr.mq_maxmsg=no_elements;
	_attr.mq_msgsize=element_size;
	printf("osforlinux_mq_create:%s;num=%d,size=%d \n",_mq_name,no_elements,element_size);
	
	p_mq = (osforlinux_mq_t*)malloc(sizeof(osforlinux_mq_t));
	*p_mq = mq_open(_mq_name,_oflag,FILE_MODE,&_attr);
	if(-1 == *p_mq)
	{
		debug_osforlinux_print(("osforlinux_mq_create: mq_open error !\n"));
		return NULL;
	}
	return p_mq;
}

int osforlinux_mq_delete(osforlinux_mq_t * mq_p)
{
	int _err=0;
	if(NULL == mq_p)
	{
		debug_osforlinux_print(("osforlinux_mq_delete: mq_p NULL !\n"));
		return -1;
	}

	_err = mq_close(*mq_p);
	if(_err == -1)
	{
		debug_osforlinux_print(("osforlinux_mq_delete: mq_close Error !\n"));
		return -1;
	}
	free(mq_p);
	return _err;
}

void* osforlinux_mq_claim(osforlinux_mq_t * mq_p)
{
	struct mq_attr _attr;
	void *_buff=NULL;
	
	if (mq_getattr(*mq_p, &_attr) == -1)
	{
		debug_osforlinux_print(("osforlinux_mq_claim: mq_getattr Error !\n"));
		return NULL;
	}
	_buff=malloc(_attr.mq_msgsize);
	if(NULL == _buff)
	{
		debug_osforlinux_print(("osforlinux_mq_claim: malloc Error !\n"));
		return NULL;
	}

	return (void*)_buff;
}

void* osforlinux_mq_claimtimeout(osforlinux_mq_t * mq_p, clock_t *timevalue)
{
	UNUSED_PARAMETER(timevalue);
	return osforlinux_mq_claim(mq_p);
}
		
void * osforlinux_mq_receive (osforlinux_mq_t* mq_p)
{
	struct mq_attr _attr;
	char *_buff=NULL;
	int _err=0;

	if(NULL == mq_p)
	{
		debug_osforlinux_print(("osforlinux_mq_receive: mq_p NULL !\n"));
	}

	mq_getattr(*mq_p, &_attr);
	_buff =(char*)malloc(_attr.mq_msgsize);
	if(NULL == _buff)
	{
		debug_osforlinux_print(("osforlinux_mq_receive: malloc Error !\n"));
		return NULL;
	}
	
	_err = mq_receive(*mq_p, _buff, _attr.mq_msgsize, 0);
	if(-1 == _err)
	{
		free(_buff);
//		debug_osforlinux_print(("osforlinux_mq_receive: mq_receive Error ! taskid:%d\n",(int)osforlinux_task_id()));
		return NULL;
	}
	
	return (void*)_buff;
}

void *osforlinux_mq_receivetimeout(osforlinux_mq_t* mq_p,clock_t *millisecond_p)
{
	struct timespec _ts;
	struct mq_attr _attr;
	clock_t _total_msec=0;
	char *_buff=NULL;
	int _err=0;

	U32 _sec=0,_msec=0;

	if(NULL == mq_p)
	{
		debug_osforlinux_print(("osforlinux_wait_timeout: mq_p NULL !\n"));
	}
	
	if((clock_t*)NULL == millisecond_p)
	{
		return osforlinux_mq_receive(mq_p);
	}

	if((clock_t*)-1 == millisecond_p)
	{
		_total_msec = 0;
	}
	else
	{
		_total_msec = *millisecond_p;
	}

	if(clock_gettime(CLOCK_REALTIME, &_ts) == -1)
	{
		debug_osforlinux_print(("osforlinux_wait_timeout: clock_gettime error !\n"));
		return (void *)-1;
	}

	_msec =	_total_msec;
	_sec=_msec/1000; //get second count;
	_msec = _msec%1000;
	
	_ts.tv_sec +=  _sec;
	_ts.tv_nsec += (_msec*1000000);

	
	mq_getattr(*mq_p, &_attr);
	_buff =(char*)malloc(_attr.mq_msgsize);
	if(NULL == _buff)
	{
		debug_osforlinux_print(("osforlinux_mq_receive: malloc Error !\n"));
		return (void *)NULL;
	}
	
	_err = mq_timedreceive(*mq_p, _buff, _attr.mq_msgsize, 0, &_ts);
	if(-1 == _err)
	{
		free(_buff);
//		debug_osforlinux_print(("osforlinux_mq_receivetimeout: mq_timedreceive Error ! taskid:%d,errno:%d\n",(int)osforlinux_task_id(),errno));
//		perror(strerror(errno));
		return (void *)NULL;
	}
	
	return (void*)_buff;
}


int osforlinux_mq_send(osforlinux_mq_t * mq_p, void * msg_p)
{
	struct mq_attr _attr;
	int _err=0;
	
	if(NULL == mq_p || NULL == msg_p)
	{
		debug_osforlinux_print(("osforlinux_mq_send: param Error !\n"));
		return -1;
	}
	mq_getattr(*mq_p, &_attr);
	_err = mq_send(*mq_p, (char*)msg_p, _attr.mq_msgsize, 0);
	free(msg_p);

	if(_err != 0)
	{
		debug_osforlinux_print(("osforlinux_mq_send: mq_send Error !\n"));
		return -1;
	}

	return _err;
}

int osforlinux_mq_release(osforlinux_mq_t* mq_p, void* msg_p)
{
	if(NULL == mq_p || NULL == msg_p)
	{
		debug_osforlinux_print(("message_release: param Error !\n"));
		return -1;
	}

	free(msg_p);
	debug_osforlinux_print(("osforlinux_mq_release:OK !\n"));
	return 0;
}