fix(posix接口融合): posix接口融合，接口规范兼容性修改

posix接口融合，接口规范兼容性修改

BREAKING CHANGE:
接口修改：
calloc
pthread_mutex_init
mq_unlink
pthread_join
pthread_exit
pthread_attr_init
pthread_attr_destroy
pthread_condattr_destroy
pthread_cond_timedwait
pthread_mutexattr_init
pthread_mutexattr_settype
pthread_mutex_destroy
pthread_mutex_timedlock
pthread_mutex_trylockk
pthread_mutex_unlock
sem_getvalue
sem_timedwait
pthread_cond_timedwait
nanosleep
timer_create
timer_settime
timer_gettime
testStdlibStrtoull005
testStdlibStrtol011
testStdlibStrtoul007
testPthread004

新增接口：
CheckForCancel
pthread_setcancelstate
pthread_setcanceltype
pthread_once
pthread_setschedprio
pthread_attr_setstack
pthread_attr_getstack
pthread_condattr_getpshared
pthread_condattr_setpshared
pthread_condattr_getclock
pthread_mutexattr_gettype
CheckMutexAttr
OsMuxPreCheck
sem_trywait
MuxPendForPosix
MuxPostForPosix
增加overrun功能

接口变化：
mq_getsetattr 改为内部接口MqGetSetAttr
GetTickTimeFromNow->OsGetTickTimeFromNow

接口位置转移：
pthread_equal接口由newlib下转移到kal/posix/src/pthread.c中

Signed-off-by: LiteOS2021 <dinglu@huawei.com>

testsuites/unittest/posix/src/pthread/pthread_cond_func_test.c

@@ -41,6 +41,9 @@
 
 #define TASK_PRIO_TEST           LOSCFG_BASE_CORE_TSK_DEFAULT_PRIO
 #define OS_TSK_TEST_STACK_SIZE   0x1000
