pthread.c 文件参考

浏览源代码.

函数
_pthread_data *	pthread_get_self_data (void)
_pthread_data *	pthread_get_data (pthread_t id)
	获取线程控制块 更多...
STATIC INT32	CheckForCancel (VOID)
STATIC VOID	ProcessUnusedStatusTask (_pthread_data *data)
STATIC VOID	PthreadReap (VOID)
STATIC VOID	SetPthreadAttr (const _pthread_data *self, const pthread_attr_t *attr, pthread_attr_t *outAttr)
	设置线程的属性 更多...
STATIC VOID	SetPthreadDataAttr (const pthread_attr_t *userAttr, const pthread_t threadID, LosTaskCB *taskCB, _pthread_data *created)
STATIC UINT32	InitPthreadData (pthread_t threadID, pthread_attr_t *userAttr, const CHAR name[], size_t len)
	线程控制块初始化 更多...
int	pthread_create (pthread_t *thread, const pthread_attr_t *attr, void *(*startRoutine)(void *), void *arg)
	pthread_create 创建线程 更多...
void	pthread_exit (void *retVal)
	线程退出 更多...
STATIC INT32	ProcessByJoinState (_pthread_data *joined)
int	pthread_join (pthread_t thread, void **retVal)
int	pthread_detach (pthread_t thread)
int	pthread_setschedparam (pthread_t thread, int policy, const struct sched_param *param)
	设置调度参数 更多...
int	pthread_getschedparam (pthread_t thread, int *policy, struct sched_param *param)
int	pthread_once (pthread_once_t *onceControl, void(*initRoutine)(void))
int	pthread_key_create (pthread_key_t *key, void(*destructor)(void *))
int	pthread_setspecific (pthread_key_t key, const void *pointer)
void *	pthread_getspecific (pthread_key_t key)
int	pthread_setcancelstate (int state, int *oldState)
int	pthread_setcanceltype (int type, int *oldType)
STATIC UINT32	DoPthreadCancel (_pthread_data *data)
int	pthread_cancel (pthread_t thread)
void	pthread_testcancel (void)
pthread_t	pthread_self (void)
int	pthread_equal (pthread_t thread1, pthread_t thread2)
void	pthread_cleanup_push_inner (struct pthread_cleanup_buffer *buffer, void(*routine)(void *), void *arg)
void	pthread_cleanup_pop_inner (struct pthread_cleanup_buffer *buffer, int execute)
int	pthread_setaffinity_np (pthread_t thread, size_t cpusetsize, const cpu_set_t *cpuset)
int	pthread_getaffinity_np (pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset)

变量
STATIC _pthread_data	g_pthreadData [LOSCFG_BASE_CORE_TSK_LIMIT+1]
STATIC INT32	g_pthreadsExited = 0
STATIC pthread_mutex_t	g_pthreadsDataMutex = PTHREAD_MUTEX_INITIALIZER
UINTPTR	g_pthreadCanceledDummyVar

函数说明

CheckForCancel()

STATIC INT32 CheckForCancel

(

VOID

)

在文件 pthread.c 第 99 行定义.

{
    _pthread_data *self = pthread_get_self_data();
    if (self->canceled && (self->cancelstate == PTHREAD_CANCEL_ENABLE)) {
        return 1;
    }
    return 0;
}

函数调用图:

这是这个函数的调用关系图:

DoPthreadCancel()

STATIC UINT32 DoPthreadCancel

(

_pthread_data *

data

)

在文件 pthread.c 第 671 行定义.

