feat: 支持uts容器

BREAKING CHANGE:
支持uts容器对外变更:
支持sethostname

Close #I6A7C8
Signed-off-by: Nzhushengle <zhushengle@huawei.com>
Change-Id: I2504f77c37bb4149861673c81688bd112563c24b

compat/posix/src/misc.c

@@ -53,21 +53,27 @@
 
 int uname(struct utsname *name)
 {
-    INT32 ret;
-    const char *cpuInfo = NULL;
-
     if (name == NULL) {
         return -EFAULT;
     }
+
+#ifdef LOSCFG_UTS_CONTAINER
+    struct utsname *currentUtsName = OsGetCurrUtsName();
+    if (currentUtsName == NULL) {
+        return -EFAULT;
+    }
+    (VOID)memcpy_s(name, sizeof(struct utsname), currentUtsName, sizeof(struct utsname));
+#else
+
     (VOID)strcpy_s(name->sysname, sizeof(name->sysname), KERNEL_NAME);
-    (VOID)strcpy_s(name->nodename, sizeof(name->nodename), "hisilicon");
-    ret = sprintf_s(name->version, sizeof(name->version), "%s %u.%u.%u.%u %s %s",
+    (VOID)strcpy_s(name->nodename, sizeof(name->nodename), KERNEL_NODE_NAME);
+    INT32 ret = sprintf_s(name->version, sizeof(name->version), "%s %u.%u.%u.%u %s %s",
                           KERNEL_NAME, KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE, __DATE__, __TIME__);
     if (ret < 0) {
         return -EIO;
     }
 
-    cpuInfo = LOS_CpuInfo();
+    const char *cpuInfo = LOS_CpuInfo();
     (VOID)strcpy_s(name->machine, sizeof(name->machine), cpuInfo);
     ret = sprintf_s(name->release, sizeof(name->release), "%u.%u.%u.%u",
                      KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE);
@@ -76,6 +82,7 @@ int uname(struct utsname *name)
     }
 
     name->domainname[0] = '\0';
+#endif
     return 0;
 }
 

kernel/Kconfig

@@ -78,6 +78,11 @@ config PID_CONTAINER
     default n
     depends on KERNEL_CONTAINER
 
+config UTS_CONTAINER
+    bool "Enable uts container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
 ######################### config options of extended #####################
 source "kernel/extended/Kconfig"
 

kernel/base/BUILD.gn

@@ -34,6 +34,7 @@ kernel_module(module_name) {
   sources = [
     "container/los_container.c",
     "container/los_pid_container.c",
+    "container/los_uts_container.c",
     "core/los_bitmap.c",
     "core/los_info.c",
     "core/los_process.c",

kernel/base/container/los_container.c

@@ -46,7 +46,10 @@ VOID OsContainerInitSystemProcess(LosProcessCB *processCB)
 VOID OsInitRootContainer(VOID)
 {
 #ifdef LOSCFG_PID_CONTAINER
-    OsInitRootPidContainer(&g_rootContainer.pidContainer);
+    (VOID)OsInitRootPidContainer(&g_rootContainer.pidContainer);
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    (VOID)OsInitRootUtsContainer(&g_rootContainer.utsContainer);
 #endif
     return;
 }
@@ -92,7 +95,12 @@ UINT32 OsCopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent
         return ret;
     }
 #endif
-
+#ifdef LOSCFG_UTS_CONTAINER
+    ret = OsCopyUtsContainer(flags, child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
     return ret;
 }
 
@@ -105,6 +113,10 @@ VOID OsContainersDestroy(LosProcessCB *processCB)
     }
 #endif
 
