diff --git a/include/os/osThread.h b/include/os/osThread.h index 8a0ace3e77df6f302a23241c7c3dc949df206c26..cca25f4fa4d31a77df0323a2a0d3f0c07e5bc4f4 100644 --- a/include/os/osThread.h +++ b/include/os/osThread.h @@ -42,81 +42,189 @@ typedef pthread_barrierattr_t TdThreadBarrierAttr; // If the error is in a third-party library, place this header file under the third-party library header file. // When you want to use this feature, you should find or add the same function in the following section. #ifndef ALLOW_FORBID_FUNC - #define pthread_t PTHREAD_T_TYPE_TAOS_FORBID - #define pthread_spinlock_t PTHREAD_SPINLOCK_T_TYPE_TAOS_FORBID - #define pthread_mutex_t PTHREAD_MUTEX_T_TYPE_TAOS_FORBID - #define pthread_mutexattr_t PTHREAD_MUTEXATTR_T_TYPE_TAOS_FORBID - #define pthread_rwlock_t PTHREAD_RWLOCK_T_TYPE_TAOS_FORBID - #define pthread_attr_t PTHREAD_ATTR_T_TYPE_TAOS_FORBID - #define pthread_once_t PTHREAD_ONCE_T_TYPE_TAOS_FORBID - #define pthread_rwlockattr_t PTHREAD_RWLOCKATTR_T_TYPE_TAOS_FORBID - #define pthread_cond_t PTHREAD_COND_T_TYPE_TAOS_FORBID - #define pthread_condattr_t PTHREAD_CONDATTR_T_TYPE_TAOS_FORBID - #define pthread_spin_init PTHREAD_SPIN_INIT_FUNC_TAOS_FORBID - #define pthread_mutex_init PTHREAD_MUTEX_INIT_FUNC_TAOS_FORBID - #define pthread_spin_destroy PTHREAD_SPIN_DESTROY_FUNC_TAOS_FORBID - #define pthread_mutex_destroy PTHREAD_MUTEX_DESTROY_FUNC_TAOS_FORBID - #define pthread_spin_lock PTHREAD_SPIN_LOCK_FUNC_TAOS_FORBID - #define pthread_mutex_lock PTHREAD_MUTEX_LOCK_FUNC_TAOS_FORBID - #define pthread_spin_unlock PTHREAD_SPIN_UNLOCK_FUNC_TAOS_FORBID - #define pthread_mutex_unlock PTHREAD_MUTEX_UNLOCK_FUNC_TAOS_FORBID - #define pthread_rwlock_rdlock PTHREAD_RWLOCK_RDLOCK_FUNC_TAOS_FORBID - #define pthread_rwlock_wrlock PTHREAD_RWLOCK_WRLOCK_FUNC_TAOS_FORBID - #define pthread_rwlock_unlock PTHREAD_RWLOCK_UNLOCK_FUNC_TAOS_FORBID - #define pthread_testcancel PTHREAD_TESTCANCEL_FUNC_TAOS_FORBID - #define pthread_attr_init PTHREAD_ATTR_INIT_FUNC_TAOS_FORBID - #define pthread_create PTHREAD_CREATE_FUNC_TAOS_FORBID - #define pthread_once PTHREAD_ONCE_FUNC_TAOS_FORBID - #define pthread_attr_setdetachstate PTHREAD_ATTR_SETDETACHSTATE_FUNC_TAOS_FORBID - #define pthread_attr_destroy PTHREAD_ATTR_DESTROY_FUNC_TAOS_FORBID - #define pthread_join PTHREAD_JOIN_FUNC_TAOS_FORBID - #define pthread_rwlock_init PTHREAD_RWLOCK_INIT_FUNC_TAOS_FORBID - #define pthread_rwlock_destroy PTHREAD_RWLOCK_DESTROY_FUNC_TAOS_FORBID - #define pthread_cond_signal PTHREAD_COND_SIGNAL_FUNC_TAOS_FORBID - #define pthread_cond_init PTHREAD_COND_INIT_FUNC_TAOS_FORBID - #define pthread_cond_broadcast PTHREAD_COND_BROADCAST_FUNC_TAOS_FORBID - #define pthread_cond_destroy PTHREAD_COND_DESTROY_FUNC_TAOS_FORBID - #define pthread_cond_wait PTHREAD_COND_WAIT_FUNC_TAOS_FORBID - #define pthread_self PTHREAD_SELF_FUNC_TAOS_FORBID - #define pthread_equal PTHREAD_EQUAL_FUNC_TAOS_FORBID - #define pthread_sigmask PTHREAD_SIGMASK_FUNC_TAOS_FORBID - #define pthread_cancel PTHREAD_CANCEL_FUNC_TAOS_FORBID - #define pthread_kill PTHREAD_KILL_FUNC_TAOS_FORBID - #define pthread_setname_np PTHREAD_SETNAME_FUNC_TAOS_FORBID + // #define pthread_t PTHREAD_T_TYPE_TAOS_FORBID + // #define pthread_spinlock_t PTHREAD_SPINLOCK_T_TYPE_TAOS_FORBID + // #define pthread_mutex_t PTHREAD_MUTEX_T_TYPE_TAOS_FORBID + // #define pthread_mutexattr_t PTHREAD_MUTEXATTR_T_TYPE_TAOS_FORBID + // #define pthread_rwlock_t PTHREAD_RWLOCK_T_TYPE_TAOS_FORBID + // #define pthread_attr_t PTHREAD_ATTR_T_TYPE_TAOS_FORBID + // #define pthread_once_t PTHREAD_ONCE_T_TYPE_TAOS_FORBID + // #define pthread_rwlockattr_t PTHREAD_RWLOCKATTR_T_TYPE_TAOS_FORBID + // #define pthread_cond_t PTHREAD_COND_T_TYPE_TAOS_FORBID + // #define pthread_condattr_t PTHREAD_CONDATTR_T_TYPE_TAOS_FORBID + // #define pthread_key_t PTHREAD_KEY_T_TYPE_TAOS_FORBID + // #define pthread_barrier_t PTHREAD_BARRIER_T_TYPE_TAOS_FORBID + // #define pthread_barrierattr_t PTHREAD_BARRIERATTR_T_TYPE_TAOS_FORBID + // #define pthread_create PTHREAD_CREATE_FUNC_TAOS_FORBID + // #define pthread_attr_destroy PTHREAD_ATTR_DESTROY_FUNC_TAOS_FORBID + // #define pthread_attr_getdetachstate PTHREAD_ATTR_GETDETACHSTATE_FUNC_TAOS_FORBID + // #define pthread_attr_getinheritsched PTHREAD_ATTR_GETINHERITSCHED_FUNC_TAOS_FORBID + // #define pthread_attr_getschedparam PTHREAD_ATTR_GETSCHEDPARAM_FUNC_TAOS_FORBID + // #define pthread_attr_getschedpolicy PTHREAD_ATTR_GETSCHEDPOLICY_FUNC_TAOS_FORBID + // #define pthread_attr_getscope PTHREAD_ATTR_GETSCOPE_FUNC_TAOS_FORBID + // #define pthread_attr_getstacksize PTHREAD_ATTR_GETSTACKSIZE_FUNC_TAOS_FORBID + // #define pthread_attr_init PTHREAD_ATTR_INIT_FUNC_TAOS_FORBID + // #define pthread_attr_setdetachstate PTHREAD_ATTR_SETDETACHSTATE_FUNC_TAOS_FORBID + // #define pthread_attr_setinheritsched PTHREAD_ATTR_SETINHERITSCHED_FUNC_TAOS_FORBID + // #define pthread_attr_setschedparam PTHREAD_ATTR_SETSCHEDPARAM_FUNC_TAOS_FORBID + // #define pthread_attr_setschedpolicy PTHREAD_ATTR_SETSCHEDPOLICY_FUNC_TAOS_FORBID + // #define pthread_attr_setscope PTHREAD_ATTR_SETSCOPE_FUNC_TAOS_FORBID + // #define pthread_attr_setstacksize PTHREAD_ATTR_SETSTACKSIZE_FUNC_TAOS_FORBID + // #define pthread_barrier_destroy PTHREAD_BARRIER_DESTROY_FUNC_TAOS_FORBID + // #define pthread_barrier_init PTHREAD_BARRIER_INIT_FUNC_TAOS_FORBID + // #define pthread_barrier_wait PTHREAD_BARRIER_WAIT_FUNC_TAOS_FORBID + // #define pthread_barrierattr_destroy PTHREAD_BARRIERATTR_DESTROY_FUNC_TAOS_FORBID + // #define pthread_barrierattr_getpshared PTHREAD_BARRIERATTR_GETPSHARED_FUNC_TAOS_FORBID + // #define pthread_barrierattr_init PTHREAD_BARRIERATTR_INIT_FUNC_TAOS_FORBID + // #define pthread_barrierattr_setpshared PTHREAD_BARRIERATTR_SETPSHARED_FUNC_TAOS_FORBID + // #define pthread_cancel PTHREAD_CANCEL_FUNC_TAOS_FORBID + // #define pthread_cond_destroy PTHREAD_COND_DESTROY_FUNC_TAOS_FORBID + // #define pthread_cond_init PTHREAD_COND_INIT_FUNC_TAOS_FORBID + // #define pthread_cond_signal PTHREAD_COND_SIGNAL_FUNC_TAOS_FORBID + // #define pthread_cond_broadcast PTHREAD_COND_BROADCAST_FUNC_TAOS_FORBID + // #define pthread_cond_wait PTHREAD_COND_WAIT_FUNC_TAOS_FORBID + // #define pthread_cond_timedwait PTHREAD_COND_TIMEDWAIT_FUNC_TAOS_FORBID + // #define pthread_condattr_destroy PTHREAD_CONDATTR_DESTROY_FUNC_TAOS_FORBID + // #define pthread_condattr_getpshared PTHREAD_CONDATTR_GETPSHARED_FUNC_TAOS_FORBID + // #define pthread_condattr_init PTHREAD_CONDATTR_INIT_FUNC_TAOS_FORBID + // #define pthread_condattr_setpshared PTHREAD_CONDATTR_SETPSHARED_FUNC_TAOS_FORBID + // #define pthread_detach PTHREAD_DETACH_FUNC_TAOS_FORBID + // #define pthread_equal PTHREAD_EQUAL_FUNC_TAOS_FORBID + // #define pthread_exit PTHREAD_EXIT_FUNC_TAOS_FORBID + // #define pthread_getschedparam PTHREAD_GETSCHEDPARAM_FUNC_TAOS_FORBID + // #define pthread_getspecific PTHREAD_GETSPECIFIC_FUNC_TAOS_FORBID + // #define pthread_join PTHREAD_JOIN_FUNC_TAOS_FORBID + // #define pthread_key_create PTHREAD_KEY_CREATE_FUNC_TAOS_FORBID + // #define pthread_key_delete PTHREAD_KEY_DELETE_FUNC_TAOS_FORBID + // #define pthread_kill PTHREAD_KILL_FUNC_TAOS_FORBID + // #define pthread_mutex_consistent PTHREAD_MUTEX_CONSISTENT_FUNC_TAOS_FORBID + // #define pthread_mutex_destroy PTHREAD_MUTEX_DESTROY_FUNC_TAOS_FORBID + // #define pthread_mutex_init PTHREAD_MUTEX_INIT_FUNC_TAOS_FORBID + // #define pthread_mutex_lock PTHREAD_MUTEX_LOCK_FUNC_TAOS_FORBID + // #define pthread_mutex_timedlock PTHREAD_MUTEX_TIMEDLOCK_FUNC_TAOS_FORBID + // #define pthread_mutex_trylock PTHREAD_MUTEX_TRYLOCK_FUNC_TAOS_FORBID + // #define pthread_mutex_unlock PTHREAD_MUTEX_UNLOCK_FUNC_TAOS_FORBID + // #define pthread_mutexattr_destroy PTHREAD_MUTEXATTR_DESTROY_FUNC_TAOS_FORBID + // #define pthread_mutexattr_getpshared PTHREAD_MUTEXATTR_GETPSHARED_FUNC_TAOS_FORBID + // #define pthread_mutexattr_getrobust PTHREAD_MUTEXATTR_GETROBUST_FUNC_TAOS_FORBID + // #define pthread_mutexattr_gettype PTHREAD_MUTEXATTR_GETTYPE_FUNC_TAOS_FORBID + // #define pthread_mutexattr_init PTHREAD_MUTEXATTR_INIT_FUNC_TAOS_FORBID + // #define pthread_mutexattr_setpshared PTHREAD_MUTEXATTR_SETPSHARED_FUNC_TAOS_FORBID + // #define pthread_mutexattr_setrobust PTHREAD_MUTEXATTR_SETROBUST_FUNC_TAOS_FORBID + // #define pthread_mutexattr_settype PTHREAD_MUTEXATTR_SETTYPE_FUNC_TAOS_FORBID + // #define pthread_once PTHREAD_ONCE_FUNC_TAOS_FORBID + // #define pthread_rwlock_destroy PTHREAD_RWLOCK_DESTROY_FUNC_TAOS_FORBID + // #define pthread_rwlock_init PTHREAD_RWLOCK_INIT_FUNC_TAOS_FORBID + // #define pthread_rwlock_rdlock PTHREAD_RWLOCK_RDLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_timedrdlock PTHREAD_RWLOCK_TIMEDRDLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_timedwrlock PTHREAD_RWLOCK_TIMEDWRLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_tryrdlock PTHREAD_RWLOCK_TRYRDLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_trywrlock PTHREAD_RWLOCK_TRYWRLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_unlock PTHREAD_RWLOCK_UNLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlock_wrlock PTHREAD_RWLOCK_WRLOCK_FUNC_TAOS_FORBID + // #define pthread_rwlockattr_destroy PTHREAD_RWLOCKATTR_DESTROY_FUNC_TAOS_FORBID + // #define pthread_rwlockattr_getpshared PTHREAD_RWLOCKATTR_GETPSHARED_FUNC_TAOS_FORBID + // #define pthread_rwlockattr_init PTHREAD_RWLOCKATTR_INIT_FUNC_TAOS_FORBID + // #define pthread_rwlockattr_setpshared PTHREAD_RWLOCKATTR_SETPSHARED_FUNC_TAOS_FORBID + // #define pthread_self PTHREAD_SELF_FUNC_TAOS_FORBID + // #define pthread_setcancelstate PTHREAD_SETCANCELSTATE_FUNC_TAOS_FORBID + // #define pthread_setcanceltype PTHREAD_SETCANCELTYPE_FUNC_TAOS_FORBID + // #define pthread_setschedparam PTHREAD_SETSCHEDPARAM_FUNC_TAOS_FORBID + // #define pthread_setspecific PTHREAD_SETSPECIFIC_FUNC_TAOS_FORBID + // #define pthread_spin_destroy PTHREAD_SPIN_DESTROY_FUNC_TAOS_FORBID + // #define pthread_spin_init PTHREAD_SPIN_INIT_FUNC_TAOS_FORBID + // #define pthread_spin_lock PTHREAD_SPIN_LOCK_FUNC_TAOS_FORBID + // #define pthread_spin_trylock PTHREAD_SPIN_TRYLOCK_FUNC_TAOS_FORBID + // #define pthread_spin_unlock PTHREAD_SPIN_UNLOCK_FUNC_TAOS_FORBID + // #define pthread_testcancel PTHREAD_TESTCANCEL_FUNC_TAOS_FORBID + // #define pthread_sigmask PTHREAD_SIGMASK_FUNC_TAOS_FORBID + // #define sigwait SIGWAIT_FUNC_TAOS_FORBID #endif -int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int pshared); -int32_t taosThreadMutexInit(TdThreadMutex *mutex, const TdThreadMutexAttr *attr); -int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock); -int32_t taosThreadMutexDestroy(TdThreadMutex * mutex); -int32_t taosThreadSpinLock(TdThreadSpinlock *lock); -int32_t taosThreadSpinTryLock(TdThreadSpinlock *lock); -int32_t taosThreadMutexLock(TdThreadMutex *mutex); -int32_t taosThreadRwlockRdlock(TdThreadRwlock *rwlock); -int32_t taosThreadSpinUnlock(TdThreadSpinlock *lock); -int32_t taosThreadMutexUnlock(TdThreadMutex *mutex); -int32_t taosThreadRwlockWrlock(TdThreadRwlock *rwlock); -int32_t taosThreadRwlockUnlock(TdThreadRwlock *rwlock); -void taosThreadTestCancel(void); -int32_t taosThreadAttrInit(TdThreadAttr *attr); -int32_t taosThreadCreate(TdThread *tid, const TdThreadAttr *attr, void*(*start)(void*), void *arg); -int32_t taosThreadOnce(TdThreadOnce *onceControl, void(*initRoutine)(void)); -int32_t taosThreadAttrSetDetachState(TdThreadAttr *attr, int32_t detachState); -int32_t taosThreadAttrDestroy(TdThreadAttr *attr); -int32_t taosThreadJoin(TdThread thread, void **pValue); -int32_t taosThreadRwlockInit(TdThreadRwlock *rwlock, const TdThreadRwlockAttr *attr); -int32_t taosThreadRwlockDestroy(TdThreadRwlock *rwlock); -int32_t taosThreadCondSignal(TdThreadCond *cond); -int32_t taosThreadCondInit(TdThreadCond *cond, const TdThreadCondAttr *attr); -int32_t taosThreadCondBroadcast(TdThreadCond *cond); -int32_t taosThreadCondDestroy(TdThreadCond *cond); -int32_t taosThreadCondWait(TdThreadCond *cond, TdThreadMutex *mutex); -TdThread taosThreadSelf(void); -int32_t taosThreadEqual(TdThread t1, TdThread t2); -int32_t taosThreadSigmask(int how, sigset_t const *set, sigset_t *oset); +int32_t taosThreadCreate(TdThread * tid, const TdThreadAttr * attr, void *(*start)(void *), void *arg); +int32_t taosThreadAttrDestroy(TdThreadAttr * attr); +int32_t taosThreadAttrGetDetachState(const TdThreadAttr * attr, int32_t *detachstate); +int32_t taosThreadAttrGetInheritSched(const TdThreadAttr * attr, int32_t *inheritsched); +int32_t taosThreadAttrGetSchedParam(const TdThreadAttr * attr, struct sched_param *param); +int32_t taosThreadAttrGetSchedPolicy(const TdThreadAttr * attr, int32_t *policy); +int32_t taosThreadAttrGetScope(const TdThreadAttr * attr, int32_t *contentionscope); +int32_t taosThreadAttrGetStackSize(const TdThreadAttr * attr, size_t * stacksize); +int32_t taosThreadAttrInit(TdThreadAttr * attr); +int32_t taosThreadAttrSetDetachState(TdThreadAttr * attr, int32_t detachstate); +int32_t taosThreadAttrSetInheritSched(TdThreadAttr * attr, int32_t inheritsched); +int32_t taosThreadAttrSetSchedParam(TdThreadAttr * attr, const struct sched_param *param); +int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr * attr, int32_t policy); +int32_t taosThreadAttrSetScope(TdThreadAttr * attr, int32_t contentionscope); +int32_t taosThreadAttrSetStackSize(TdThreadAttr * attr, size_t stacksize); +int32_t taosThreadBarrierDestroy(TdThreadBarrier * barrier); +int32_t taosThreadBarrierInit(TdThreadBarrier * barrier, const TdThreadBarrierAttr * attr, uint32_t count); +int32_t taosThreadBarrierWait(TdThreadBarrier * barrier); +int32_t taosThreadBarrierAttrDestroy(TdThreadBarrierAttr * attr); +int32_t taosThreadBarrierAttrGetPshared(const TdThreadBarrierAttr * attr, int32_t *pshared); +int32_t taosThreadBarrierAttrInit(TdThreadBarrierAttr * attr); +int32_t taosThreadBarrierAttrSetPshared(TdThreadBarrierAttr * attr, int32_t pshared); int32_t taosThreadCancel(TdThread thread); -int32_t taosThreadKill(TdThread thread, int sig); +int32_t taosThreadCondDestroy(TdThreadCond * cond); +int32_t taosThreadCondInit(TdThreadCond * cond, const TdThreadCondAttr * attr); +int32_t taosThreadCondSignal(TdThreadCond * cond); +int32_t taosThreadCondBroadcast(TdThreadCond * cond); +int32_t taosThreadCondWait(TdThreadCond * cond, TdThreadMutex * mutex); +int32_t taosThreadCondTimedWait(TdThreadCond * cond, TdThreadMutex * mutex, const struct timespec *abstime); +int32_t taosThreadCondAttrDestroy(TdThreadCondAttr * attr); +int32_t taosThreadCondAttrGetPshared(const TdThreadCondAttr * attr, int32_t *pshared); +int32_t taosThreadCondAttrInit(TdThreadCondAttr * attr); +int32_t taosThreadCondAttrSetPshared(TdThreadCondAttr * attr, int32_t pshared); int32_t taosThreadDetach(TdThread thread); +int32_t taosThreadEqual(TdThread t1, TdThread t2); +void taosThreadExit(void *valuePtr); +int32_t taosThreadGetSchedParam(TdThread thread, int32_t *policy, struct sched_param *param); +void *taosThreadGetSpecific(TdThreadKey key); +int32_t taosThreadJoin(TdThread thread, void **valuePtr); +int32_t taosThreadKeyCreate(TdThreadKey * key, void(*destructor)(void *)); +int32_t taosThreadKeyDelete(TdThreadKey key); +int32_t taosThreadKill(TdThread thread, int32_t sig); +int32_t taosThreadMutexConsistent(TdThreadMutex* mutex); +int32_t taosThreadMutexDestroy(TdThreadMutex * mutex); +int32_t taosThreadMutexInit(TdThreadMutex * mutex, const TdThreadMutexAttr * attr); +int32_t taosThreadMutexLock(TdThreadMutex * mutex); +int32_t taosThreadMutexTimedLock(TdThreadMutex * mutex, const struct timespec *abstime); +int32_t taosThreadMutexTryLock(TdThreadMutex * mutex); +int32_t taosThreadMutexUnlock(TdThreadMutex * mutex); +int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr * attr); +int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr * attr, int32_t *pshared); +int32_t taosThreadMutexAttrGetRobust(const TdThreadMutexAttr * attr, int32_t * robust); +int32_t taosThreadMutexAttrGetType(const TdThreadMutexAttr * attr, int32_t *kind); +int32_t taosThreadMutexAttrInit(TdThreadMutexAttr * attr); +int32_t taosThreadMutexAttrSetPshared(TdThreadMutexAttr * attr, int32_t pshared); +int32_t taosThreadMutexAttrSetRobust(TdThreadMutexAttr * attr, int32_t robust); +int32_t taosThreadMutexAttrSetType(TdThreadMutexAttr * attr, int32_t kind); +int32_t taosThreadOnce(TdThreadOnce * onceControl, void(*initRoutine)(void)); +int32_t taosThreadRwlockDestroy(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockInit(TdThreadRwlock * rwlock, const TdThreadRwlockAttr * attr); +int32_t taosThreadRwlockRdlock(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockTimedRdlock(TdThreadRwlock * rwlock, const struct timespec *abstime); +int32_t taosThreadRwlockTimedWrlock(TdThreadRwlock * rwlock, const struct timespec *abstime); +int32_t taosThreadRwlockTryRdlock(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockTryWrlock(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockUnlock(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockWrlock(TdThreadRwlock * rwlock); +int32_t taosThreadRwlockAttrDestroy(TdThreadRwlockAttr * attr); +int32_t taosThreadRwlockAttrGetPshared(const TdThreadRwlockAttr * attr, int32_t *pshared); +int32_t taosThreadRwlockAttrInit(TdThreadRwlockAttr * attr); +int32_t taosThreadRwlockAttrSetPshared(TdThreadRwlockAttr * attr, int32_t pshared); +TdThread taosThreadSelf(void); +int32_t taosThreadSetCancelState(int32_t state, int32_t *oldstate); +int32_t taosThreadSetCancelType(int32_t type, int32_t *oldtype); +int32_t taosThreadSetSchedParam(TdThread thread, int32_t policy, const struct sched_param *param); +int32_t taosThreadSetSpecific(TdThreadKey key, const void *value); +int32_t taosThreadSpinDestroy(TdThreadSpinlock * lock); +int32_t taosThreadSpinInit(TdThreadSpinlock * lock, int32_t pshared); +int32_t taosThreadSpinLock(TdThreadSpinlock * lock); +int32_t taosThreadSpinTrylock(TdThreadSpinlock * lock); +int32_t taosThreadSpinUnlock(TdThreadSpinlock * lock); +void taosThreadTestCancel(void); +int32_t taosThreadSigMask(int32_t how, sigset_t const *set, sigset_t * oset); +int32_t taosThreadSigWait(const sigset_t * set, int32_t *sig); #ifdef __cplusplus } diff --git a/source/os/src/osSocket.c b/source/os/src/osSocket.c index b130689d4b5aa7bba55d341796cf6416594209d5..d79d7c3d580b53f3de9a1829afee9fe4f40c6892 100644 --- a/source/os/src/osSocket.c +++ b/source/os/src/osSocket.c @@ -758,7 +758,7 @@ void taosBlockSIGPIPE() { sigset_t signal_mask; sigemptyset(&signal_mask); sigaddset(&signal_mask, SIGPIPE); - int32_t rc = taosThreadSigmask(SIG_BLOCK, &signal_mask, NULL); + int32_t rc = taosThreadSigMask(SIG_BLOCK, &signal_mask, NULL); if (rc != 0) { // printf("failed to block SIGPIPE"); } @@ -876,7 +876,7 @@ void taosSetMaskSIGPIPE() { sigset_t signal_mask; sigemptyset(&signal_mask); sigaddset(&signal_mask, SIGPIPE); - int32_t rc = taosThreadSigmask(SIG_SETMASK, &signal_mask, NULL); + int32_t rc = taosThreadSigMask(SIG_SETMASK, &signal_mask, NULL); if (rc != 0) { // printf("failed to setmask SIGPIPE"); } diff --git a/source/os/src/osThread.c b/source/os/src/osThread.c index 386534500f980ffeffcbce7ed6b7f04d81b74265..436614ad6a4fa7ff23187f0f2f2b67dd835f9499 100644 --- a/source/os/src/osThread.c +++ b/source/os/src/osThread.c @@ -17,138 +17,338 @@ #include #include "os.h" -// int32_t taosThreadSetnameNp(TdThread thread, const char *name) { -// return pthread_setname_np(thread,name); -// } +int32_t taosThreadCreate(TdThread * tid, const TdThreadAttr * attr, void *(*start)(void *), void *arg) { + return pthread_create(tid, attr, start, arg); +} + +int32_t taosThreadAttrDestroy(TdThreadAttr * attr) { + return pthread_attr_destroy(attr); +} + +int32_t taosThreadAttrGetDetachState(const TdThreadAttr * attr, int32_t *detachstate) { + return pthread_attr_getdetachstate(attr, detachstate); +} + +int32_t taosThreadAttrGetInheritSched(const TdThreadAttr * attr, int32_t *inheritsched) { + return pthread_attr_getinheritsched(attr, inheritsched); +} + +int32_t taosThreadAttrGetSchedParam(const TdThreadAttr * attr, struct sched_param *param) { + return pthread_attr_getschedparam(attr, param); +} + +int32_t taosThreadAttrGetSchedPolicy(const TdThreadAttr * attr, int32_t *policy) { + return pthread_attr_getschedpolicy(attr, policy); +} + +int32_t taosThreadAttrGetScope(const TdThreadAttr * attr, int32_t *contentionscope) { + return pthread_attr_getscope(attr, contentionscope); +} + +int32_t taosThreadAttrGetStackSize(const TdThreadAttr * attr, size_t * stacksize) { + return pthread_attr_getstacksize(attr, stacksize); +} + +int32_t taosThreadAttrInit(TdThreadAttr * attr) { + return pthread_attr_init(attr); +} + +int32_t taosThreadAttrSetDetachState(TdThreadAttr * attr, int32_t detachstate) { + return pthread_attr_setdetachstate(attr, detachstate); +} + +int32_t taosThreadAttrSetInheritSched(TdThreadAttr * attr, int32_t inheritsched) { + return pthread_attr_setinheritsched(attr, inheritsched); +} + +int32_t taosThreadAttrSetSchedParam(TdThreadAttr * attr, const struct sched_param *param) { + return pthread_attr_setschedparam(attr, param); +} + +int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr * attr, int32_t policy) { + return pthread_attr_setschedpolicy(attr, policy); +} + +int32_t taosThreadAttrSetScope(TdThreadAttr * attr, int32_t contentionscope) { + return pthread_attr_setscope(attr, contentionscope); +} + +int32_t taosThreadAttrSetStackSize(TdThreadAttr * attr, size_t stacksize) { + return pthread_attr_setstacksize(attr, stacksize); +} + +int32_t taosThreadBarrierDestroy(TdThreadBarrier * barrier) { + return pthread_barrier_destroy(barrier); +} + +int32_t taosThreadBarrierInit(TdThreadBarrier * barrier, const TdThreadBarrierAttr * attr, uint32_t count) { + return pthread_barrier_init(barrier, attr, count); +} + +int32_t taosThreadBarrierWait(TdThreadBarrier * barrier) { + return pthread_barrier_wait(barrier); +} + +int32_t taosThreadBarrierAttrDestroy(TdThreadBarrierAttr * attr) { + return pthread_barrierattr_destroy(attr); +} + +int32_t taosThreadBarrierAttrGetPshared(const TdThreadBarrierAttr * attr, int32_t *pshared) { + return pthread_barrierattr_getpshared(attr, pshared); +} + +int32_t taosThreadBarrierAttrInit(TdThreadBarrierAttr * attr) { + return pthread_barrierattr_init(attr); +} + +int32_t taosThreadBarrierAttrSetPshared(TdThreadBarrierAttr * attr, int32_t pshared) { + return pthread_barrierattr_setpshared(attr, pshared); +} + +int32_t taosThreadCancel(TdThread thread) { + return pthread_cancel(thread); +} + +int32_t taosThreadCondDestroy(TdThreadCond * cond) { + return pthread_cond_destroy(cond); +} + +int32_t taosThreadCondInit(TdThreadCond * cond, const TdThreadCondAttr * attr) { + return pthread_cond_init(cond, attr); +} + +int32_t taosThreadCondSignal(TdThreadCond * cond) { + return pthread_cond_signal(cond); +} + +int32_t taosThreadCondBroadcast(TdThreadCond * cond) { + return pthread_cond_broadcast(cond); +} + +int32_t taosThreadCondWait(TdThreadCond * cond, TdThreadMutex * mutex) { + return pthread_cond_wait(cond, mutex); +} + +int32_t taosThreadCondTimedWait(TdThreadCond * cond, TdThreadMutex * mutex, const struct timespec *abstime) { + return pthread_cond_timedwait(cond, mutex, abstime); +} + +int32_t taosThreadCondAttrDestroy(TdThreadCondAttr * attr) { + return pthread_condattr_destroy(attr); +} + +int32_t taosThreadCondAttrGetPshared(const TdThreadCondAttr * attr, int32_t *pshared) { + return pthread_condattr_getpshared(attr, pshared); +} + +int32_t taosThreadCondAttrInit(TdThreadCondAttr * attr) { + return pthread_condattr_init(attr); +} + +int32_t taosThreadCondAttrSetPshared(TdThreadCondAttr * attr, int32_t pshared) { + return pthread_condattr_setpshared(attr, pshared); +} + +int32_t taosThreadDetach(TdThread thread) { + return pthread_detach(thread); +} -int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int pshared) { - return pthread_spin_init(lock, pshared); +int32_t taosThreadEqual(TdThread t1, TdThread t2) { + return pthread_equal(t1, t2); +} + +void taosThreadExit(void *valuePtr) { + return pthread_exit(valuePtr); +} + +int32_t taosThreadGetSchedParam(TdThread thread, int32_t *policy, struct sched_param *param) { + return pthread_getschedparam(thread, policy, param); +} + +void *taosThreadGetSpecific(TdThreadKey key) { + return pthread_getspecific(key); } -int32_t taosThreadMutexInit(TdThreadMutex *mutex, const TdThreadMutexAttr *attr) { - return pthread_mutex_init(mutex, attr); +int32_t taosThreadJoin(TdThread thread, void **valuePtr) { + return pthread_join(thread, valuePtr); } -int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock) { - return pthread_spin_destroy(lock); +int32_t taosThreadKeyCreate(TdThreadKey * key, void(*destructor)(void *)) { + return pthread_key_create(key, destructor); +} + +int32_t taosThreadKeyDelete(TdThreadKey key) { + return pthread_key_delete(key); +} + +int32_t taosThreadKill(TdThread thread, int32_t sig) { + return pthread_kill(thread, sig); +} + +int32_t taosThreadMutexConsistent(TdThreadMutex* mutex) { + return pthread_mutex_consistent(mutex); } int32_t taosThreadMutexDestroy(TdThreadMutex * mutex) { - return pthread_mutex_destroy(mutex); + return pthread_mutex_destroy(mutex); } -int32_t taosThreadSpinLock(TdThreadSpinlock *lock) { - return pthread_spin_lock(lock); +int32_t taosThreadMutexInit(TdThreadMutex * mutex, const TdThreadMutexAttr * attr) { + return pthread_mutex_init(mutex, attr); } -int32_t taosThreadSpinTryLock(TdThreadSpinlock *lock) { - return pthread_spin_trylock(lock); +int32_t taosThreadMutexLock(TdThreadMutex * mutex) { + return pthread_mutex_lock(mutex); } -int32_t taosThreadMutexLock(TdThreadMutex *mutex) { - return pthread_mutex_lock(mutex); +int32_t taosThreadMutexTimedLock(TdThreadMutex * mutex, const struct timespec *abstime) { + return pthread_mutex_timedlock(mutex, abstime); } -int32_t taosThreadSpinUnlock(TdThreadSpinlock *lock) { - return pthread_spin_unlock(lock); +int32_t taosThreadMutexTryLock(TdThreadMutex * mutex) { + return pthread_mutex_trylock(mutex); } -int32_t taosThreadMutexUnlock(TdThreadMutex *mutex) { - return pthread_mutex_unlock(mutex); +int32_t taosThreadMutexUnlock(TdThreadMutex * mutex) { + return pthread_mutex_unlock(mutex); } -int32_t taosThreadRwlockRdlock(TdThreadRwlock *rwlock) { - return pthread_rwlock_rdlock(rwlock); +int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr * attr) { + return pthread_mutexattr_destroy(attr); } -int32_t taosThreadRwlockWrlock(TdThreadRwlock *rwlock) { - return pthread_rwlock_wrlock(rwlock); +int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr * attr, int32_t *pshared) { + return pthread_mutexattr_getpshared(attr, pshared); } -int32_t taosThreadRwlockUnlock(TdThreadRwlock *rwlock) { - return pthread_rwlock_unlock(rwlock); +int32_t taosThreadMutexAttrGetRobust(const TdThreadMutexAttr * attr, int32_t * robust) { + return pthread_mutexattr_getrobust(attr, robust); } -void taosThreadTestCancel(void) { - return pthread_testcancel(); +int32_t taosThreadMutexAttrGetType(const TdThreadMutexAttr * attr, int32_t *kind) { + return pthread_mutexattr_gettype(attr, kind); } -int32_t taosThreadAttrInit(TdThreadAttr *attr) { - return pthread_attr_init(attr); +int32_t taosThreadMutexAttrInit(TdThreadMutexAttr * attr) { + return pthread_mutexattr_init(attr); } -int32_t taosThreadCreate(TdThread *tid, const TdThreadAttr *attr, void*(*start)(void*), void *arg) { - return pthread_create(tid, attr, start, arg); +int32_t taosThreadMutexAttrSetPshared(TdThreadMutexAttr * attr, int32_t pshared) { + return pthread_mutexattr_setpshared(attr, pshared); } -int32_t taosThreadOnce(TdThreadOnce *onceControl, void(*initRoutine)(void)) { - return pthread_once(onceControl, initRoutine); +int32_t taosThreadMutexAttrSetRobust(TdThreadMutexAttr * attr, int32_t robust) { + return pthread_mutexattr_setrobust(attr, robust); } -int32_t taosThreadAttrSetDetachState(TdThreadAttr *attr, int32_t detachState) { - return pthread_attr_setdetachstate(attr, detachState); +int32_t taosThreadMutexAttrSetType(TdThreadMutexAttr * attr, int32_t kind) { + return pthread_mutexattr_settype(attr, kind); } -int32_t taosThreadAttrDestroy(TdThreadAttr *attr) { - return pthread_attr_destroy(attr); +int32_t taosThreadOnce(TdThreadOnce * onceControl, void(*initRoutine)(void)) { + return pthread_once(onceControl, initRoutine); } -int32_t taosThreadJoin(TdThread thread, void **pValue) { - return pthread_join(thread, pValue); +int32_t taosThreadRwlockDestroy(TdThreadRwlock * rwlock) { + return pthread_rwlock_destroy(rwlock); } -int32_t taosThreadRwlockInit(TdThreadRwlock *rwlock, const TdThreadRwlockAttr *attr) { - return pthread_rwlock_init(rwlock, attr); +int32_t taosThreadRwlockInit(TdThreadRwlock * rwlock, const TdThreadRwlockAttr * attr) { + return pthread_rwlock_init(rwlock, attr); } -int32_t taosThreadRwlockDestroy(TdThreadRwlock *rwlock) { - return pthread_rwlock_destroy(rwlock); +int32_t taosThreadRwlockRdlock(TdThreadRwlock * rwlock) { + return pthread_rwlock_rdlock(rwlock); } -int32_t taosThreadCondSignal(TdThreadCond *cond) { - return pthread_cond_signal(cond); +int32_t taosThreadRwlockTimedRdlock(TdThreadRwlock * rwlock, const struct timespec *abstime) { + return pthread_rwlock_timedrdlock(rwlock, abstime); } -int32_t taosThreadCondInit(TdThreadCond *cond, const TdThreadCondAttr *attr) { - return pthread_cond_init(cond, attr); +int32_t taosThreadRwlockTimedWrlock(TdThreadRwlock * rwlock, const struct timespec *abstime) { + return pthread_rwlock_timedwrlock(rwlock, abstime); } -int32_t taosThreadCondBroadcast(TdThreadCond *cond) { - return pthread_cond_broadcast(cond); +int32_t taosThreadRwlockTryRdlock(TdThreadRwlock * rwlock) { + return pthread_rwlock_tryrdlock(rwlock); } -int32_t taosThreadCondDestroy(TdThreadCond *cond) { - return pthread_cond_destroy(cond); +int32_t taosThreadRwlockTryWrlock(TdThreadRwlock * rwlock) { + return pthread_rwlock_trywrlock(rwlock); } -int32_t taosThreadCondWait(TdThreadCond *cond, TdThreadMutex *mutex) { - return pthread_cond_wait(cond, mutex); +int32_t taosThreadRwlockUnlock(TdThreadRwlock * rwlock) { + return pthread_rwlock_unlock(rwlock); +} + +int32_t taosThreadRwlockWrlock(TdThreadRwlock * rwlock) { + return pthread_rwlock_wrlock(rwlock); +} + +int32_t taosThreadRwlockAttrDestroy(TdThreadRwlockAttr * attr) { + return pthread_rwlockattr_destroy(attr); +} + +int32_t taosThreadRwlockAttrGetPshared(const TdThreadRwlockAttr * attr, int32_t *pshared) { + return pthread_rwlockattr_getpshared(attr, pshared); +} + +int32_t taosThreadRwlockAttrInit(TdThreadRwlockAttr * attr) { + return pthread_rwlockattr_init(attr); +} + +int32_t taosThreadRwlockAttrSetPshared(TdThreadRwlockAttr * attr, int32_t pshared) { + return pthread_rwlockattr_setpshared(attr, pshared); } TdThread taosThreadSelf(void) { - return pthread_self(); + return pthread_self(); } -// int32_t taosThreadGetW32ThreadIdNp(TdThread thread) { -// return pthread_getw32threadid_np(thread); -// } +int32_t taosThreadSetCancelState(int32_t state, int32_t *oldstate) { + return pthread_setcancelstate(state, oldstate); +} -int32_t taosThreadEqual(TdThread t1, TdThread t2) { - return pthread_equal(t1, t2); +int32_t taosThreadSetCancelType(int32_t type, int32_t *oldtype) { + return pthread_setcanceltype(type, oldtype); } -int32_t taosThreadSigmask(int how, sigset_t const *set, sigset_t *oset) { - return pthread_sigmask(how, set, oset); +int32_t taosThreadSetSchedParam(TdThread thread, int32_t policy, const struct sched_param *param) { + return pthread_setschedparam(thread, policy, param); } -int32_t taosThreadCancel(TdThread thread) { - return pthread_cancel(thread); +int32_t taosThreadSetSpecific(TdThreadKey key, const void *value) { + return pthread_setspecific(key, value); } -int32_t taosThreadKill(TdThread thread, int sig) { - return pthread_kill(thread, sig); +int32_t taosThreadSpinDestroy(TdThreadSpinlock * lock) { + return pthread_spin_destroy(lock); } -int32_t taosThreadDetach(TdThread thread) { - return pthread_detach(thread); +int32_t taosThreadSpinInit(TdThreadSpinlock * lock, int32_t pshared) { + return pthread_spin_init(lock, pshared); +} + +int32_t taosThreadSpinLock(TdThreadSpinlock * lock) { + return pthread_spin_lock(lock); +} + +int32_t taosThreadSpinTrylock(TdThreadSpinlock * lock) { + return pthread_spin_trylock(lock); +} + +int32_t taosThreadSpinUnlock(TdThreadSpinlock * lock) { + return pthread_spin_unlock(lock); +} + +void taosThreadTestCancel(void) { + return pthread_testcancel(); +} + +int32_t taosThreadSigMask(int32_t how, sigset_t const *set, sigset_t * oset) { + return pthread_sigmask(how, set, oset); +} + +int32_t taosThreadSigWait(const sigset_t * set, int32_t *sig) { + return sigwait(set, sig); } \ No newline at end of file diff --git a/source/util/src/tprocess.c b/source/util/src/tprocess.c index 86cec2d271972eda46ce87cf8087597da2f8b353..bfb55b4593a53b55d2df863af8301348145b37fb 100644 --- a/source/util/src/tprocess.c +++ b/source/util/src/tprocess.c @@ -64,13 +64,13 @@ static int32_t taosProcInitMutex(TdThreadMutex **ppMutex, int32_t *pShmid) { int32_t shmid = -1; int32_t code = -1; - if (pthread_mutexattr_init(&mattr) != 0) { + if (taosThreadMutexAttrInit(&mattr) != 0) { terrno = TAOS_SYSTEM_ERROR(errno); uError("failed to init mutex while init attr since %s", terrstr()); goto _OVER; } - if (pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED) != 0) { + if (taosThreadMutexAttrSetPshared(&mattr, PTHREAD_PROCESS_SHARED) != 0) { terrno = TAOS_SYSTEM_ERROR(errno); uError("failed to init mutex while set shared since %s", terrstr()); goto _OVER; @@ -112,7 +112,7 @@ _OVER: *pShmid = shmid; } - pthread_mutexattr_destroy(&mattr); + taosThreadMutexAttrDestroy(&mattr); return code; } diff --git a/source/util/test/queueTest.cpp b/source/util/test/queueTest.cpp index 09c544df9f27f9f897d6376e5c08fbee9efe2057..0bc53ab85ab21b8b4185a131c1abb759903023af 100644 --- a/source/util/test/queueTest.cpp +++ b/source/util/test/queueTest.cpp @@ -36,12 +36,12 @@ TEST_F(UtilTestQueue, 01_fork) { int err; pthread_mutexattr_t mattr; - if ((err = pthread_mutexattr_init(&mattr)) < 0) { + if ((err = taosThreadMutexAttrInit(&mattr)) < 0) { printf("mutex addr init error:%s\n", strerror(err)); exit(1); } - if ((err = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED)) < 0) { + if ((err = taosThreadMutexAttrSetPshared(&mattr, PTHREAD_PROCESS_SHARED)) < 0) { printf("mutex addr get shared error:%s\n", strerror(err)); exit(1); } @@ -50,7 +50,7 @@ TEST_F(UtilTestQueue, 01_fork) { int mid = shmget(IPC_PRIVATE, sizeof(pthread_mutex_t), 0600); m = (pthread_mutex_t*)shmat(mid, NULL, 0); - if ((err = pthread_mutex_init(m, &mattr)) < 0) { + if ((err = taosThreadMutexInit(m, &mattr)) < 0) { printf("mutex mutex init error:%s\n", strerror(err)); exit(1); } @@ -125,7 +125,7 @@ TEST_F(UtilTestQueue, 01_fork) { taosThreadAttrDestroy(&mattr); //销毁mutex - pthread_mutex_destroy(m); + taosThreadMutexDestroy(m); exit(0); }