{
    UINT32 ret = LOS_OK;
    UINT32 intSave;
    LOS_TaskLock();
    data->canceled = 0;
    if ((data->task->taskStatus & OS_TASK_STATUS_EXIT) || (LOS_TaskSuspend(data->task->taskID) != ENOERR)) {
        ret = LOS_NOK;
        goto OUT;
    }
 
    if (data->task->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
        SCHEDULER_LOCK(intSave);
        OsTaskJoinPostUnsafe(data->task);
        SCHEDULER_UNLOCK(intSave);
        g_pthreadCanceledDummyVar = (UINTPTR)PTHREAD_CANCELED;
        data->task->joinRetval = (VOID *)g_pthreadCanceledDummyVar;
    } else if (data->state && !(data->task->taskStatus & OS_TASK_STATUS_UNUSED)) {
        data->state = PTHREAD_STATE_EXITED;
        g_pthreadsExited++;
        PthreadReap();
    } else {
        ret = LOS_NOK;
    }
OUT:
    LOS_TaskUnlock();
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

InitPthreadData()

STATIC UINT32 InitPthreadData	(	pthread_t	threadID,
		pthread_attr_t *	userAttr,
		const CHAR	name[],
		size_t	len
	)

线程控制块初始化

在文件 pthread.c 第 189 行定义.

{
    errno_t err;
    UINT32 ret = LOS_OK;
    LosTaskCB *taskCB = OS_TCB_FROM_TID(threadID);
    _pthread_data *created = &g_pthreadData[threadID];
 
    err = strncpy_s(created->name, sizeof(created->name), name, len);
    if (err != EOK) {
        PRINT_ERR("%s: %d, err: %d\n", __FUNCTION__, __LINE__, err);
        return LOS_NOK;
    }
    userAttr->stacksize   = taskCB->stackSize;//内核栈大小
    err = OsSetTaskName(taskCB, created->name, FALSE);
    if (err != LOS_OK) {
        PRINT_ERR("%s: %d, err: %d\n", __FUNCTION__, __LINE__, err);
        return LOS_NOK;
    }
#ifdef LOSCFG_KERNEL_SMP
    if (userAttr->cpuset.__bits[0] > 0) {
        taskCB->cpuAffiMask = (UINT16)userAttr->cpuset.__bits[0];//CPU亲和力掩码
    }
#endif
 
    SetPthreadDataAttr(userAttr, threadID, taskCB, created);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

ProcessByJoinState()

STATIC INT32 ProcessByJoinState

(

_pthread_data *

joined

)

在文件 pthread.c 第 328 行定义.

{
    UINT32 intSave;
    INT32 err = 0;
    UINT32 ret;
    switch (joined->state) {
        case PTHREAD_STATE_RUNNING:
            /* The thread is still running, we must wait for it. */
            SCHEDULER_LOCK(intSave);
            ret = OsTaskJoinPendUnsafe(joined->task);
            SCHEDULER_UNLOCK(intSave);
            if (ret != LOS_OK) {
                err = (INT32)ret;
                break;
            }
 
            joined->state = PTHREAD_STATE_ALRDY_JOIN;
            break;
           /*
            * The thread has become unjoinable while we waited, so we
            * fall through to complain.
            */
        case PTHREAD_STATE_FREE:
        case PTHREAD_STATE_DETACHED:
        case PTHREAD_STATE_EXITED:
            /* None of these may be joined. */
            err = EINVAL;
            break;
        case PTHREAD_STATE_ALRDY_JOIN:
            err = EINVAL;
            break;
        case PTHREAD_STATE_JOIN:
            break;
        default:
            PRINT_ERR("state: %u is not supported\n", (UINT32)joined->state);
            break;
    }
    return err;
}

函数调用图:

这是这个函数的调用关系图:

ProcessUnusedStatusTask()

STATIC VOID ProcessUnusedStatusTask

(

_pthread_data *

data

)

在文件 pthread.c 第 108 行定义.

{
    data->state = PTHREAD_STATE_FREE;
    (VOID)memset_s(data, sizeof(_pthread_data), 0, sizeof(_pthread_data));
}

这是这个函数的调用关系图:

pthread_cancel()

int pthread_cancel

(

pthread_t

thread

)

在文件 pthread.c 第 700 行定义.

{
    _pthread_data *data = NULL;
 
    if (pthread_mutex_lock(&g_pthreadsDataMutex) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
 
    data = pthread_get_data(thread);
    if (data == NULL) {
        if (pthread_mutex_unlock(&g_pthreadsDataMutex) != ENOERR) {
            PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
        }
        return ESRCH;
    }
 
    data->canceled = 1;
 
    if ((data->cancelstate == PTHREAD_CANCEL_ENABLE) &&
        (data->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)) {
        /*
         * If the thread has cancellation enabled, and it is in
         * asynchronous mode, suspend it and set corresponding thread's status.
         * We also release the thread out of any current wait to make it wake up.
         */
        if (DoPthreadCancel(data) == LOS_NOK) {
            goto ERROR_OUT;
        }
    }
 
    /*
     * Otherwise the thread has cancellation disabled, in which case
     * it is up to the thread to enable cancellation
     */
    if (pthread_mutex_unlock(&g_pthreadsDataMutex) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
 
    return ENOERR;
ERROR_OUT:
    if (pthread_mutex_unlock(&g_pthreadsDataMutex) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
    return ESRCH;
}

函数调用图:

pthread_cleanup_pop_inner()

void pthread_cleanup_pop_inner	(	struct pthread_cleanup_buffer *	buffer,
		int	execute
	)

在文件 pthread.c 第 787 行定义.

{
    (VOID)buffer;
    (VOID)execute;
    PRINT_ERR("[%s] is not support.\n", __FUNCTION__);
    return;
}

pthread_cleanup_push_inner()

void pthread_cleanup_push_inner	(	struct pthread_cleanup_buffer *	buffer,
		void(*)(void *)	routine,
		void *	arg
	)

在文件 pthread.c 第 777 行定义.

{
    (VOID)buffer;
    (VOID)routine;
    (VOID)arg;
    PRINT_ERR("[%s] is not support.\n", __FUNCTION__);
    return;
}

pthread_create()

int pthread_create	(	pthread_t *	thread,
		const pthread_attr_t *	attr,
		void *(*)(void *)	startRoutine,
		void *	arg
	)

pthread_create
创建线程

参数

arg	传递给线程入口函数的参数
attr	指向线程属性的指针，如果使用 NULL，则使用默认的线程属性
startRoutine	线程入口函数地址
thread	指向线程句柄 (线程标识符) 的指针，不能为 NULL

返回

参见

在文件 pthread.c 第 229 行定义.

{
    pthread_attr_t userAttr;
    UINT32 ret;
    CHAR name[PTHREAD_DATA_NAME_MAX] = {0};
    STATIC UINT16 pthreadNumber = 1;
    TSK_INIT_PARAM_S taskInitParam = {0};//posix线程对标鸿蒙内核的任务
    UINT32 taskHandle;
    _pthread_data *self = pthread_get_self_data();
 
    if ((thread == NULL) || (startRoutine == NULL)) {
        return EINVAL;
    }
 
    SetPthreadAttr(self, attr, &userAttr);//设置线程属性(包括栈信息 ==)
 
    (VOID)snprintf_s(name, sizeof(name), sizeof(name) - 1, "pth%02d", pthreadNumber);
    pthreadNumber++;
 
    taskInitParam.pcName       = name;
    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)startRoutine;//线程入口函数 类似 Java thread 的 run()函数
    taskInitParam.auwArgs[0]   = (UINTPTR)arg;//参数
    taskInitParam.usTaskPrio   = (UINT16)userAttr.schedparam.sched_priority;//任务优先级
    taskInitParam.uwStackSize  = userAttr.stacksize;//栈大小
    if (OsProcessIsUserMode(OsCurrProcessGet())) {//@note_thinking 是不是搞反了 ? 
        taskInitParam.processID = OsGetKernelInitProcessID();//内核进程
    } else {
        taskInitParam.processID = OsCurrProcessGet()->processID;//这里可以看出
    }
    if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {
        taskInitParam.uwResved = LOS_TASK_STATUS_DETACHED;//detached状态的线程，在结束的时候，会自动释放该线程所占用的资源。
    } else {
        /* Set the pthread default joinable */
        taskInitParam.uwResved = LOS_TASK_ATTR_JOINABLE;//如果使用 PTHREAD_CREATE_JOINABLE 创建非分离线程，
    }//则假设应用程序将等待线程完成。也就是说，程序将对线程执行 pthread_join()。
 
    PthreadReap();
    ret = LOS_TaskCreateOnly(&taskHandle, &taskInitParam);//创建线程但不调度
    if (ret == LOS_OK) {
        *thread = (pthread_t)taskHandle;
        ret = InitPthreadData(*thread, &userAttr, name, PTHREAD_DATA_NAME_MAX);
        if (ret != LOS_OK) {
            goto ERROR_OUT_WITH_TASK;
        }
        (VOID)LOS_SetTaskScheduler(taskHandle, SCHED_RR, taskInitParam.usTaskPrio);//设置调度器,等待调度
    }
 
    if (ret == LOS_OK) {
        return ENOERR;
    } else {
        goto ERROR_OUT;
    }
 
ERROR_OUT_WITH_TASK:
    (VOID)LOS_TaskDelete(taskHandle);
ERROR_OUT:
    *thread = (pthread_t)-1;
 
    return map_errno(ret);
}

函数调用图:

这是这个函数的调用关系图:

pthread_detach()

int pthread_detach

(

pthread_t

thread

)

在文件 pthread.c 第 430 行定义.

{
    int ret = 0;
    UINT32 intSave;
 
    _pthread_data *detached = NULL;
 
    if (pthread_mutex_lock(&g_pthreadsDataMutex) != ENOERR) {
        ret = ESRCH;
    }
    detached = pthread_get_data(thread);
    if (detached == NULL) {
        ret = ESRCH; /* No such thread */
    } else if (detached->state == PTHREAD_STATE_DETACHED) {
        ret = EINVAL; /* Already detached! */
    } else if (detached->state == PTHREAD_STATE_JOIN) {
        detached->state = PTHREAD_STATE_EXITED;
        g_pthreadsExited++;
    } else {
        /* Set state to detached and kick any joinees to make them return. */
        SCHEDULER_LOCK(intSave);
        if (!(detached->task->taskStatus & OS_TASK_STATUS_EXIT)) {
            ret = OsTaskSetDetachUnsafe(detached->task);
            if (ret == ESRCH) {
                ret = LOS_OK;
            } else if (ret == LOS_OK) {
                detached->state = PTHREAD_STATE_DETACHED;
            }
        } else {
            detached->state = PTHREAD_STATE_EXITED;
            g_pthreadsExited++;
        }
        SCHEDULER_UNLOCK(intSave);
    }
 
    /* Dispose of any dead threads */
    PthreadReap();
    if (pthread_mutex_unlock(&g_pthreadsDataMutex) != ENOERR) {
        ret = ESRCH;
    }
 
    return ret;
}

函数调用图:

pthread_equal()

int pthread_equal	(	pthread_t	thread1,
		pthread_t	thread2
	)

在文件 pthread.c 第 772 行定义.

{
    return thread1 == thread2;
}

pthread_exit()

void pthread_exit

(

void *

retVal

)

线程退出

在文件 pthread.c 第 291 行定义.

{
    _pthread_data *self = pthread_get_self_data();
    UINT32 intSave;
 
    if (pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, (int *)0) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
 
    if (pthread_mutex_lock(&g_pthreadsDataMutex) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
 
    self->task->joinRetval = retVal;
    /*
     * If we are already detached, go to EXITED state, otherwise
     * go into JOIN state.
     */
    if (self->state == PTHREAD_STATE_DETACHED) {
        self->state = PTHREAD_STATE_EXITED;
        g_pthreadsExited++;
    } else {
        self->state = PTHREAD_STATE_JOIN;
    }
 
    if (pthread_mutex_unlock(&g_pthreadsDataMutex) != ENOERR) {
        PRINT_ERR("%s: %d failed\n", __FUNCTION__, __LINE__);
    }
    SCHEDULER_LOCK(intSave);
    /* If the thread is the highest thread,it can't schedule in LOS_SemPost. */
    OsTaskJoinPostUnsafe(self->task);
    if (self->task->taskStatus & OS_TASK_STATUS_RUNNING) {
        OsSchedResched();
    }
    SCHEDULER_UNLOCK(intSave);
}

函数调用图:

这是这个函数的调用关系图:

pthread_get_data()

_pthread_data * pthread_get_data

(

pthread_t

id

)

获取线程控制块

在文件 pthread.c 第 70 行定义.

{
    _pthread_data *data = NULL;
 
    if (OS_TID_CHECK_INVALID(id)) {
        return NULL;
    }
 
    data = &g_pthreadData[id];
    /* Check that this is a valid entry */
    if ((data->state == PTHREAD_STATE_FREE) || (data->state == PTHREAD_STATE_EXITED)) {
        return NULL;
    }
 
    /* Check that the entry matches the id */
    if (data->id != id) {
        return NULL;
    }
 
    /* Return the pointer */
    return data;
}

这是这个函数的调用关系图:

pthread_get_self_data()

_pthread_data * pthread_get_self_data

(

void

)

在文件 pthread.c 第 62 行定义.

{
    UINT32 runningTaskPID = ((LosTaskCB *)(OsCurrTaskGet()))->taskID;//当前线程
    _pthread_data *data = &g_pthreadData[runningTaskPID];
 
    return data;
}

函数调用图:

这是这个函数的调用关系图:

pthread_getaffinity_np()

int pthread_getaffinity_np	(	pthread_t	thread,
		size_t	cpusetsize,
		cpu_set_t *	cpuset
	)

在文件 pthread.c 第 811 行定义.

{
    INT32 ret = sched_getaffinity(thread, cpusetsize, cpuset);
    if (ret == -1) {
        return errno;
    } else {
        return ENOERR;
    }
}

函数调用图:

pthread_getschedparam()

int pthread_getschedparam	(	pthread_t	thread,
		int *	policy,
		struct sched_param *	param
	)

在文件 pthread.c 第 515 行定义.

{
    _pthread_data *data = NULL;
    int ret;
 
    if ((policy == NULL) || (param == NULL)) {
        return EINVAL;
    }
 
    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    data = pthread_get_data(thread);
    if (data == NULL) {
        goto ERR_OUT;
    }
 
    *policy = data->attr.schedpolicy;
    *param = data->attr.schedparam;
 
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    return ret;
ERR_OUT:
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
    return ESRCH;
}

函数调用图:

pthread_getspecific()

void * pthread_getspecific

(

pthread_key_t

key

)

在文件 pthread.c 第 597 行定义.

{
    (VOID)key;
    PRINT_ERR("[%s] is not support.\n", __FUNCTION__);
    return NULL;
}

pthread_join()

int pthread_join	(	pthread_t	thread,
		void **	retVal
	)

在文件 pthread.c 第 368 行定义.

{
    INT32 err;
    UINT8 status;
    _pthread_data *self = NULL;
    _pthread_data *joined = NULL;
 
    /* Check for cancellation first. */
    pthread_testcancel();
 
    /* Dispose of any dead threads */
    (VOID)pthread_mutex_lock(&g_pthreadsDataMutex);
    PthreadReap();
    (VOID)pthread_mutex_unlock(&g_pthreadsDataMutex);
 
    self   = pthread_get_self_data();
    joined = pthread_get_data(thread);
    if (joined == NULL) {
        return ESRCH;
    }
    status = joined->state;
 
    if (joined == self) {
        return EDEADLK;
    }
 
    err = ProcessByJoinState(joined);
    (VOID)pthread_mutex_lock(&g_pthreadsDataMutex);
 
    if (!err) {
        /*
         * Here, we know that joinee is a thread that has exited and is
         * ready to be joined.
         */
        if (retVal != NULL) {
            /* Get the retVal */
            *retVal = joined->task->joinRetval;
        }
 
        /* Set state to exited. */
        joined->state = PTHREAD_STATE_EXITED;
        g_pthreadsExited++;
 
        /* Dispose of any dead threads */
        PthreadReap();
    } else {
        joined->state = status;
    }
 
    (VOID)pthread_mutex_unlock(&g_pthreadsDataMutex);
    /* Check for cancellation before returning */
    pthread_testcancel();
 
    return err;
}

函数调用图:

pthread_key_create()

int pthread_key_create	(	pthread_key_t *	key,
		void(*)(void *)	destructor
	)

在文件 pthread.c 第 579 行定义.

{
    (VOID)key;
    (VOID)destructor;
    PRINT_ERR("[%s] is not support.\n", __FUNCTION__);
    return 0;
}

pthread_once()

int pthread_once	(	pthread_once_t *	onceControl,
		void(*)(void)	initRoutine
	)

在文件 pthread.c 第 548 行定义.

{
    pthread_once_t old;
    int ret;
 
    if ((onceControl == NULL) || (initRoutine == NULL)) {
        return EINVAL;
    }
 
    /* Do a test and set on the onceControl object. */
    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    old = *onceControl;
    *onceControl = 1;
 
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
    /* If the onceControl was zero, call the initRoutine(). */
    if (!old) {
        initRoutine();
    }
 
    return ENOERR;
}

函数调用图:

pthread_self()

pthread_t pthread_self

(

void

)

在文件 pthread.c 第 764 行定义.

{
    _pthread_data *data = pthread_get_self_data();
 
    return data->id;
}

函数调用图:

这是这个函数的调用关系图:

pthread_setaffinity_np()

int pthread_setaffinity_np	(	pthread_t	thread,
		size_t	cpusetsize,
		const cpu_set_t *	cpuset
	)

在文件 pthread.c 第 798 行定义.

{
    INT32 ret = sched_setaffinity(thread, cpusetsize, cpuset);
    if (ret == -1) {
        return errno;
    } else {
        return ENOERR;
    }
}

函数调用图:

pthread_setcancelstate()

int pthread_setcancelstate	(	int	state,
		int *	oldState
	)

在文件 pthread.c 第 608 行定义.

{
    _pthread_data *self = NULL;
    int ret;
 
    if ((state != PTHREAD_CANCEL_ENABLE) && (state != PTHREAD_CANCEL_DISABLE)) {
        return EINVAL;
    }
 
    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    self = pthread_get_self_data();
 
    if (oldState != NULL) {
        *oldState = self->cancelstate;
    }
 
    self->cancelstate = (UINT8)state;
 
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    return ENOERR;
}

函数调用图:

这是这个函数的调用关系图:

pthread_setcanceltype()

int pthread_setcanceltype	(	int	type,
		int *	oldType
	)

在文件 pthread.c 第 642 行定义.

{
    _pthread_data *self = NULL;
    int ret;
 
    if ((type != PTHREAD_CANCEL_ASYNCHRONOUS) && (type != PTHREAD_CANCEL_DEFERRED)) {
        return EINVAL;
    }
 
    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    self = pthread_get_self_data();
    if (oldType != NULL) {
        *oldType = self->canceltype;
    }
 
    self->canceltype = (UINT8)type;
 
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    return ENOERR;
}

函数调用图:

pthread_setschedparam()

int pthread_setschedparam	(	pthread_t	thread,
		int	policy,
		const struct sched_param *	param
	)

设置调度参数

在文件 pthread.c 第 474 行定义.

{
    _pthread_data *data = NULL;
    int ret;
 
    if ((param == NULL) || (param->sched_priority > OS_TASK_PRIORITY_LOWEST)) {
        return EINVAL;
    }
 
    if (policy != SCHED_RR) {
        return EINVAL;
    }
 
    /* The parameters seem OK, change the thread. */
    ret = pthread_mutex_lock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
 
    data = pthread_get_data(thread);
    if (data == NULL) {
        ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
        if (ret != ENOERR) {
            return ret;
        }
        return ESRCH;
    }
 
    /* Only support one policy now */
    data->attr.schedpolicy = SCHED_RR;
    data->attr.schedparam  = *param;
 
    ret = pthread_mutex_unlock(&g_pthreadsDataMutex);
    if (ret != ENOERR) {
        return ret;
    }
    (VOID)LOS_TaskPriSet((UINT32)thread, (UINT16)param->sched_priority);
 
    return ENOERR;
}

函数调用图:

pthread_setspecific()

int pthread_setspecific	(	pthread_key_t	key,
		const void *	pointer
	)

在文件 pthread.c 第 588 行定义.

{
    (VOID)key;
    (VOID)pointer;
    PRINT_ERR("[%s] is not support.\n", __FUNCTION__);
    return 0;
}

pthread_testcancel()

void pthread_testcancel

(

void

)

在文件 pthread.c 第 750 行定义.

{
    if (CheckForCancel()) {
        /*
         * If we have cancellation enabled, and there is a cancellation
         * pending, then go ahead and do the deed.
         * Exit now with special retVal. pthread_exit() calls the
         * cancellation handlers implicitly.
         */
        pthread_exit((void *)PTHREAD_CANCELED);
    }
}

函数调用图:

这是这个函数的调用关系图:

PthreadReap()

STATIC VOID PthreadReap

(

VOID

)

在文件 pthread.c 第 119 行定义.

{
    UINT32 i;
    _pthread_data *data = NULL;
    /*
     * Loop over the thread table looking for exited threads. The
     * g_pthreadsExited counter springs us out of this once we have
     * found them all (and keeps us out if there are none to do).
     */
    for (i = 0; g_pthreadsExited && (i < g_taskMaxNum); i++) {
        data = &g_pthreadData[i];
        if (data->state == PTHREAD_STATE_EXITED) {
            /* the Huawei LiteOS not delete the dead TCB,so need to delete the TCB */
            (VOID)LOS_TaskDelete(data->task->taskID);
            if (data->task->taskStatus & OS_TASK_STATUS_UNUSED) {
                ProcessUnusedStatusTask(data);
                g_pthreadsExited--;
            }
        }
    }
}

函数调用图:

这是这个函数的调用关系图:

SetPthreadAttr()

STATIC VOID SetPthreadAttr	(	const _pthread_data *	self,
		const pthread_attr_t *	attr,
		pthread_attr_t *	outAttr
	)

设置线程的属性

在文件 pthread.c 第 141 行定义.

{
    /*
     * Set use_attr to the set of attributes we are going to
     * actually use. Either those passed in, or the default set.
     */
    if (attr == NULL) {
        (VOID)pthread_attr_init(outAttr);
    } else {
        (VOID)memcpy_s(outAttr, sizeof(pthread_attr_t), attr, sizeof(pthread_attr_t));
    }
 
    /*
     * If the stack size is not valid, we can assume that it is at
     * least PTHREAD_STACK_MIN bytes.
     */
    if (!outAttr->stacksize_set) {
        outAttr->stacksize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
    }
    if (outAttr->inheritsched == PTHREAD_INHERIT_SCHED) {
        if (self->task == NULL) {
            outAttr->schedparam.sched_priority = LOS_TaskPriGet(OsCurrTaskGet()->taskID);
        } else {
            outAttr->schedpolicy = self->attr.schedpolicy;
            outAttr->schedparam  = self->attr.schedparam;
            outAttr->scope       = self->attr.scope;
        }
    }
}

函数调用图:

这是这个函数的调用关系图:

SetPthreadDataAttr()

STATIC VOID SetPthreadDataAttr	(	const pthread_attr_t *	userAttr,
		const pthread_t	threadID,
		LosTaskCB *	taskCB,
		_pthread_data *	created
	)

在文件 pthread.c 第 171 行定义.

{
    created->attr         = *userAttr;
    created->id           = threadID;
    created->task         = taskCB;
    created->state        = (userAttr->detachstate == PTHREAD_CREATE_JOINABLE) ?
                            PTHREAD_STATE_RUNNING : PTHREAD_STATE_DETACHED;
    /* need to confirmation */
    created->cancelstate  = PTHREAD_CANCEL_ENABLE;
    created->canceltype   = PTHREAD_CANCEL_DEFERRED;
    created->cancelbuffer = NULL;
    created->canceled     = 0;
    created->freestack    = 0; /* no use default : 0 */
    created->stackmem     = taskCB->topOfStack;
    created->thread_data  = NULL;
}

这是这个函数的调用关系图:

变量说明

g_pthreadCanceledDummyVar

UINTPTR g_pthreadCanceledDummyVar

在文件 pthread.c 第 56 行定义.

g_pthreadData

STATIC _pthread_data g_pthreadData[LOSCFG_BASE_CORE_TSK_LIMIT+1]

在文件 pthread.c 第 47 行定义.

g_pthreadsDataMutex

STATIC pthread_mutex_t g_pthreadsDataMutex = PTHREAD_MUTEX_INITIALIZER

在文件 pthread.c 第 53 行定义.

g_pthreadsExited

STATIC INT32 g_pthreadsExited = 0

在文件 pthread.c 第 50 行定义.