+#ifdef LOSCFG_UTS_CONTAINER
+    OsUtsContainersDestroy(processCB);
+#endif
+
 #ifndef LOSCFG_PID_CONTAINER
     LOS_AtomicDec(&curr->container->rc);
     if (LOS_AtomicRead(&processCB->container->rc) == 1) {

kernel/base/container/los_pid_container.c

@@ -112,7 +112,6 @@ UINT32 OsAllocSpecifiedVpidUnsafe(UINT32 vpid, LosProcessCB *processCB, LosProce
 
 STATIC UINT32 OsAllocVpid(LosProcessCB *processCB)
 {
-    UINT32 intSave;
     ProcessVid *oldProcessVid = NULL;
     PidContainer *pidContainer = processCB->container->pidContainer;
     if ((pidContainer == NULL) || (LOS_AtomicRead(&pidContainer->lock) > 0)) {
@@ -120,7 +119,6 @@ STATIC UINT32 OsAllocVpid(LosProcessCB *processCB)
     }
 
     processCB->processID = OS_INVALID_VALUE;
-    SCHEDULER_LOCK(intSave);
     do {
         ProcessVid *vpid = OsGetFreeVpid(pidContainer);
         if (vpid == NULL) {
@@ -136,8 +134,6 @@ STATIC UINT32 OsAllocVpid(LosProcessCB *processCB)
         oldProcessVid = vpid;
         pidContainer = pidContainer->parent;
     } while (pidContainer != NULL);
-    SCHEDULER_UNLOCK(intSave);
-
     return processCB->processID;
 }
 
@@ -331,9 +327,13 @@ VOID OsPidContainersDestroy(LosProcessCB *curr)
 UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
 {
     UINT32 ret;
+    UINT32 intSave;
 
     if (!(flags & CLONE_NEWPID)) {
+        SCHEDULER_LOCK(intSave);
+        child->container->pidContainer = parent->container->pidContainer;
         ret = OsAllocVpid(child);
+        SCHEDULER_UNLOCK(intSave);
         if (ret == OS_INVALID_VALUE) {
             PRINT_ERR("[%s] alloc vpid failed\n", __FUNCTION__);
             return ENOSPC;

kernel/base/container/los_uts_container.c

+/*
+ * Copyright (c) 2022-2022 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "internal.h"
+#include "los_uts_container_pri.h"
+#include "los_process_pri.h"
+
+#ifdef LOSCFG_UTS_CONTAINER
+
+STATIC UINT32 g_currentUtsContainerNum;
+
+STATIC UINT32 CreateUtsContainer(UtsContainer **newUtsContainer)
+{
+    UINT32 intSave;
+    UINT32 size = sizeof(UtsContainer);
+    UtsContainer *utsContainer = LOS_MemAlloc(m_aucSysMem1, size);
+    if (utsContainer == NULL) {
+        return ENOMEM;
+    }
+    (VOID)memset_s(utsContainer, sizeof(UtsContainer), 0, sizeof(UtsContainer));
+
+    LOS_AtomicSet(&utsContainer->rc, 1);
+
+    SCHEDULER_LOCK(intSave);
+    g_currentUtsContainerNum += 1;
+    *newUtsContainer = utsContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsCopyUtsContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    UINT32 ret;
+    UtsContainer *newUtsContainer = NULL;
+    UtsContainer *currUtsContainer = parent->container->utsContainer;
+
+    if (!(flags & CLONE_NEWUTS)) {
+        SCHEDULER_LOCK(intSave);
+        LOS_AtomicInc(&currUtsContainer->rc);
+        child->container->utsContainer = currUtsContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    ret = CreateUtsContainer(&newUtsContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    (VOID)memcpy_s(&newUtsContainer->utsName, sizeof(newUtsContainer->utsName),
+                   &currUtsContainer->utsName, sizeof(currUtsContainer->utsName));
+    child->container->utsContainer = newUtsContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+VOID OsUtsContainersDestroy(LosProcessCB *curr)
+{
+    UINT32 intSave;
+    if (curr->container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    UtsContainer *utsContainer = curr->container->utsContainer;
+    if (utsContainer != NULL) {
+        if (LOS_AtomicRead(&utsContainer->rc) == 0) {
+            g_currentUtsContainerNum--;
+            curr->container->utsContainer = NULL;
+            SCHEDULER_UNLOCK(intSave);
+            (VOID)LOS_MemFree(m_aucSysMem1, utsContainer);
+            return;
+        }
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return;
+}
+
+STATIC UINT32 InitUtsContainer(struct utsname *name)
+{
+    UINT32 ret;
+
+    ret = sprintf_s(name->sysname, sizeof(name->sysname), "%s", KERNEL_NAME);
+    if (ret < 0) {
+        return LOS_NOK;
+    }
+    ret = sprintf_s(name->nodename, sizeof(name->nodename), "%s", KERNEL_NODE_NAME);
+    if (ret < 0) {
+        return LOS_NOK;
+    }
+    ret = sprintf_s(name->version, sizeof(name->version), "%s %u.%u.%u.%u %s %s",
+        KERNEL_NAME, KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE, __DATE__, __TIME__);
+    if (ret < 0) {
+        return LOS_NOK;
+    }
+    const char *cpuInfo = LOS_CpuInfo();
+    ret = sprintf_s(name->machine, sizeof(name->machine), "%s", cpuInfo);
+    if (ret < 0) {
+        return LOS_NOK;
+    }
+    ret = sprintf_s(name->release, sizeof(name->release), "%u.%u.%u.%u",
+        KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE);
+    if (ret < 0) {
+        return LOS_NOK;
+    }
+    name->domainname[0] = '\0';
+    return LOS_OK;
+}
+
+UINT32 OsInitRootUtsContainer(UtsContainer **utsContainer)
+{
+    UINT32 ret = CreateUtsContainer(utsContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    return InitUtsContainer(&(*utsContainer)->utsName);
+}
+
+struct utsname *OsGetCurrUtsName(VOID)
+{
+    Container *container = OsCurrProcessGet()->container;
+    if (container == NULL) {
+        return NULL;
+    }
+    UtsContainer *utsContainer = container->utsContainer;
+    if (utsContainer == NULL) {
+        return NULL;
+    }
+    return &utsContainer->utsName;
+}
+#endif

kernel/base/core/los_process.c

@@ -2033,7 +2033,7 @@ ERROR_INIT:
 
 LITE_OS_SEC_TEXT INT32 OsClone(UINT32 flags, UINTPTR sp, UINT32 size)
 {
-    UINT32 cloneFlag = CLONE_PARENT | CLONE_THREAD | CLONE_VFORK | CLONE_VM;
+    UINT32 cloneFlag = CLONE_PARENT | CLONE_THREAD | SIGCHLD;
 #ifdef LOSCFG_KERNEL_CONTAINER
 #ifdef LOSCFG_PID_CONTAINER
     cloneFlag |= CLONE_NEWPID;
@@ -2042,10 +2042,13 @@ LITE_OS_SEC_TEXT INT32 OsClone(UINT32 flags, UINTPTR sp, UINT32 size)
         return -LOS_EINVAL;
     }
 #endif
+#ifdef LOSCFG_UTS_CONTAINER
+    cloneFlag |= CLONE_NEWUTS;
+#endif
 #endif
 
     if (flags & (~cloneFlag)) {
-        PRINT_WARN("Clone dont support some flags!\n");
+        return -LOS_EOPNOTSUPP;
     }
 
     return OsCopyProcess(cloneFlag & flags, NULL, sp, size);

kernel/base/include/los_container_pri.h

@@ -36,12 +36,17 @@
 #ifdef LOSCFG_PID_CONTAINER
 #include "los_pid_container_pri.h"
 #endif
+#ifdef LOSCFG_UTS_CONTAINER
+#include "los_uts_container_pri.h"
+#endif
 
 typedef struct Container {
     Atomic   rc;
 #ifdef LOSCFG_PID_CONTAINER
     struct PidContainer *pidContainer;
-    struct PidContainer *pidForChildren;
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    struct UtsContainer *utsContainer;
 #endif
 } Container;
 

kernel/base/include/los_uts_container_pri.h

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LOS_UTS_CONTAINER_PRI_H
+#define _LOS_UTS_CONTAINER_PRI_H
+
+#include "sys/utsname.h"
+#include "sched.h"
+#include "los_atomic.h"
+
+#ifdef LOSCFG_UTS_CONTAINER
+
+typedef struct ProcessCB LosProcessCB;
+
+typedef struct UtsContainer {
+    Atomic rc;
+    struct utsname utsName;
+} UtsContainer;
+
+UINT32 OsInitRootUtsContainer(UtsContainer **utsContainer);
+
+UINT32 OsCopyUtsContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent);
+
+VOID OsUtsContainersDestroy(LosProcessCB *curr);
+
+struct utsname *OsGetCurrUtsName(VOID);
+
+#endif
+#endif /* _LOS_UTS_CONTAINER_PRI_H */

kernel/common/los_config.h

@@ -373,6 +373,7 @@ extern UINT32 __heap_end;
  */
 #define _T(x)                                   x
 #define KERNEL_NAME                            "Huawei LiteOS"
+#define KERNEL_NODE_NAME                       "hisilicon"
 #define KERNEL_SEP                             " "
 #define _V(v)                                  _T(KERNEL_NAME)_T(KERNEL_SEP)_T(v)
 

syscall/los_syscall.h

@@ -177,6 +177,9 @@ extern int SysShmCtl(int shmid, int cmd, struct shmid_ds *buf);
 extern int SysShmDt(const void *shmaddr);
 
 /* misc */
+#ifdef LOSCFG_UTS_CONTAINER
+extern int SysSetHostName(const char *name, size_t len);
+#endif
 extern int SysUname(struct utsname *name);
 extern int SysInfo(struct sysinfo *info);
 

syscall/misc_syscall.c

@@ -46,6 +46,44 @@
 #include "user_copy.h"
 #include "unistd.h"
 
+#ifdef LOSCFG_UTS_CONTAINER
+#define HOST_NAME_MAX_LEN 65
+int SysSetHostName(const char *name, size_t len)
+{
+    int ret;
+    char tmpName[HOST_NAME_MAX_LEN];
+    unsigned int intSave;
+
+    if (name == NULL) {
+        return -EFAULT;
+    }
+
+    if ((len < 0) || (len > HOST_NAME_MAX_LEN)) {
+        return -EINVAL;
+    }
+
+    ret = LOS_ArchCopyFromUser(&tmpName, name, len);
+    if (ret != 0) {
+        return -EFAULT;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    struct utsname *currentUtsName = OsGetCurrUtsName();
+    if (currentUtsName == NULL) {
+        SCHEDULER_UNLOCK(intSave);
+        return -EFAULT;
+    }
+
+    (VOID)memset_s(currentUtsName->nodename, sizeof(currentUtsName->nodename), 0, sizeof(currentUtsName->nodename));
+    ret = memcpy_s(currentUtsName->nodename, sizeof(currentUtsName->nodename), tmpName, len);
+    if (ret != EOK) {
+        SCHEDULER_UNLOCK(intSave);
+        return -EFAULT;
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return 0;
+}
+#endif
 
 int SysUname(struct utsname *name)
 {

syscall/syscall_lookup.h

@@ -161,6 +161,9 @@ SYSCALL_HAND_DEF(__NR_getitimer, SysGetiTimer, int, ARG_NUM_2)
 SYSCALL_HAND_DEF(__NR_wait4, SysWait, int, ARG_NUM_4)
 SYSCALL_HAND_DEF(__NR_waitid, SysWaitid, int, ARG_NUM_5)
 SYSCALL_HAND_DEF(__NR_uname, SysUname, int, ARG_NUM_1)
+#ifdef LOSCFG_UTS_CONTAINER
+SYSCALL_HAND_DEF(__NR_sethostname, SysSetHostName, int, ARG_NUM_2)
+#endif
 SYSCALL_HAND_DEF(__NR_mprotect, SysMprotect, int, ARG_NUM_3)
 SYSCALL_HAND_DEF(__NR_getpgid, SysGetProcessGroupID, int, ARG_NUM_1)
 SYSCALL_HAND_DEF(__NR_sched_setparam, SysSchedSetParam, int, ARG_NUM_3)

testsuites/unittest/config.gni

@@ -129,9 +129,13 @@ LOSCFG_USER_TEST_SECURITY_VID = true
 ########## container test ##########
 LOSCFG_USER_TEST_CONTAINER = false
 LOSCFG_USER_TEST_PID_CONTAINER = false
+LOSCFG_USER_TEST_UTS_CONTAINER = false
 if (defined(LOSCFG_KERNEL_CONTAINER)) {
   LOSCFG_USER_TEST_CONTAINER = true
   if (defined(LOSCFG_PID_CONTAINER)) {
     LOSCFG_USER_TEST_PID_CONTAINER = true
   }
+  if (defined(LOSCFG_UTS_CONTAINER)) {
+    LOSCFG_USER_TEST_UTS_CONTAINER = true
+  }
 }

testsuites/unittest/container/BUILD.gn

@@ -35,6 +35,9 @@ config("container_config") {
   if (defined(LOSCFG_USER_TEST_PID_CONTAINER)) {
     cflags += [ "-DLOSCFG_USER_TEST_PID_CONTAINER" ]
   }
+  if (defined(LOSCFG_USER_TEST_UTS_CONTAINER)) {
+    cflags += [ "-DLOSCFG_USER_TEST_UTS_CONTAINER" ]
+  }
   cflags_cc = cflags
 }
 

testsuites/unittest/container/It_container_test.cpp

@@ -126,6 +126,30 @@ HWTEST_F(ContainerTest, ItPidContainer023, TestSize.Level0)
     ItPidContainer023();
 }
 #endif
+#if defined(LOSCFG_USER_TEST_UTS_CONTAINER)
+/**
+* @tc.name: Container_UTS_Test_001
+* @tc.desc: uts container function test case
+* @tc.type: FUNC
+* @tc.require: issueI6A7C8
+* @tc.author:
+*/
+HWTEST_F(ContainerTest, ItUtsContainer001, TestSize.Level0)
+{
+    ItUtsContainer001();
+}
+/**
+* @tc.name: Container_UTS_Test_002
+* @tc.desc: uts container function test case
+* @tc.type: FUNC
+* @tc.require: issueI6A7C8
+* @tc.author:
+*/
+HWTEST_F(ContainerTest, ItUtsContainer002, TestSize.Level0)
+{
+    ItUtsContainer002();
+}
+#endif
 #endif
 
 #if defined(LOSCFG_USER_TEST_FULL)
@@ -394,6 +418,19 @@ HWTEST_F(ContainerTest, ItPidContainer024, TestSize.Level0)
     ItPidContainer024();
 }
 #endif
+#if defined(LOSCFG_USER_TEST_UTS_CONTAINER)
+/**
+* @tc.name: Container_UTS_Test_003
+* @tc.desc: uts container function test case
+* @tc.type: FUNC
+* @tc.require: issueI6A7C8
+* @tc.author:
+*/
+HWTEST_F(ContainerTest, ItUtsContainer003, TestSize.Level0)
+{
+    ItUtsContainer003();
+}
+#endif
 #endif
 } // namespace OHOS
 

testsuites/unittest/container/It_container_test.h

@@ -83,6 +83,10 @@ void ItContainer001(void);
 #if defined(LOSCFG_USER_TEST_PID_CONTAINER)
 void ItPidContainer023(void);
 #endif
+#if defined(LOSCFG_USER_TEST_UTS_CONTAINER)
+void ItUtsContainer001(void);
+void ItUtsContainer002(void);
+#endif
 #endif
 
 #if defined(LOSCFG_USER_TEST_FULL)
@@ -110,6 +114,9 @@ void ItPidContainer021(void);
 void ItPidContainer022(void);
 void ItPidContainer024(void);
 #endif
+#if defined(LOSCFG_USER_TEST_UTS_CONTAINER)
+void ItUtsContainer003(void);
+#endif
 #endif
 
 #endif /* _IT_CONTAINER_TEST_H */

testsuites/unittest/container/config.gni

@@ -36,12 +36,13 @@ common_include_dirs = [
 
 sources_entry = [ "$TEST_UNITTEST_DIR/container/It_container_test.cpp" ]
 
-sources_smoke = [
-  "$TEST_UNITTEST_DIR/container/smoke/It_container_001.cpp",
-  "$TEST_UNITTEST_DIR/container/smoke/It_pid_container_023.cpp",
-]
+sources_smoke = [ "$TEST_UNITTEST_DIR/container/smoke/It_container_001.cpp" ]
+sources_full = []
 
-sources_full = [
+if (defined(LOSCFG_USER_TEST_PID_CONTAINER)) {
+  sources_smoke +=
+      [ "$TEST_UNITTEST_DIR/container/smoke/It_pid_container_023.cpp" ]
+  sources_full += [
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_001.cpp",
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_002.cpp",
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_003.cpp",
@@ -64,4 +65,13 @@ sources_full = [
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_021.cpp",
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_022.cpp",
     "$TEST_UNITTEST_DIR/container/full/It_pid_container_024.cpp",
-]
+  ]
+}
+if (defined(LOSCFG_USER_TEST_UTS_CONTAINER)) {
+  sources_smoke += [
+    "$TEST_UNITTEST_DIR/container/smoke/It_uts_container_001.cpp",
+    "$TEST_UNITTEST_DIR/container/smoke/It_uts_container_002.cpp",
+  ]
+  sources_full +=
+      [ "$TEST_UNITTEST_DIR/container/full/It_uts_container_003.cpp" ]
+}

testsuites/unittest/container/full/It_pid_container_003.cpp

@@ -51,7 +51,7 @@ static int ChildFunClone1(void *p)
 {
     (void)p;
     pid_t pid = getpid();
-    const int COUNT = 1000;
+    const int COUNT = 100;
     int childPid;
     int childFunRet = (int)pid;
     int processCount = 0;

testsuites/unittest/container/full/It_pid_container_009.cpp

@@ -35,7 +35,7 @@ static int ChildFun(void *p)
     int ret;
     int status = 0;
     pid_t pid;
-    int count = 1000;
+    int count = 100;
     int processCount = 0;
 
     pid = getpid();

testsuites/unittest/container/full/It_uts_container_003.cpp

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "It_container_test.h"
+#include "sys/resource.h"
+#include "sys/wait.h"
+#include "pthread.h"
+#include "sched.h"
+
+const int SLEEP_TIME_US = 1000;
+const int LOOP_NUM = 100;
+
+static int ChildFunc(void *arg)
+{
+    (void)arg;
+    usleep(SLEEP_TIME_US);
+    exit(EXIT_CODE_ERRNO_5);
+}
+
+static int GroupProcess(void *arg)
+{
+    (void)arg;
+    int ret;
+    int status = 0;
+
+    for (int i = 0; i < LOOP_NUM; i++) {
+        int argTmp = CHILD_FUNC_ARG;
+        auto pid = CloneWrapper(ChildFunc, CLONE_NEWUTS, &argTmp);
+        if (pid == -1) {
+            return EXIT_CODE_ERRNO_1;
+        }
+
+        ret = waitpid(pid, &status, 0);
+        status = WEXITSTATUS(status);
+        if (status != EXIT_CODE_ERRNO_5) {
+            return EXIT_CODE_ERRNO_2;
+        }
+    }
+
+    exit(EXIT_CODE_ERRNO_5);
+}
+
+void ItUtsContainer003(void)
+{
+    int ret;
+    int status = 0;
+    int arg = CHILD_FUNC_ARG;
+    auto pid = CloneWrapper(GroupProcess, CLONE_NEWUTS, &arg);
+    ASSERT_NE(pid, -1);
+
+    ret = waitpid(pid, &status, 0);
+    ASSERT_EQ(ret, pid);
+    status = WEXITSTATUS(status);
+    ASSERT_EQ(status, EXIT_CODE_ERRNO_5);
+}

testsuites/unittest/container/smoke/It_uts_container_001.cpp

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "It_container_test.h"
+
+static int ChildFunc(void *arg)
+{
+    int value = *((int*)arg);
+    if (value != CHILD_FUNC_ARG) {
+        return EXIT_CODE_ERRNO_1;
+    }
+    return EXIT_CODE_ERRNO_2;
+}
+
+void ItUtsContainer001(void)
+{
+    int ret;
+
+    int arg = CHILD_FUNC_ARG;
+    auto pid = CloneWrapper(ChildFunc, CLONE_NEWUTS, &arg);
+    ASSERT_NE(pid, -1);
+
+    int status;
+    ret = waitpid(pid, &status, 0);
+    ASSERT_EQ(ret, pid);
+
+    ret = WIFEXITED(status);
+    ASSERT_NE(ret, 0);
+
+    int exitCode = WEXITSTATUS(status);
+    ASSERT_EQ(exitCode, EXIT_CODE_ERRNO_2);
+}

testsuites/unittest/container/smoke/It_uts_container_002.cpp

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "It_container_test.h"
+#include "sys/utsname.h"
+
+static int ChildFunc(void *arg)
+{
+    int ret;
+    int value = *((int*)arg);
+    if (value != CHILD_FUNC_ARG) {
+        return EXIT_CODE_ERRNO_1;
+    }
+    sleep(1);
+
+    struct utsname newName;
+    ret = uname(&newName);
+    if (ret != 0) {
+        return EXIT_CODE_ERRNO_2;
+    }
+
+    const char *name = "TestHostName";
+    ret = sethostname(name, strlen(name));
+    if (ret != 0) {
+        return EXIT_CODE_ERRNO_3;
+    }
+
+    struct utsname newName1;
+    ret = uname(&newName1);
+    if (ret != 0) {
+        return EXIT_CODE_ERRNO_4;
+    }
+
+    ret = strcmp(newName.nodename, newName1.nodename);
+    if (ret == 0) {
+        return EXIT_CODE_ERRNO_5;
+    }
+
+    return 0;
+}
+
+void ItUtsContainer002(void)
+{
+    int ret;
+    char *stack = (char*)mmap(NULL, STACK_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+    ASSERT_TRUE(stack != NULL);
+    char *stackTop = stack + STACK_SIZE;
+
+    struct utsname oldName;
+    ret = uname(&oldName);
+    ASSERT_EQ(ret, 0);
+
+    int arg = CHILD_FUNC_ARG;
+    auto pid = clone(ChildFunc, stackTop, CLONE_NEWUTS, &arg);
+    (void)munmap(stack, STACK_SIZE);
+    ASSERT_NE(pid, -1);
+
+    int status;
+    ret = waitpid(pid, &status, 0);
+    ASSERT_EQ(ret, pid);
+
+    int exitCode = WEXITSTATUS(status);
+    ASSERT_EQ(exitCode, 0);
+
+    struct utsname oldName1;
+    ret = uname(&oldName1);
+    ASSERT_EQ(ret, 0);
+
+    ret = strcmp(oldName.nodename, oldName1.nodename);
+    ASSERT_EQ(ret, 0);
+}