+#define PTHREAD_TASK_DELAY       10
+
+static INT32 g_pthreadSem = 0;
 static UINT32 g_testCount;
 
 /**
@@ -251,7 +254,7 @@ LITE_TEST_CASE(PthreadFuncTestSuite, testPthread004, Function | MediumTest | Lev
     ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
 
     ret = pthread_join(newTh, NULL);
-    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+    ICUNIT_ASSERT_EQUAL(ret, ESRCH, ret);
 
     return LOS_OK;
 };
@@ -645,4 +648,343 @@ LITE_TEST_CASE(PthreadFuncTestSuite, testPthread008, Function | MediumTest | Lev
     return LOS_OK;
 };
 
+static VOID *pthread_prio_f01(void *argument)
+{
+    g_testCount++;
+    ICUNIT_ASSERT_EQUAL(g_testCount, (UINT32)argument, g_testCount);
+    return NULL;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_009
+ * @tc.name      : event operation for set priority
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread009, Function | MediumTest | Level1)
+{
+    pthread_attr_t attr;
+    pthread_t thread[TEST_THREAD_COUNT];
+    struct sched_param schedParam = { 0 };
+    UINT32 ret;
+    UINT32 i = 0;
+    g_testCount = 0;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setstacksize(&attr, OS_TSK_TEST_STACK_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    schedParam.sched_priority = TASK_PRIO_TEST + 1;
+    ret = pthread_attr_setschedparam(&attr, &schedParam);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    
+    for (i = 0; i < TEST_THREAD_COUNT; i++) {
+        ret = pthread_create(&thread[i], &attr, pthread_prio_f01, TEST_THREAD_COUNT - i);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+
+    for (i = 0; i < TEST_THREAD_COUNT; i++) {
+        ret = pthread_setschedprio(thread[i], TASK_PRIO_TEST + TEST_THREAD_COUNT - i);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+
+    for (i = 0; i < TEST_THREAD_COUNT; i++) {
+        ret = pthread_join(thread[i], NULL);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+
+    return LOS_OK;
+};
+
+static VOID pthread_once_f01(void)
+{
+    g_testCount++;
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_010
+ * @tc.name      : event operation for pthread_once
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread010, Function | MediumTest | Level1)
+{
+    pthread_attr_t attr;
+    pthread_t thread[TEST_THREAD_COUNT];
+    struct sched_param schedParam = { 0 };
+    UINT32 ret;
+    UINT32 i = 0;
+    pthread_once_t onceControl = 0;
+    g_testCount = 0;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setstacksize(&attr, OS_TSK_TEST_STACK_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    schedParam.sched_priority = TASK_PRIO_TEST + 1;
+    ret = pthread_attr_setschedparam(&attr, &schedParam);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    
+    for (i = 0; i < TEST_THREAD_COUNT; i++) {
+        ret = pthread_once(&onceControl, pthread_once_f01);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+
+    return LOS_OK;
+};
+
+static VOID *pthread_cancel_f01(void *argument)
+{
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+    while (1) {
+        g_testCount++;
+        ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+        LOS_TaskDelay(PTHREAD_TASK_DELAY);
+    }
+
+    return NULL;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_011
+ * @tc.name      : event operation for pthread_cancel
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread011, Function | MediumTest | Level1)
+{
+    pthread_attr_t attr;
+    pthread_t thread;
+    struct sched_param schedParam = { 0 };
+    UINT32 ret;
+    pthread_once_t onceControl = 0;
+    g_testCount = 0;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setstacksize(&attr, OS_TSK_TEST_STACK_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    schedParam.sched_priority = TASK_PRIO_TEST - 1;
+    ret = pthread_attr_setschedparam(&attr, &schedParam);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+ 
+    ret = pthread_create(&thread, &attr, pthread_cancel_f01, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_cancel(thread);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+
+    return LOS_OK;
+};
+
+static VOID *pthread_testcancel_f01(void *argument)
+{
+    INT32 ret = 0;
+
+    ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    ICUNIT_TRACK_EQUAL(ret, 0, ret);
+
+    ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    g_testCount = 1;
+    g_pthreadSem = 1;
+    while (g_pthreadSem == 1) {
+        LOS_TaskDelay(PTHREAD_TASK_DELAY);
+    }
+
+    LOS_TaskDelay(PTHREAD_TASK_DELAY);
+    pthread_testcancel();
+    g_testCount = -1;
+
+    return NULL;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_012
+ * @tc.name      : event operation for testcancel
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread012, Function | MediumTest | Level1)
+{
+    pthread_attr_t attr;
+    pthread_t thread;
+    struct sched_param schedParam = { 0 };
+    UINT32 ret;
+    pthread_once_t onceControl = 0;
+
+    g_testCount = 0;
+    g_pthreadSem = 0;
+
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setstacksize(&attr, OS_TSK_TEST_STACK_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    schedParam.sched_priority = TASK_PRIO_TEST - 1;
+    ret = pthread_attr_setschedparam(&attr, &schedParam);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    
+    ret = pthread_create(&thread, &attr, pthread_testcancel_f01, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    while (g_pthreadSem == 0) {
+        LOS_TaskDelay(PTHREAD_TASK_DELAY);
+    }
+
+    ret = pthread_cancel(thread);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    g_pthreadSem = 0;
+
+    ret = pthread_join(thread, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+
+    return LOS_OK;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_013
+ * @tc.name      : event operation for set/get clock
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread013, Function | MediumTest | Level1)
+{
+    INT32 ret;
+    clockid_t clk;
+    const int invalidClock = -100;
+    pthread_condattr_t condattr;
+    ret = pthread_condattr_init(&condattr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = pthread_condattr_getclock(&condattr, &clk);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(clk, 0, clk);
+
+    ret = pthread_condattr_setclock(&condattr, 0);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_condattr_getclock(&condattr, &clk);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(clk, 0, clk);
+
+    struct timespec ts = {0};
+    ret = clock_getres(CLOCK_MONOTONIC, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_condattr_getclock(&condattr, &clk);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(clk, CLOCK_MONOTONIC, clk);
+
+    ret = pthread_condattr_setclock(&condattr, invalidClock);
+    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_014
+ * @tc.name      : event operation for setpshared
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread014, Function | MediumTest | Level1)
+{
+    INT32 ret;
+    pthread_condattr_t attr;
+
+    /* Initialize a cond attributes object */
+    ret = pthread_condattr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    /* Set 'pshared' to INVALID_PSHARED_VALUE. */
+    ret = pthread_condattr_setpshared(&attr, (-100));
+    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+
+    /* Destroy the cond attributes object */
+    ret = pthread_condattr_destroy(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_015
+ * @tc.name      : event operation for getpshared
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread015, Function | MediumTest | Level1)
+{
+    INT32 ret;
+    INT32 pshared;
+    pthread_condattr_t attr;
+
+    /* Initialize a cond attributes object */
+    ret = pthread_condattr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    /* Set 'pshared' to INVALID_PSHARED_VALUE. */
+    ret = pthread_condattr_getpshared(&attr, &pshared);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(pshared, PTHREAD_PROCESS_PRIVATE, pshared);
+
+    /* Destroy the cond attributes object */
+    ret = pthread_condattr_destroy(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_PTHREAD_OPERATION_016
+ * @tc.name      : event operation for get/set mutex attr
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadFuncTestSuite, testPthread016, Function | MediumTest | Level1)
+{
+    pthread_mutexattr_t mutex_attr;
+    int mutex_type;
+    int ret;
+    pthread_mutexattr_init(&mutex_attr);
+    ret = pthread_mutexattr_settype(NULL, PTHREAD_MUTEX_ERRORCHECK);
+    if (ret == 0)
+    {
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+    pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ERRORCHECK);
+    pthread_mutexattr_gettype(&mutex_attr, &mutex_type);
+    if (mutex_type != PTHREAD_MUTEX_ERRORCHECK) {
+        ICUNIT_ASSERT_EQUAL(mutex_type, 0, mutex_type);
+    }
+    ret = pthread_mutexattr_gettype(NULL, &mutex_type);
+    if (ret == 0) {
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+    mutex_attr.type = 3;
+    ret = pthread_mutexattr_gettype(&mutex_attr, &mutex_type);
+    if (ret == 0) {
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+    return LOS_OK;
+}
+
 RUN_TEST_SUITE(PthreadFuncTestSuite);
+

testsuites/unittest/posix/src/semaphore/semaphore_func_test.c

@@ -214,6 +214,33 @@ LITE_TEST_CASE(PosixSemaphoreFuncTestSuite, testIpcSem_Timedwait003, Function |
     TEST_ASSERT_EQUAL_INT(errno, EINVAL);
 }
 
+/* *
+ * @tc.number   SUB_KERNEL_IPC_SEM_TIMEDWAIT_004
+ * @tc.name     sem_trywait get semaphore success
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PosixSemaphoreFuncTestSuite, testIpcSem_Trywait004, Function | MediumTest | Level3)
+{
+    sem_t sem;
+    int val;
+    int ret;
+
+    ret = sem_init(&sem, 0, 1);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    ret = sem_trywait(&sem);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    ret = sem_getvalue(&sem, &val);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    if (val <= 0) {
+        sem_destroy(&sem);
+        return LOS_OK;
+    } else {
+        TEST_ASSERT_EQUAL_INT(0, ret);
+    }
+}
 
 RUN_TEST_SUITE(PosixSemaphoreFuncTestSuite);
 
@@ -223,6 +250,7 @@ void PosixSemaphoreFuncTest()
     RUN_ONE_TESTCASE(testIpcSem_Timedwait001);
     RUN_ONE_TESTCASE(testIpcSem_Timedwait002);
     RUN_ONE_TESTCASE(testIpcSem_Timedwait003);
+    RUN_ONE_TESTCASE(testIpcSem_Trywait004);
 
     return;
 }

testsuites/unittest/posix/src/stdlib/strtol_test.c

@@ -265,13 +265,13 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol011, Function | MediumTest
     char nPtr[] = "12 1.5";
     char *endPtr = NULL;
     long ret = strtol(nPtr, &endPtr, 65);
-    if (ret == 67) {
+    if (ret == 0) {
         LOG("[DEMO] posix stdlib test case 11:strtol(base=65) ret:%ld, %s, endPtr:%s ok.\n", ret, endPtr, endPtr);
     } else {
         LOG("[DEMO] posix stdlib test case 11:strtol(base=65) ret:%ld, %s fail.\n", ret, endPtr);
     }
-    TEST_ASSERT_EQUAL_INT32(67, ret);
-    TEST_ASSERT_EQUAL_STRING(endPtr, " 1.5");
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+    TEST_ASSERT_EQUAL_STRING(endPtr, "12 1.5");
 }
 
 LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol012, Function | MediumTest | Level1)

testsuites/unittest/posix/src/stdlib/strtoul_test.c

@@ -191,13 +191,13 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul007, Function | MediumTe
     char nPtr[] = " 12.34";
     char *endPtr = NULL;
     unsigned long ret = strtoul(nPtr, &endPtr, 65);
-    if (ret == 67UL) {
+    if (ret == 0UL) {
         LOG("[DEMO] posix stdlib test case 7:strtoul(base=65) ret:%lu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
     } else {
         LOG("[DEMO] posix stdlib test case 7:strtoul(base=65) ret:%lu,%s fail.\n", ret, endPtr);
     }
-    TEST_ASSERT_EQUAL_UINT32(67UL, ret);
-    TEST_ASSERT_EQUAL_STRING(endPtr, ".34");
+    TEST_ASSERT_EQUAL_UINT32(0UL, ret);
+    TEST_ASSERT_EQUAL_STRING(endPtr, " 12.34");
 }
 
 /* *

testsuites/unittest/posix/src/stdlib/strtoull_test.c

@@ -153,13 +153,13 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull005, Function | Medium
     char nPtr[] = " 1.6";
     char *endPtr = NULL;
     unsigned long long ret = strtoull(nPtr, &endPtr, 65);
-    if (ret == 1ULL) {
+    if (ret == 0ULL) {
         LOG("[DEMO] posix stdlib test case 5:strtoull(base=65) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
     } else {
         LOG("[DEMO] posix stdlib test case 5:strtoull(base=65) ret:%llu,%s fail.\n", ret, nPtr);
     }
-    TEST_ASSERT_TRUE(ret == 1ULL);
-    TEST_ASSERT_EQUAL_STRING(endPtr, ".6");
+    TEST_ASSERT_TRUE(ret == 0ULL);
+    TEST_ASSERT_EQUAL_STRING(endPtr, " 1.6");
 }
 
 /* *