!1108 feat: 支持pid容器内访问进程挂载目录

Merge pull request !1108 from zhushengle/proc_pid_dir
feat: 支持pid容器内访问进程挂载目录
2023-02-07 04:07:53 +00:00 · 2023-02-07 11:42:44 +08:00 · 2023-02-06 12:08:27 +00:00 · 2023-02-06 10:41:45 +00:00 · 2023-02-06 14:45:59 +08:00 · 2023-02-06 03:19:54 +00:00
288 changed files with 18096 additions and 1687 deletions
--- a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
+++ b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
@@ -10,6 +10,12 @@
 ### 测试用例（新增、改动、可能影响的功能）


+### 是否涉及对外变更（典型的如：对外API规格变更、新增对外接口等等）
+
+必须选择一项（在MarkDown模式下用[x]替换[ ]即可勾选对应选项）:
+- [ ] 是，涉及对外变更: 需要在commit message中按【[模板要求](https://gitee.com/openharmony/kernel_liteos_a/wikis/Commit%20message%20%E8%A7%84%E8%8C%83)】描述变更点
+- [ ] 否，不涉及对外变更
+
 ### 是否需要同步至release（如：3.0LTS ... ）分支？

 必须选择一项（在MarkDown模式下用[x]替换[ ]即可勾选对应选项）:
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -34,6 +34,7 @@ LITEOS_MENUCONFIG_H = rebase_path("$root_out_dir/config.h")
 declare_args() {
  tee_enable = false
  liteos_name = "OHOS_Image"
+  liteos_container_enable = false
  liteos_skip_make = false
  liteos_is_mini = false
 }
@@ -239,6 +240,21 @@ config("misc_config") {
  asmflags = cflags
 }

+config("container_config") {
+  if (liteos_container_enable) {
+    cflags = [
+      "-DLOSCFG_KERNEL_CONTAINER",
+      "-DLOSCFG_PID_CONTAINER",
+      "-DLOSCFG_UTS_CONTAINER",
+      "-DLOSCFG_MNT_CONTAINER",
+      "-DLOSCFG_CHROOT",
+      "-DLOSCFG_IPC_CONTAINER",
+      "-DLOSCFG_TIME_CONTAINER",
+      "-DLOSCFG_PROC_PROCESS_DIR",
+    ]
+  }
+}
+
 config("los_config") {
  configs = [
    ":arch_config",
@@ -249,6 +265,7 @@ config("los_config") {
    ":ssp_config",
    ":warn_config",
    ":misc_config",
+    ":container_config",
  ]
 }

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,338 @@
+#  (2022-03-30)
+
+
+### Bug Fixes
+
+
+* **arm-virt:** HW_RANDOM_ENABLE配置支持arm virt平台 ([68f9f49](https://gitee.com/openharmony/kernel_liteos_a/commits/68f9f49c2a62d3271db14ccb896c9f9fc78a60e4))
+* A核代码静态告警定期清理 ([9ba725c](https://gitee.com/openharmony/kernel_liteos_a/commits/9ba725c3d486dd28fe9b2489b0f95a65354d7d86)), closes [#I4I0O8](https://gitee.com/openharmony/kernel_liteos_a/issues/I4I0O8)
+* change default permission of procfs to 0550 ([a776c04](https://gitee.com/openharmony/kernel_liteos_a/commits/a776c04a3da414f73ef7136a543c029cc6dd75be)), closes [#I4NY49](https://gitee.com/openharmony/kernel_liteos_a/issues/I4NY49)
+* change the execFile field in TCB to execVnode ([e4a0662](https://gitee.com/openharmony/kernel_liteos_a/commits/e4a06623ceb49b5bead60d45c0534db88b9c666f)), closes [#I4CLL9](https://gitee.com/openharmony/kernel_liteos_a/issues/I4CLL9)
+* close file when process interpretor failed ([a375bf5](https://gitee.com/openharmony/kernel_liteos_a/commits/a375bf5668a5e86e082d0e124b538e423023a259)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* codex 清理 ([9ab3e35](https://gitee.com/openharmony/kernel_liteos_a/commits/9ab3e351d38cdae2ec083048a50a253bc2a3b604)), closes [#I4BL3](https://gitee.com/openharmony/kernel_liteos_a/issues/I4BL3)
+* dyload open close failed ([5e87d8c](https://gitee.com/openharmony/kernel_liteos_a/commits/5e87d8c183471166294e2caa041ab4da8570c6a1)), closes [#I452Z7](https://gitee.com/openharmony/kernel_liteos_a/issues/I452Z7)
+* fix ppoll ([a55f68f](https://gitee.com/openharmony/kernel_liteos_a/commits/a55f68f957e9f8ad74bd9e0c1b3d27775e0f8c75))
+* fix some function declarations ([63fd8bc](https://gitee.com/openharmony/kernel_liteos_a/commits/63fd8bc39b21fffb6990f74e879eefecafad6c88))
+* implicit declaration of function 'syscall' in apps/shell ([bd0c083](https://gitee.com/openharmony/kernel_liteos_a/commits/bd0c0835fc58ed5f941dbbc9adfac74253eeb874))
+* LOS_Panic和魔法键功能中的使用PRINTK打印，依赖任务调度，特殊情况下存在打印不出来的问题 ([53addea](https://gitee.com/openharmony/kernel_liteos_a/commits/53addea304de09e0df457b690403ac652bbcea72)), closes [#I4NOC7](https://gitee.com/openharmony/kernel_liteos_a/issues/I4NOC7)
+* los_stat_pri.h中缺少依赖的头文件 ([2cd03c5](https://gitee.com/openharmony/kernel_liteos_a/commits/2cd03c55b7a614c648adc965ebfe494d491fe20f)), closes [#I4KEZ1](https://gitee.com/openharmony/kernel_liteos_a/issues/I4KEZ1)
+* los_trace.h接口注释错误修正 ([6d24961](https://gitee.com/openharmony/kernel_liteos_a/commits/6d249618aecc216388f9b1a2b48fe0ac6dd19ff2)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* MMU竞态问题修复 ([748e0d8](https://gitee.com/openharmony/kernel_liteos_a/commits/748e0d8ffb6ee9c8757ed056f575e3abc6c10702)), closes [#I2](https://gitee.com/openharmony/kernel_liteos_a/issues/I2)
+* **mtd:** 去除mtd对hisilicon驱动的依赖 ([f7d010d](https://gitee.com/openharmony/kernel_liteos_a/commits/f7d010dfa4cb825096267528e131a9e2735d7505)), closes [#I49](https://gitee.com/openharmony/kernel_liteos_a/issues/I49)
+* OsFutexWaitParamCheck函数中absTime为0时，直接返回，不需要打印 ([3f71be7](https://gitee.com/openharmony/kernel_liteos_a/commits/3f71be75355f11037d9de80cc4d7da0f01905003)), closes [#I4D67](https://gitee.com/openharmony/kernel_liteos_a/issues/I4D67)
+* OsLockDepCheckIn异常处理中存在g_lockdepAvailable锁嵌套调用, ([bf030b6](https://gitee.com/openharmony/kernel_liteos_a/commits/bf030b6bb5843151a5b8b8736246a1376a5fb9d0)), closes [#I457](https://gitee.com/openharmony/kernel_liteos_a/issues/I457)
+* pr模板补充说明 ([e3cd485](https://gitee.com/openharmony/kernel_liteos_a/commits/e3cd485db528490a16a8932d734faab263b44bc9))
+* same file mode for procfs files ([c79bcd0](https://gitee.com/openharmony/kernel_liteos_a/commits/c79bcd028e1be34b45cba000077230fa2ef95e68)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* shell支持exit退出，完善帮助信息，特殊处理不可见字符 ([cc6e112](https://gitee.com/openharmony/kernel_liteos_a/commits/cc6e11281e63b6bdc9be8e5d3c39f1258eb2ceaa))
+* smp初始化中副核冗余的启动框架调用 ([5ce70a5](https://gitee.com/openharmony/kernel_liteos_a/commits/5ce70a50c3733b6ec8cc4b444837e366ec837f69)), closes [#I4F8A5](https://gitee.com/openharmony/kernel_liteos_a/issues/I4F8A5)
+* solve SIGCHLD ignored in sigsuspend() ([5a80d4e](https://gitee.com/openharmony/kernel_liteos_a/commits/5a80d4e1a34c94204a0bb01443bf25a4fdb12750)), closes [#I47](https://gitee.com/openharmony/kernel_liteos_a/issues/I47)
+* syscall review bugfix ([214f44e](https://gitee.com/openharmony/kernel_liteos_a/commits/214f44e935277c29d347c50b553a31ea7df36448)), closes [#149](https://gitee.com/openharmony/kernel_liteos_a/issues/149)
+* **test:** misc09用例因依赖hosts文件而失败 ([f2f5c5f](https://gitee.com/openharmony/kernel_liteos_a/commits/f2f5c5fdc3202610de173e7046adab4df5e59142)), closes [re#I48IZ0](https://gitee.com/re/issues/I48IZ0)
+* **test:** 修复sys部分用例因依赖passwd、group文件而失败 ([614cdcc](https://gitee.com/openharmony/kernel_liteos_a/commits/614cdccf91bd2d220c4c76418b53400ce714c6cb)), closes [re#I48](https://gitee.com/re/issues/I48)
+* 中断中调用PRINTK概率卡死，导致系统不能正常响应中断 ([9726ba1](https://gitee.com/openharmony/kernel_liteos_a/commits/9726ba11a79f3d2d1e616e12ef0bb44e4fc5cd20)), closes [#I4C9](https://gitee.com/openharmony/kernel_liteos_a/issues/I4C9)
+* 临终遗言重定向内容缺失task相关信息，对应的shell命令中申请的内存需要cacheline对齐 ([48ca854](https://gitee.com/openharmony/kernel_liteos_a/commits/48ca854bf07f8dcda9657f950601043a485a1b33)), closes [#I482S5](https://gitee.com/openharmony/kernel_liteos_a/issues/I482S5)
+* 优化liteipc任务状态，删除功能重复字段 ([5004ef4](https://gitee.com/openharmony/kernel_liteos_a/commits/5004ef4d87b54fb6d7f748ca8212ae155bcefac5)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 优化trace buffer初始化，删除swtmr 桩中的无效参数 ([b551270](https://gitee.com/openharmony/kernel_liteos_a/commits/b551270ef50cb206360e2eee3dd20ace5cecccb7)), closes [#I4DQ1](https://gitee.com/openharmony/kernel_liteos_a/issues/I4DQ1)
+* 修复 virpart.c 不适配的格式化打印问题 ([de29140](https://gitee.com/openharmony/kernel_liteos_a/commits/de29140edf2567f4847876cb1ed5e0b6857420f3)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 修复A核文档失效的问题 ([456d255](https://gitee.com/openharmony/kernel_liteos_a/commits/456d255a81c2031be8ebecc2bf897af80c3d3c7a)), closes [#I4U7](https://gitee.com/openharmony/kernel_liteos_a/issues/I4U7)
+* 修复A核测试用例失败的问题 ([59329ce](https://gitee.com/openharmony/kernel_liteos_a/commits/59329ce7c6b6a00084df427748e6283287a773c0)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 修复A核测试用例失败的问题 ([be68dc8](https://gitee.com/openharmony/kernel_liteos_a/commits/be68dc8bcaf8d965039ae1d792775f00a08adfac)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 修复dispatch单词拼写错误。 ([9b07aec](https://gitee.com/openharmony/kernel_liteos_a/commits/9b07aece2dfa3494cf35e8b388410341508d6224)), closes [#I4BLE8](https://gitee.com/openharmony/kernel_liteos_a/issues/I4BLE8)
+* 修复futime提示错误22的BUG ([f2861dd](https://gitee.com/openharmony/kernel_liteos_a/commits/f2861ddfb424af7b99c278273601ce0fab1f37e6))
+* 修复jffs2适配层错误释放锁的BUG ([011a55f](https://gitee.com/openharmony/kernel_liteos_a/commits/011a55ff21d95f969abac60bcff96f4c4d7a326d)), closes [#I4FH9](https://gitee.com/openharmony/kernel_liteos_a/issues/I4FH9)
+* 修复los_vm_scan.c中内部函数OsInactiveListIsLow冗余代码 ([bc32a1e](https://gitee.com/openharmony/kernel_liteos_a/commits/bc32a1ec0fa5d19c6d2672bcf4a01de5e1be3afb)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 修复LOSCFG_FS_FAT_CACHE宏关闭后编译失败的BUG ([63e71fe](https://gitee.com/openharmony/kernel_liteos_a/commits/63e71feca05a8d46a49822c713258738740f0712)), closes [#I3T3N0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3T3N0)
+* 修复OsVmPhysFreeListAdd和OsVmPhysFreeListAddUnsafe函数内容重复 ([6827bd2](https://gitee.com/openharmony/kernel_liteos_a/commits/6827bd2a22b78aa05e20d6460412fc7b2d738929)), closes [#I4FL95](https://gitee.com/openharmony/kernel_liteos_a/issues/I4FL95)
+* 修复PR520缺陷 ([4033891](https://gitee.com/openharmony/kernel_liteos_a/commits/40338918d9132399ee0494d331930a05b7a13c67)), closes [re#I4DEG5](https://gitee.com/re/issues/I4DEG5)
+* 修复shcmd.h需要用宏包起来的问题 ([6c4e4b1](https://gitee.com/openharmony/kernel_liteos_a/commits/6c4e4b16abe9c68fea43d40b2d39b4f0ed4bfc9c)), closes [#I4N50](https://gitee.com/openharmony/kernel_liteos_a/issues/I4N50)
+* 修复xts权限用例压测异常问题 ([b0d31cb](https://gitee.com/openharmony/kernel_liteos_a/commits/b0d31cb43f5a8d1c3da574b2b957e3b0e98b3067)), closes [#I3ZJ1](https://gitee.com/openharmony/kernel_liteos_a/issues/I3ZJ1)
+* 修复硬随机不可用时，地址随机化不可用问题 ([665c152](https://gitee.com/openharmony/kernel_liteos_a/commits/665c152c27bb86395ddd0395279255f6cdaf7255)), closes [#I4D4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4D4)
+* 修复进程用例导致门禁概率失败 ([1ed28b4](https://gitee.com/openharmony/kernel_liteos_a/commits/1ed28b4c80cfd222be08b0c2e71e6287e52bb276)), closes [#I4FO0](https://gitee.com/openharmony/kernel_liteos_a/issues/I4FO0)
+* 修复进程线程不稳定用例 ([f6ac03d](https://gitee.com/openharmony/kernel_liteos_a/commits/f6ac03d3e3c56236adc5734d4c059f1fbcc9e0c1)), closes [#I4F1](https://gitee.com/openharmony/kernel_liteos_a/issues/I4F1)
+* 修复重复执行内存用例导致系统卡死问题 ([6c2b163](https://gitee.com/openharmony/kernel_liteos_a/commits/6c2b163c7d7c696ef89b17a0275f3cddb3d7cefb)), closes [#I4F7](https://gitee.com/openharmony/kernel_liteos_a/issues/I4F7)
+* 修改MMU模块的注释错误 ([1a8e22d](https://gitee.com/openharmony/kernel_liteos_a/commits/1a8e22dcf15944153e013d004fd7bbf24557a8c7)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 共享内存问题修复 ([9fdb80f](https://gitee.com/openharmony/kernel_liteos_a/commits/9fdb80f85f92d0167a0456455a94fc6f679797ce)), closes [#I47X2](https://gitee.com/openharmony/kernel_liteos_a/issues/I47X2)
+* 内核ERR打印，无进程和线程信息，不方便问题定位。 ([cb423f8](https://gitee.com/openharmony/kernel_liteos_a/commits/cb423f845462b8cc474c3cba261dadf3943a08ef)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 内核ERR级别及以上的打印输出当前进程和线程名 ([540b201](https://gitee.com/openharmony/kernel_liteos_a/commits/540b2017c5460e300365d2039a08abd5945cec6b))
+* 内源检视测试用例问题修复 ([a6ac759](https://gitee.com/openharmony/kernel_liteos_a/commits/a6ac7597f85043ba6de3a1b395ca676d85c65ea7))
+* 删除冗余的头文件 ([8e614bb](https://gitee.com/openharmony/kernel_liteos_a/commits/8e614bb1616b75bc89eee7ad7da49b7a9c285b47)), closes [#I4KN63](https://gitee.com/openharmony/kernel_liteos_a/issues/I4KN63)
+* 增加pselect SYSCALL函数及测试用例 ([f601c16](https://gitee.com/openharmony/kernel_liteos_a/commits/f601c16b9e67d531dda51fc18389a53db4360b7b)), closes [#I45](https://gitee.com/openharmony/kernel_liteos_a/issues/I45)
+* 增加内核epoll系统调用 ([2251b8a](https://gitee.com/openharmony/kernel_liteos_a/commits/2251b8a2d1f649422dd67f8551b085a7e0c63ec7)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 实现了musl库net模块中的一些函数接口和相应的测试用例 ([3d00a7d](https://gitee.com/openharmony/kernel_liteos_a/commits/3d00a7d23a96f29c138cfc1672825b90b9e0c05e)), closes [#I4JQI1](https://gitee.com/openharmony/kernel_liteos_a/issues/I4JQI1)
+* 添加进程线程冒烟用例 ([2be5968](https://gitee.com/openharmony/kernel_liteos_a/commits/2be59680f2fb0801b43522cd38cc387c8ff38766)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 用户态进程主线程退出时，其他子线程刚好进入异常处理流程会导致系统卡死 ([d955790](https://gitee.com/openharmony/kernel_liteos_a/commits/d955790a44a679421798ec1ac2900b4d75dd75a4)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 编码规范修改 ([d161a0b](https://gitee.com/openharmony/kernel_liteos_a/commits/d161a0b03de046c05fff45a2b625631b4e45a347))
+* 编码规范问题修复 ([f60bc94](https://gitee.com/openharmony/kernel_liteos_a/commits/f60bc94cf231bc615ff6603ca0393b8fe33a8c47))
+* 编译框架在做编译入口的统一 ([bdb9864](https://gitee.com/openharmony/kernel_liteos_a/commits/bdb9864436a6f128a4c3891bbd63e3c60352689f)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 解决dmesg -s参数double lock问题 ([e151256](https://gitee.com/openharmony/kernel_liteos_a/commits/e1512566e322eb1fbc8f5d5997f9bfcd022feac7)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 进程退出前自己回收vmspace中的所有region ([298ccea](https://gitee.com/openharmony/kernel_liteos_a/commits/298ccea3fedaccc651b38973f0455fa1ce12e516)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 通过g_uart_fputc_en关闭打印后，shell进程不能正常启动 ([d21b05c](https://gitee.com/openharmony/kernel_liteos_a/commits/d21b05c0f69877130366ad37b852a0f30c11809d)), closes [#I4CTY2](https://gitee.com/openharmony/kernel_liteos_a/issues/I4CTY2)
+* 针对pr是否同步至release分支，增加原因说明规则 ([b37a7b7](https://gitee.com/openharmony/kernel_liteos_a/commits/b37a7b79292d93dae6c4914952b5f3bb509e8721))
+* 非当前进程销毁时，销毁liteipc时错误的销毁了当前进程的liteipc资源 ([0f0e85b](https://gitee.com/openharmony/kernel_liteos_a/commits/0f0e85b7a6bf76d540925fbf661c483c8dba1cba)), closes [#I4FSA7](https://gitee.com/openharmony/kernel_liteos_a/issues/I4FSA7)
+
+
+### Code Refactoring
+
+* los_cir_buf.c中接口整合 ([0d325c5](https://gitee.com/openharmony/kernel_liteos_a/commits/0d325c56a1053043db05d53a6c8083f4d35f116b)), closes [#I4MC13](https://gitee.com/openharmony/kernel_liteos_a/issues/I4MC13)
+
+
+### Features
+
+
+* add option SIOCGIFBRDADDR for ioctl ([4ecc473](https://gitee.com/openharmony/kernel_liteos_a/commits/4ecc473843207d259613d26b8ee176d75e7f00fd)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* add sync() to vfs ([f67c4da](https://gitee.com/openharmony/kernel_liteos_a/commits/f67c4dae5141914df2e069dce0196b14780649d8)), closes [#I480](https://gitee.com/openharmony/kernel_liteos_a/issues/I480)
+* **build:** support gcc toolchain ([6e886d4](https://gitee.com/openharmony/kernel_liteos_a/commits/6e886d4233dec3b82a27642f174b920e5f98f6aa))
+* L0-L1 支持Perf ([6e0a3f1](https://gitee.com/openharmony/kernel_liteos_a/commits/6e0a3f10bbbfe29d110c050da927684b6d77b961)), closes [#I47I9](https://gitee.com/openharmony/kernel_liteos_a/issues/I47I9)
+* L0~L1 支持Lms ([e748fdb](https://gitee.com/openharmony/kernel_liteos_a/commits/e748fdbe578a1ddd8eb10b2e207042676231ba26)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* liteipc 静态内存优化 ([5237924](https://gitee.com/openharmony/kernel_liteos_a/commits/52379242c109e0cf442784dbe811ff9d42d5f33a)), closes [#I4G4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4G4)
+* page cache backed by vnode instead of filep ([38a6b80](https://gitee.com/openharmony/kernel_liteos_a/commits/38a6b804e9291d2fdbd189825ebd7d56165ec51c)), closes [#I44](https://gitee.com/openharmony/kernel_liteos_a/issues/I44)
+* 提供低功耗默认处理框架 ([212d1bd](https://gitee.com/openharmony/kernel_liteos_a/commits/212d1bd1e806530fe7e7a16ea986cb2c6fb084ed)), closes [#I4KBG9](https://gitee.com/openharmony/kernel_liteos_a/issues/I4KBG9)
+* 支持AT_RANDOM以增强用户态栈保护能力 ([06ea037](https://gitee.com/openharmony/kernel_liteos_a/commits/06ea03715f0cfb8728fadd0d9c19a403dc8f6028)), closes [#I4CB8](https://gitee.com/openharmony/kernel_liteos_a/issues/I4CB8)
+* 支持L1 低功耗框架 ([64e49ab](https://gitee.com/openharmony/kernel_liteos_a/commits/64e49aba7c9c7d2280c5b3f29f04b17b63209855)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 支持LOS_TaskJoin 和 LOS_TaskDetach ([37bc11f](https://gitee.com/openharmony/kernel_liteos_a/commits/37bc11fa8837a3019a0a56702f401ec1845f6547)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 新增解析异常和backtrace信息脚本 ([7019fdf](https://gitee.com/openharmony/kernel_liteos_a/commits/7019fdfcbb33c660e8aa9fd399d5fccbd7e23b49)), closes [#I47](https://gitee.com/openharmony/kernel_liteos_a/issues/I47)
+* 调度tick响应时间计算优化 ([f47da44](https://gitee.com/openharmony/kernel_liteos_a/commits/f47da44b39be7fa3e9b5031d7b79b9bef1fd4fbc))
+* 调度去进程化，优化进程线程依赖关系 ([dc479fb](https://gitee.com/openharmony/kernel_liteos_a/commits/dc479fb7bd9cb8441e4e47d44b42110ea07d76a2))
+* 调度相关模块间依赖优化 ([0e3936c](https://gitee.com/openharmony/kernel_liteos_a/commits/0e3936c4f8b8bcfc48d283a6d53413e0fc0619b3)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 进程cpup占用率结构优化为动态分配 ([f06e090](https://gitee.com/openharmony/kernel_liteos_a/commits/f06e090a1085a654fd726fbc3c3a1c2bc703d663)), closes [#I4](https://gitee.com/openharmony/kernel_liteos_a/issues/I4)
+* 进程rlimit修改为动态分配,减少静态内存占用 ([cf8446c](https://gitee.com/openharmony/kernel_liteos_a/commits/cf8446c94112ed6993a2e6e71e793d83a72689d5)), closes [#I4EZY5](https://gitee.com/openharmony/kernel_liteos_a/issues/I4EZY5)
+
+### BREAKING CHANGES
+
+* 1. 删除 LOS_CirBufLock()，LOS_CirBufUnlock()内核对外接口
+2. LOS_CirBufWrite()，LOS_CirBufRead()由原先内部不进行上/解锁操作，变为默认已包含上/解锁操作。
+* 新增支持API:
+
+LOS_LmsCheckPoolAdd使能检测指定内存池
+LOS_LmsCheckPoolDel不检测指定内存池
+LOS_LmsAddrProtect为指定内存段上锁，不允许访问
+LOS_LmsAddrDisableProtect去能指定内存段的访问保护
+* 1.新增一系列perf的对外API，位于los_perf.h中.
+    LOS_PerfInit配置采样数据缓冲区
+    LOS_PerfStart开启Perf采样
+    LOS_PerfStop停止Perf采样
+    LOS_PerfConfig配置Perf采样事件
+    LOS_PerfDataRead读取采样数据
+    LOS_PerfNotifyHookReg 注册采样数据缓冲区的钩子函数
+    LOS_PerfFlushHookReg 注册缓冲区刷cache的钩子
+
+2. 用户态新增perf命令
+【Usage】:
+./perf [start] /[start id] Start perf.
+./perf [stop] Stop perf.
+./perf [read nBytes] Read nBytes raw data from perf buffer and print out.
+./perf [list] List events to be used in -e.
+./perf [stat] or [record] <option> <command>
+         -e, event selector. use './perf list' to list available events.
+         -p, event period.
+         -o, perf data output filename.
+         -t, taskId filter(whiltelist), if not set perf will sample all tasks.
+         -s, type of data to sample defined in PerfSampleType los_perf.h.
+         -P, processId filter(whiltelist), if not set perf will sample all processes.
+         -d, whether to prescaler (once every 64 counts), which only take effect on cpu cycle hardware event.
+
+
+#  (2021-09-30)
+
+
+### Bug Fixes
+
+*  A核代码告警清零 ([698756d](https://gitee.com/openharmony/kernel_liteos_a/commits/698756d1e6dfb11b9f874c02ce6a1496646f2c27)), closes [#I4378](https://gitee.com/openharmony/kernel_liteos_a/issues/I4378)
+*  A核告警消除 ([d16bfd0](https://gitee.com/openharmony/kernel_liteos_a/commits/d16bfd005a6dae78df2df3ad55cf21e0716dfae9)), closes [#I46KF6](https://gitee.com/openharmony/kernel_liteos_a/issues/I46KF6)
+* 3518平台, 异常测试进程无法正常退出 ([23937a2](https://gitee.com/openharmony/kernel_liteos_a/commits/23937a239f50d1487e89f3184e4f4b933d6842c6)), closes [#I3V8R5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3V8R5)
+* add (void) to GetFileMappingList method ([56b8eca](https://gitee.com/openharmony/kernel_liteos_a/commits/56b8ecaf171671c0fe97f1dd1f191bebb7812a51)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* add capability and amend smoke testcase ([c9d69e2](https://gitee.com/openharmony/kernel_liteos_a/commits/c9d69e2d1bde57c67068cc36f6a79327d5db5daf))
+* add fchdir api ([e828cbd](https://gitee.com/openharmony/kernel_liteos_a/commits/e828cbdeac7d60bfd6ed98c75a9958ee8ec7b672))
+* add fchmod api ([2f214bf](https://gitee.com/openharmony/kernel_liteos_a/commits/2f214bf4de6c31875c77e84b1763e96bc5ceb669))
+* add fststfs api and unitest ([4c57aa2](https://gitee.com/openharmony/kernel_liteos_a/commits/4c57aa26ad3644ce2429effc8e8fe7fd3c52ebc2))
+* add product_path parameter for driver build ([88fe4eb](https://gitee.com/openharmony/kernel_liteos_a/commits/88fe4eb3e1eafa6d1e32c7b96579a07f5a8c6e35)), closes [#I3PQ10](https://gitee.com/openharmony/kernel_liteos_a/issues/I3PQ10)
+* add syscall for ppoll & add 2 testcases ([defedb6](https://gitee.com/openharmony/kernel_liteos_a/commits/defedb6fdf0806da4a39e22408544cdfb405f2ff))
+* avoid compile warning ignored ([eca711b](https://gitee.com/openharmony/kernel_liteos_a/commits/eca711bb64a7c806ae34c8483cac73fe22b0104f)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* A核codex修改 ([ec977a1](https://gitee.com/openharmony/kernel_liteos_a/commits/ec977a1c7e9ba4ea6621ceb1d0d10e586148208d)), closes [#I40B1](https://gitee.com/openharmony/kernel_liteos_a/issues/I40B1)
+* BBOX使用预留物理内存缓存故障日志 ([2ad176e](https://gitee.com/openharmony/kernel_liteos_a/commits/2ad176e587d5ed7106831a25d386a88e26192e2b)), closes [#I41](https://gitee.com/openharmony/kernel_liteos_a/issues/I41)
+* bootargs解析与rootfs挂载解耦，并支持自定义bootargs参数 ([80473f0](https://gitee.com/openharmony/kernel_liteos_a/commits/80473f0975fe6fd4c4eae3a8a473674ad2dd1293)), closes [#I41CL8](https://gitee.com/openharmony/kernel_liteos_a/issues/I41CL8)
+* **build:** clang10.0.1支持lto，去掉冗余判断 ([73223ae](https://gitee.com/openharmony/kernel_liteos_a/commits/73223ae7e652b7cd9f1e1848c32b2b2573d07b2a))
+* **build:** fix rootfsdir.sh target directory not exist ([21bf2b8](https://gitee.com/openharmony/kernel_liteos_a/commits/21bf2b889931787fb18ca7ea238291fd57e76d51)), closes [#I3NHQ0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3NHQ0)
+* **build:** 去除冗余单板相关的宏配置 ([471de36](https://gitee.com/openharmony/kernel_liteos_a/commits/471de3663ea8b63f7448162edc0293b8723dcefc))
+* clang10 lld could not recognized Oz ([87a0006](https://gitee.com/openharmony/kernel_liteos_a/commits/87a0006d5e1976fdf5efe4be383921610eb04ec6))
+* clang相关编译选项隔离 ([77dcef4](https://gitee.com/openharmony/kernel_liteos_a/commits/77dcef4bc0c92d0141f7a3be0addd4d5cb533b0b)), closes [#I444](https://gitee.com/openharmony/kernel_liteos_a/issues/I444)
+* codex ([101a55d](https://gitee.com/openharmony/kernel_liteos_a/commits/101a55d1199530d621f809976f0024aa8295cce8))
+* codex clean ([b5370af](https://gitee.com/openharmony/kernel_liteos_a/commits/b5370af822c8e81ed2248ac8aa3bb479a0db9dae)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* compile error when fatfs disabled ([fd3f407](https://gitee.com/openharmony/kernel_liteos_a/commits/fd3f4072b5c3dff710013ccdaddf114b0e13f435))
+* console compile bug fix ([f8441a0](https://gitee.com/openharmony/kernel_liteos_a/commits/f8441a0cdea301449416b0c0477dc48a05b6ab4e))
+* correct spelling ([c66fe03](https://gitee.com/openharmony/kernel_liteos_a/commits/c66fe0313f76ba41992b4864c93cf82934378ad3))
+* Correctly handle the return value of LOS_EventRead in QuickstartListen. ([0e0ab81](https://gitee.com/openharmony/kernel_liteos_a/commits/0e0ab81ff9474cffd5e60a8ee741840eac5d737b)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Ctrl-C move out of LOS_MAGIC_KEY_ENABLE ([40f239a](https://gitee.com/openharmony/kernel_liteos_a/commits/40f239a7d4673dc740c853b1011b5072e48385b7))
+* Delete useless 'exc interaction' macros and function declarations. ([d2f2679](https://gitee.com/openharmony/kernel_liteos_a/commits/d2f26790716c9f76589c4a7d6fa5518f9ccd743c)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* dereference NULL point bug fix ([deaa564](https://gitee.com/openharmony/kernel_liteos_a/commits/deaa564a66b83c9fe19a37b8a061ec9064ece354))
+* do not build toybox temporarily ([044f2c7](https://gitee.com/openharmony/kernel_liteos_a/commits/044f2c7c17c68e10aeccc3af0c222cfc722d194c))
+* do not override existing libs ([8118408](https://gitee.com/openharmony/kernel_liteos_a/commits/8118408123e75f7f5a4ab9101e388be6bba0dcda))
+* **doc:** 修复README_zh-HK.md的链接错误 ([f1b4c87](https://gitee.com/openharmony/kernel_liteos_a/commits/f1b4c87bc44650348504bc00b3f6f94491c341a0))
+* fatfs memory leak ([fbfd71d](https://gitee.com/openharmony/kernel_liteos_a/commits/fbfd71dfe3b5555ef09e542d96a630dfba636daa))
+* fix function name OsSchedSetIdleTaskSchedParam ([8f8c038](https://gitee.com/openharmony/kernel_liteos_a/commits/8f8c038b217d5ba2518413bfc1ba857587d47442))
+* Fix kernel page fault exception handling causing system exception. ([a89fb57](https://gitee.com/openharmony/kernel_liteos_a/commits/a89fb57f5795236b93fd19ee2d7a059cae1b2b1b)), closes [#I3RAN4](https://gitee.com/openharmony/kernel_liteos_a/issues/I3RAN4)
+* fix length typo ([12d98b1](https://gitee.com/openharmony/kernel_liteos_a/commits/12d98b144b70e726d3fd31ddc9d17ed855d0ec1b))
+* fix mq function by enable mq_notify api ([4427142](https://gitee.com/openharmony/kernel_liteos_a/commits/4427142d734df8f95f4599093392904abacc5c93))
+* Fix quickstart codingstyle ([2e011b6](https://gitee.com/openharmony/kernel_liteos_a/commits/2e011b672f6b96ea7e0db066a07e3f9fb6ba5df3)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* fix stored typo ([d25560f](https://gitee.com/openharmony/kernel_liteos_a/commits/d25560f8ac3216670d198cbbb25891c394e0b3c2))
+* fix syscall faccessat,fstatfs,fstatat & add 6 testcases ([aa1cd24](https://gitee.com/openharmony/kernel_liteos_a/commits/aa1cd245a5711e5b53c328b688da5ddc2e783d5f))
+* fix the inappropriate errno in FatFs ([af61187](https://gitee.com/openharmony/kernel_liteos_a/commits/af61187587411dca38ff62e720451f08f19c1c82)), closes [#I3O8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3O8)
+* fix typo in quickstart ([3b2ff4b](https://gitee.com/openharmony/kernel_liteos_a/commits/3b2ff4b71fc5ae1dc74180c33fd66f69da0059d1)), closes [#I3M1S8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3M1S8)
+* Fix wrong judgment in los_trace.c to avoid null pointer access. ([4d863e9](https://gitee.com/openharmony/kernel_liteos_a/commits/4d863e985b6372f7895db57b602b662dba5cadd0)), closes [#I3RT9](https://gitee.com/openharmony/kernel_liteos_a/issues/I3RT9)
+* Identical condition 'ret<0', second condition is always false. :bug: ([1348809](https://gitee.com/openharmony/kernel_liteos_a/commits/1348809807548dd481286a55a6677a9169fcd705))
+* init进程收到子进程退出信号后，调用fork重新拉起进程，会导致系统卡死 ([35a2f3a](https://gitee.com/openharmony/kernel_liteos_a/commits/35a2f3af33a5dba1e0ba36587efced8fead97223)), closes [#I41](https://gitee.com/openharmony/kernel_liteos_a/issues/I41)
+* kernel crashed after rmdir the umounted folder ([ac0d083](https://gitee.com/openharmony/kernel_liteos_a/commits/ac0d083b1c89c4ad3fdaab0347d11f174d0185cb))
+* kernel crashed when delete a umounted folder ([f305d1f](https://gitee.com/openharmony/kernel_liteos_a/commits/f305d1f702a770010125a0f4f0152ffefeeec5c4))
+* kernel crashed when delete a umounted folder ([c6e9212](https://gitee.com/openharmony/kernel_liteos_a/commits/c6e921241b1cf26bcbfeea44e20f6b596512e259))
+* **kernel_test:** 内核mem/shm冒烟用例重复运行失败 ([0676578](https://gitee.com/openharmony/kernel_liteos_a/commits/0676578aae09c101d79e7a276823e849df293e29)), closes [#I3TH4](https://gitee.com/openharmony/kernel_liteos_a/issues/I3TH4)
+* L1 toybox 命令功能实现 ([2ff44c4](https://gitee.com/openharmony/kernel_liteos_a/commits/2ff44c4938d2e66ce60e9497c505eb6e97efc8c2)), closes [#I41N2](https://gitee.com/openharmony/kernel_liteos_a/issues/I41N2)
+* liteipc max data size too small ([4dc421e](https://gitee.com/openharmony/kernel_liteos_a/commits/4dc421e3decdaae60219d533c4a93dbc9334e35f))
+* LiteOS_A BBOX Codex整改 ([6a5a032](https://gitee.com/openharmony/kernel_liteos_a/commits/6a5a0326d2b18ffacce5d38fb351530973c2f245)), closes [#I43](https://gitee.com/openharmony/kernel_liteos_a/issues/I43)
+* Liteos-a创建的文件夹在Ubuntu中不可见 ([a9fc1e0](https://gitee.com/openharmony/kernel_liteos_a/commits/a9fc1e0e5d3e5eb8a34c568a8d147320a9afebe1)), closes [#I3XMY6](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XMY6)
+* lookup new vnode may cause parent vnode freeing ([902a11d](https://gitee.com/openharmony/kernel_liteos_a/commits/902a11de9a4b08e799820fb87942cb2171b9e095)), closes [#I3MYP4](https://gitee.com/openharmony/kernel_liteos_a/issues/I3MYP4)
+* **mini:** fix compile error in mini liteos_a ([e13cb3b](https://gitee.com/openharmony/kernel_liteos_a/commits/e13cb3bcc4e74d4c49c31d290d686f99a4e81e3f))
+* minimal compile ([ac8c2c6](https://gitee.com/openharmony/kernel_liteos_a/commits/ac8c2c6d5b9ede0e46b48212f0b3447605a613c4))
+* misspell ([08980ea](https://gitee.com/openharmony/kernel_liteos_a/commits/08980eac3c249ec6a6717d8a04fb0be7716053a1))
+* mkdir -p is more robust ([e38f9a9](https://gitee.com/openharmony/kernel_liteos_a/commits/e38f9a98c9d373db8381af707c5996d1fefef64e))
+* mksh compile bug fix ([d8263b1](https://gitee.com/openharmony/kernel_liteos_a/commits/d8263b1e91d76706d52df321ef642c1c8297e8e4)), closes [#I3ZMR7](https://gitee.com/openharmony/kernel_liteos_a/issues/I3ZMR7)
+* modify event API description ([937734b](https://gitee.com/openharmony/kernel_liteos_a/commits/937734b1e9f5fc52e0ac727549bd2e4b4c864e3c))
+* move nuttx head file back ([4c8a86e](https://gitee.com/openharmony/kernel_liteos_a/commits/4c8a86ece7cafa8f74441bacc74c7788c0a1b780)), closes [#I4443](https://gitee.com/openharmony/kernel_liteos_a/issues/I4443)
+* nanosleep 接口的rmtp参数被错误清零 ([9458de9](https://gitee.com/openharmony/kernel_liteos_a/commits/9458de9ac664cd75540c8b638b9a6caf82812fc8)), closes [#I41U0](https://gitee.com/openharmony/kernel_liteos_a/issues/I41U0)
+* no exception information output, when the system is abnormal ([5bf4d1c](https://gitee.com/openharmony/kernel_liteos_a/commits/5bf4d1c7128e6718611bbec23cb4373bcb3bfe55))
+* no exception information output, when the system is abnormal ([28aa777](https://gitee.com/openharmony/kernel_liteos_a/commits/28aa777191e7b41e4f1f346ab79f8688edc59c6d))
+* no exception information output, when the system is abnormal after holding ([0ed8adf](https://gitee.com/openharmony/kernel_liteos_a/commits/0ed8adfe3ae59672e284331d40ef3b9e0bc8e094))
+* Optimiz macro of quickstart cmd ([cb140a4](https://gitee.com/openharmony/kernel_liteos_a/commits/cb140a4442c02dd0b1925cc58deecbf4da36dcea)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Optimize /dev/quickstart permissions. ([4e24b57](https://gitee.com/openharmony/kernel_liteos_a/commits/4e24b572897c33e1b2723122c0e13d3931096bae)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Optimize quickstart node implementation ([4abd2e0](https://gitee.com/openharmony/kernel_liteos_a/commits/4abd2e0247b14718bb21756fb446142140d30a88)), closes [#I3R8O8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3R8O8)
+* OsGerCurrSchedTimeCycle 函数存在拼写错误 ([53ced1a](https://gitee.com/openharmony/kernel_liteos_a/commits/53ced1a85edc3d06230225ced3916772f432243f)), closes [#I446](https://gitee.com/openharmony/kernel_liteos_a/issues/I446)
+* OsGetArgsAddr声明所在头文件不正确 ([14bd753](https://gitee.com/openharmony/kernel_liteos_a/commits/14bd753aa8beb49af887c8d0aedaefa446409760)), closes [#I41](https://gitee.com/openharmony/kernel_liteos_a/issues/I41)
+* parent point of vnode found by VfsHashGet should be updated ([f32caa5](https://gitee.com/openharmony/kernel_liteos_a/commits/f32caa52c67eca20d58676be4e0439acbb4c5ac3)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* PathCacheFree try to free name field in struct PathCache ([9f47faf](https://gitee.com/openharmony/kernel_liteos_a/commits/9f47faff732609cf2249f104b94ed55f3ef133bb)), closes [#I3NTH9](https://gitee.com/openharmony/kernel_liteos_a/issues/I3NTH9)
+* PathCacheMemoryDump miscalculate the RAM usage of PathCache ([87da7c7](https://gitee.com/openharmony/kernel_liteos_a/commits/87da7c794c9bc8e311ae5242820fbf8aefd8d558)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Provide a separate configuration macro for boot environment in RAM. ([e28e06b](https://gitee.com/openharmony/kernel_liteos_a/commits/e28e06b08f5b28091153e584cb9d93014a9f2b10))
+* Provide a separate configuration macro for boot environment in RAM. ([bc67393](https://gitee.com/openharmony/kernel_liteos_a/commits/bc67393a67f714e0a8165b6103e53699c676341c))
+* Provide a separate configuration macro for boot environment in RAM. ([f13b90e](https://gitee.com/openharmony/kernel_liteos_a/commits/f13b90e4308ba3d60683799b9ce62fb3705ac277)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* race condition in liteipc ([7e2aef2](https://gitee.com/openharmony/kernel_liteos_a/commits/7e2aef2480b15f71ee0e089cef4443f578e03dbb)), closes [#I3PW5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3PW5)
+* rebuild mksh depends on rebuild.sh script ([bef4ab9](https://gitee.com/openharmony/kernel_liteos_a/commits/bef4ab9835dec865898c74337dfb7154718b94aa))
+* remove redundant headfile ([73a7777](https://gitee.com/openharmony/kernel_liteos_a/commits/73a777777e1b834192f6bb2c0e8bd03c69765c11)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Remove redundant invalid codes ([fe05df4](https://gitee.com/openharmony/kernel_liteos_a/commits/fe05df40ae710632adb1bd54fb04ad4a8e0c1429)), closes [#I3R70](https://gitee.com/openharmony/kernel_liteos_a/issues/I3R70)
+* Show conflicting files for git apply or patch -p command ([35f7957](https://gitee.com/openharmony/kernel_liteos_a/commits/35f79579758644cbcac6005f894be21f34f42b99)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* SIOCGIFCONF ioctl malloc size error in kernel ([bfd27e7](https://gitee.com/openharmony/kernel_liteos_a/commits/bfd27e78b259eedbd4c30548e80c9b4d789d26e1)), closes [#I3XEZ3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XEZ3)
+* smp启动代码解耦及内存映射关系解耦 ([3bb3173](https://gitee.com/openharmony/kernel_liteos_a/commits/3bb3173604dc4dea09301f61da402974185dc112)), closes [#I41P8](https://gitee.com/openharmony/kernel_liteos_a/issues/I41P8)
+* some branch in format does not release the vnode mutex properly ([9b2b700](https://gitee.com/openharmony/kernel_liteos_a/commits/9b2b700fa0e3a8edadb38f09c917a3e3f013347f)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Sortlink, the response time to insert the node should be inserted into the back of the existing node. ([1323874](https://gitee.com/openharmony/kernel_liteos_a/commits/1323874389030c55fb053fead12ca1c6654d8851)), closes [#I3PSJ8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3PSJ8)
+* statfs can't get f_bfree and f_bavail of a FAT12/FAT16 partition ([9503c4a](https://gitee.com/openharmony/kernel_liteos_a/commits/9503c4a9fc30aaa8ea2031d4fb794436f3c98055)), closes [#I3Q0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Q0)
+* SysOpenat返回值应该为进程fd，而非系统全局fd。 ([3457c0b](https://gitee.com/openharmony/kernel_liteos_a/commits/3457c0b11debb2cf5d4abe325c2510a750654512)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* the total used vnode number not increased after unlink a file under ([4f514a1](https://gitee.com/openharmony/kernel_liteos_a/commits/4f514a16af5a3f3b9c4ea182de774297afb17f66)), closes [#I3TS1](https://gitee.com/openharmony/kernel_liteos_a/issues/I3TS1)
+* tick 动态化计算优化，消除中断执行时间对系统总体时间的影响，保证软件定时器的响应精度。 ([8df3e8c](https://gitee.com/openharmony/kernel_liteos_a/commits/8df3e8c96515a1907455a9bbc61426f43c803c62)), closes [#I43](https://gitee.com/openharmony/kernel_liteos_a/issues/I43)
+* toybox update ([c3245b3](https://gitee.com/openharmony/kernel_liteos_a/commits/c3245b3ce317eb58c8dad58fdfc7f094b9b9794b))
+* toybox命令升级 ([76f45b3](https://gitee.com/openharmony/kernel_liteos_a/commits/76f45b3fb2783d1cab45a6ba08787c29dfa2c948)), closes [#I41N2](https://gitee.com/openharmony/kernel_liteos_a/issues/I41N2)
+* update LOS_DL_LIST_IS_END comment ([900269b](https://gitee.com/openharmony/kernel_liteos_a/commits/900269bd4645252d898f6d3b73de01d8548c960c))
+* userfs分区的起始地址与大小改为通过bootargs配置 ([2e2b142](https://gitee.com/openharmony/kernel_liteos_a/commits/2e2b14205f4b81c7483ab42d62f144487097e9a4)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* VnodeInUseIter and VnodeFreeAll used to be recursive ([5f6656c](https://gitee.com/openharmony/kernel_liteos_a/commits/5f6656cb36a2ffb0b290aeb53981aba7501e80b2)), closes [#I3NN3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3NN3)
+* 以g_sysSchedStartTime是否为0判断时间轴是否生效存在极限场景导致调度时间不生效 ([67ac8c4](https://gitee.com/openharmony/kernel_liteos_a/commits/67ac8c4c586adc371ece56700fd42371ca7fc885)), closes [#I45HP5](https://gitee.com/openharmony/kernel_liteos_a/issues/I45HP5)
+* 修复FATFS中不同内部接口不支持FAT12/FAT16 FAT表结束标志 ([33f5c70](https://gitee.com/openharmony/kernel_liteos_a/commits/33f5c70e6c8781758d2bfde0f60ca3d6ec7d543f)), closes [#I409R6](https://gitee.com/openharmony/kernel_liteos_a/issues/I409R6)
+* 修复kill进程时，因liteipc阻塞的进程概率无法退出问题 ([7de43bb](https://gitee.com/openharmony/kernel_liteos_a/commits/7de43bb004a12f926550f0b36ca3c2fa610feb27)), closes [#I3XX7](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XX7)
+* 修复MagicKey数组越界访问 ([071cd62](https://gitee.com/openharmony/kernel_liteos_a/commits/071cd6268aeaaef702387dacaf4ef1ffbb7618fc)), closes [#I3U4N9](https://gitee.com/openharmony/kernel_liteos_a/issues/I3U4N9)
+* 修复mprotect修改地址区间的权限后，相应的区间名丢失问题 ([e425187](https://gitee.com/openharmony/kernel_liteos_a/commits/e425187d176a5e09bc5253faefc9cfc8454da0a3)), closes [#I43R40](https://gitee.com/openharmony/kernel_liteos_a/issues/I43R40)
+* 修复mq_close关闭后仍然占用文件描述符的问题 ([590c7b4](https://gitee.com/openharmony/kernel_liteos_a/commits/590c7b4e22662781d05ad035a785e985d573ec33)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* 修复mqueue问题 ([26ee8b8](https://gitee.com/openharmony/kernel_liteos_a/commits/26ee8b836e346e641de4ecd72284f5d377bca6f8)), closes [#I43P4](https://gitee.com/openharmony/kernel_liteos_a/issues/I43P4)
+* 修复sigwait等待到的信号值与获取的siginfo中的值不一致 ([ed7defb](https://gitee.com/openharmony/kernel_liteos_a/commits/ed7defbd439c345a07159d40eb04433afd530004)), closes [#I3M12](https://gitee.com/openharmony/kernel_liteos_a/issues/I3M12)
+* 修复了LOSCFG_FS_FAT_VIRTUAL_PARTITION宏开关错误作用域引起的功能错误 ([acda419](https://gitee.com/openharmony/kernel_liteos_a/commits/acda419a2d773ea890052a16ee66b4872f941fbb)), closes [#I3W1](https://gitee.com/openharmony/kernel_liteos_a/issues/I3W1)
+* 修复了内核的VFAT测试用例 ([a8384b5](https://gitee.com/openharmony/kernel_liteos_a/commits/a8384b5db2274d50a350910d7cfd3fc36b4f4103)), closes [#I3XF3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XF3)
+* 修复内核access chmod chown接口 ([56a95b9](https://gitee.com/openharmony/kernel_liteos_a/commits/56a95b9ec903f815f9199ac65ca318e00a83b2ed)), closes [#I3Z5L6](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Z5L6)
+* 修复内核c库的makefile中被优化函数替换的高频函数依然参与了编译的问题 ([6f6dc4f](https://gitee.com/openharmony/kernel_liteos_a/commits/6f6dc4f24c8ab05a6d42da46a9fa41d74a477bd7)), closes [#I3XGM8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XGM8)
+* 修复内核堆完整性检查逻辑中访问非法指针导致系统异常问题。 ([30f5ab8](https://gitee.com/openharmony/kernel_liteos_a/commits/30f5ab89b72d45f596b15af82a8e8e01add7977d)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* 修复启动框架debug模式下-Werror=maybe-uninitialized告警以及符号链接不进镜像的隐患 ([4c02415](https://gitee.com/openharmony/kernel_liteos_a/commits/4c024159a9600745863e49ee955308470a5b657b)), closes [#I3T5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3T5)
+* 修复开机概率挂死 ([2e82c36](https://gitee.com/openharmony/kernel_liteos_a/commits/2e82c361f73b2119613c3571c48faae8ec41d4eb)), closes [#I3SWY2](https://gitee.com/openharmony/kernel_liteos_a/issues/I3SWY2)
+* 修复文档链接失效问题 ([42a3a6c](https://gitee.com/openharmony/kernel_liteos_a/commits/42a3a6c51bfca4ade8ce94084ea2f8eb1c86a137)), closes [#I45297](https://gitee.com/openharmony/kernel_liteos_a/issues/I45297)
+* 修改/proc/mounts显示格式 ([6860246](https://gitee.com/openharmony/kernel_liteos_a/commits/6860246cfaac6f540665e79bbc4c3d54c419b092)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* 修改clock_gettime接口适配posix标准测试用例011输入clk_id错误时返回值ESRCH为EINVAL. ([f8cf6e6](https://gitee.com/openharmony/kernel_liteos_a/commits/f8cf6e6439ee017fe8e0d4ecfc9949c28fa6775f)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* 修改DoNanoSleep 以纳秒为单位 ([6917e08](https://gitee.com/openharmony/kernel_liteos_a/commits/6917e08431689ccbd5a30e9a39b67016ffb64d0a)), closes [#I3Z9](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Z9)
+* 修改某些平台保存bbox日志失败的问题 ([8f6a1dd](https://gitee.com/openharmony/kernel_liteos_a/commits/8f6a1dd33c59164070e8d2fb5abbd3e76ef8ac8e)), closes [#I41](https://gitee.com/openharmony/kernel_liteos_a/issues/I41)
+* 修改默认窗口宽度到400 ([09c491c](https://gitee.com/openharmony/kernel_liteos_a/commits/09c491ca1fd6d3110eafb0d07e45b25bdc3bd5d0)), closes [#I40](https://gitee.com/openharmony/kernel_liteos_a/issues/I40)
+* 关闭jffs和fat后，rootfs配置也被相应关闭，导致nand介质的rootfs不可用。 ([0ea476b](https://gitee.com/openharmony/kernel_liteos_a/commits/0ea476b9741fabd3c255c2770688f587920cf509)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* 内核态在console初始化完成后，使用printf无法正常打印 ([44ce696](https://gitee.com/openharmony/kernel_liteos_a/commits/44ce6969048c2e252f3f9d66fa485c77bdab8ae7)), closes [#I3UG00](https://gitee.com/openharmony/kernel_liteos_a/issues/I3UG00)
+* 去掉冗余的strip操作 ([7819d15](https://gitee.com/openharmony/kernel_liteos_a/commits/7819d15b3619681ae37a1349a6bec2440c829ae9)), closes [#I43767](https://gitee.com/openharmony/kernel_liteos_a/issues/I43767)
+* 合并进程栈两个地址连续的region ([42f374d](https://gitee.com/openharmony/kernel_liteos_a/commits/42f374dd7a353f1c8227e92fa92827c1c7b32424)), closes [#I43](https://gitee.com/openharmony/kernel_liteos_a/issues/I43)
+* 在内核提示No idle TCB时，增加打印当前系统任务信息，以方便问题定位。 ([11a9b00](https://gitee.com/openharmony/kernel_liteos_a/commits/11a9b00d43a6dbe9fba9f6eb07d78a9d226c28f8)), closes [#I434](https://gitee.com/openharmony/kernel_liteos_a/issues/I434)
+* 增加表头，内容以制表符分栏。 ([e9ad6b7](https://gitee.com/openharmony/kernel_liteos_a/commits/e9ad6b71c3b1136414672cd21b339ded7a02dfb9)), closes [#I3W2M9](https://gitee.com/openharmony/kernel_liteos_a/issues/I3W2M9)
+* 将用户态内存调测解析脚本移至tools目录下 ([85b4cb7](https://gitee.com/openharmony/kernel_liteos_a/commits/85b4cb7a67b717984d3ebf68115c7139cc61d690)), closes [#I42T9](https://gitee.com/openharmony/kernel_liteos_a/issues/I42T9)
+* 恢复了FATFS设置卷标的功能 ([9515d53](https://gitee.com/openharmony/kernel_liteos_a/commits/9515d53dccc9a6458bfbaf8e15143928f05cb660)), closes [#I3Y5G8](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Y5G8)
+* 解决kill进程时无法保证进程的已持有的内核资源合理释放. ([cf89f01](https://gitee.com/openharmony/kernel_liteos_a/commits/cf89f016e93f28f8d72e6f5de08640d08a155908)), closes [#I3S0N0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3S0N0)
+* 解决不同环境下计算的rootfs的size偏小，导致mcopy造成的disk full错误 ([c54879b](https://gitee.com/openharmony/kernel_liteos_a/commits/c54879b54875abece53b1f64072cfacbd2e1970e)), closes [#I3IA06](https://gitee.com/openharmony/kernel_liteos_a/issues/I3IA06)
+* 设置qemu默认userfs大小/修改qemu驱动目录 ([1d952a2](https://gitee.com/openharmony/kernel_liteos_a/commits/1d952a254a6e7ec2f70f7112eb27355cfd01ba4d)), closes [#I3XW96](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XW96) [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+
+
+### Features
+
+* active mksh & toybox ([cacb4f0](https://gitee.com/openharmony/kernel_liteos_a/commits/cacb4f0103ecb2d1b7af54d84957f88d3e9443d2)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* Add /dev/quickstart to support synchronous communication between processes in user mode startup. ([46b63f7](https://gitee.com/openharmony/kernel_liteos_a/commits/46b63f71537789743ed2f3f337c1809ee4900d71)), closes [#I3OHO5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3OHO5)
+* add /proc/fd file to dump the pid/fd/path information ([600dded](https://gitee.com/openharmony/kernel_liteos_a/commits/600dded31e80df275ed08c326c0ce3d1857d8dd8)), closes [#I3WB5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3WB5)
+* add /proc/fs_cache to display cache info ([231cb6b](https://gitee.com/openharmony/kernel_liteos_a/commits/231cb6be27380948bc48136ae2e02c28450f47a8)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* add /proc/fs_cache to display cache info ([53c6d96](https://gitee.com/openharmony/kernel_liteos_a/commits/53c6d96c6f97cb006216769f8b73f50fba3bc325)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* add and fix some syscall ([ce849f2](https://gitee.com/openharmony/kernel_liteos_a/commits/ce849f2145e1569517c5244c9ffcaebed53f3a66))
+* add blackbox for liteos_a ([a195aac](https://gitee.com/openharmony/kernel_liteos_a/commits/a195aac9fb60b0163f9eebb29084287d226bd14c)), closes [#I406](https://gitee.com/openharmony/kernel_liteos_a/issues/I406)
+* add blackbox for liteos_a ([425975e](https://gitee.com/openharmony/kernel_liteos_a/commits/425975e4811023e31a520979c20ea2562224d9d0)), closes [#I3NN7](https://gitee.com/openharmony/kernel_liteos_a/issues/I3NN7)
+* add clear cache cmd to /proc/fs_cache ([3d1cf68](https://gitee.com/openharmony/kernel_liteos_a/commits/3d1cf683f37a6f75e9db2ce1f11ec93159b77663)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* add liteos patch ability ([98ca844](https://gitee.com/openharmony/kernel_liteos_a/commits/98ca8441fe75ee1c3318a6a09376fd72f5a51350))
+* add support for gn build system ([a8805a6](https://gitee.com/openharmony/kernel_liteos_a/commits/a8805a65aab9109b915364fccf36c8328f636e48))
+* add uid/gid for ProcFs ([6780659](https://gitee.com/openharmony/kernel_liteos_a/commits/67806596a3c0df9a54893d8c74ebe9da98d7fb06)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* A核proc文件系统在echo模式下新增write的功能 ([f10dd7c](https://gitee.com/openharmony/kernel_liteos_a/commits/f10dd7c135d37a5fb0d78610d5ece5807d01eb1f)), closes [#I3T6](https://gitee.com/openharmony/kernel_liteos_a/issues/I3T6)
+* build OHOS_Image from kernel ([abf4d8f](https://gitee.com/openharmony/kernel_liteos_a/commits/abf4d8fb252631aca9d46211762880a23be2a0b1))
+* **build:** make liteos_config_file available as gn argument ([f9a9077](https://gitee.com/openharmony/kernel_liteos_a/commits/f9a907772f506ca7e2d84e96d4d17cffc7dae50f))
+* **build:** 使用xts -notest选项时，内核用例不参与编译构建和用例编译配置方式调整 ([9bdf716](https://gitee.com/openharmony/kernel_liteos_a/commits/9bdf716407c125c9877b6f49c2133112c18cdabc))
+* don't apply module_swith on configs of config ([f3beb4b](https://gitee.com/openharmony/kernel_liteos_a/commits/f3beb4b273c9a76fbfaffe57302f27d2a74cd2ba))
+* enable gn build for toybox and mksh ([c54bfa1](https://gitee.com/openharmony/kernel_liteos_a/commits/c54bfa16e3907482c252e9738192df869c63326e))
+* fatfs支持符号链接功能 ([e50cf0b](https://gitee.com/openharmony/kernel_liteos_a/commits/e50cf0be6f6d118022b6d79c5177aece574ba150)), closes [#I3V8D1](https://gitee.com/openharmony/kernel_liteos_a/issues/I3V8D1)
+* **file system:** add memory-based romfs ([c4595d2](https://gitee.com/openharmony/kernel_liteos_a/commits/c4595d25042b188570d991a815009764c37f3cb3)), closes [#I3S0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3S0)
+* introduce mksh toybox to rootfs ([41c7689](https://gitee.com/openharmony/kernel_liteos_a/commits/41c7689dfa49c52fb15705ce15ef22a278fbf2ef))
+* L0-L1 支持Trace ([dc9ec68](https://gitee.com/openharmony/kernel_liteos_a/commits/dc9ec6856fe14aa604f037f55f17a3ba2bafb098)), closes [#I46WA0](https://gitee.com/openharmony/kernel_liteos_a/issues/I46WA0)
+* L1支持低功耗投票框架 ([21d8ac8](https://gitee.com/openharmony/kernel_liteos_a/commits/21d8ac8752469f6e0dc2d50d28b75421f665385a)), closes [#I3VS5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3VS5)
+* **libc:** upgrade optimized-routines to v21.02 ([1ec8d5a](https://gitee.com/openharmony/kernel_liteos_a/commits/1ec8d5a454658e95c4acb821d0878f357f4e82ad))
+* **make:** optimize makefiles and remove some unused files ([0e26094](https://gitee.com/openharmony/kernel_liteos_a/commits/0e260949c962158a263d4b0ad45fe9f6843d6e30))
+* Open macro for ADC moudule ([c71ec9d](https://gitee.com/openharmony/kernel_liteos_a/commits/c71ec9d7e8574078a9dc2a8463f3141cca3d625a))
+* **QEMU_ARM_VIRT_CA7:** 使能FAT文件系统编译选项 ([49856dc](https://gitee.com/openharmony/kernel_liteos_a/commits/49856dc1e0de1c5e92346c83eda641dfb1bb16be))
+* support .mkshrc ([51a50c9](https://gitee.com/openharmony/kernel_liteos_a/commits/51a50c95b4cd47b6931523926b728d1c0ff8988b)), closes [#I3Y5](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Y5)
+* support link/symlink/readlink ([6eddc86](https://gitee.com/openharmony/kernel_liteos_a/commits/6eddc869d349be59860bfd84ff10b7579a9b00a9)), closes [#I3Q0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Q0)
+* support toybox in qemu ([5618319](https://gitee.com/openharmony/kernel_liteos_a/commits/561831928bb1ad1871b2d60d2bba2d67488cea5f)), closes [#I3V17](https://gitee.com/openharmony/kernel_liteos_a/issues/I3V17)
+* timer_create支持以SIGEV_THREAD方式创建定时器 ([e5f6bf0](https://gitee.com/openharmony/kernel_liteos_a/commits/e5f6bf05567c2d193f3746caca502199e7b81e92)), closes [#I3](https://gitee.com/openharmony/kernel_liteos_a/issues/I3)
+* using kconfiglib instead of kconfig ([8784694](https://gitee.com/openharmony/kernel_liteos_a/commits/878469468647a19f704e7ee2af696b0ba8ab775a))
+* vfs support sdcard hotplug ([2db80ec](https://gitee.com/openharmony/kernel_liteos_a/commits/2db80ecb389176b53c77807567895470bb180a06)), closes [#I44WH1](https://gitee.com/openharmony/kernel_liteos_a/issues/I44WH1)
+* **vfs:** vfs支持FD_CLOEXEC标记 ([27dca4d](https://gitee.com/openharmony/kernel_liteos_a/commits/27dca4d857ef8de6b4bb9302e0dd435be7e3284f)), closes [#I3U81](https://gitee.com/openharmony/kernel_liteos_a/issues/I3U81)
+* 删除zpfs冗余代码 ([3393479](https://gitee.com/openharmony/kernel_liteos_a/commits/3393479c52f4a9dfe2394bb32beb4b98fca8e171))
+* 基于汇编实现内核对用户态内存清零的功能 ([9db3407](https://gitee.com/openharmony/kernel_liteos_a/commits/9db3407589bb0b2d4a5772faac3130032bc0b8a9)), closes [#I3XXT0](https://gitee.com/openharmony/kernel_liteos_a/issues/I3XXT0)
+* 增加mount的MS_RDONLY标志的支持 ([8729f6e](https://gitee.com/openharmony/kernel_liteos_a/commits/8729f6ee57ea57bc664d076ff112c8726fedded9)), closes [#I3Z1W6](https://gitee.com/openharmony/kernel_liteos_a/issues/I3Z1W6)
+* 支持killpg和waitid ([dc3cc09](https://gitee.com/openharmony/kernel_liteos_a/commits/dc3cc094a75c6da65d87522930afea06106d3933))
+* 新增toybox reboot命令 ([e567a10](https://gitee.com/openharmony/kernel_liteos_a/commits/e567a10d021c3e0fe02d6911dbe8687255c67ffa)), closes [#I3YQ7](https://gitee.com/openharmony/kernel_liteos_a/issues/I3YQ7)
+* 给开发者提供系统信息导出Hidumper工具。 ([cb17fa5](https://gitee.com/openharmony/kernel_liteos_a/commits/cb17fa50ed28e6e8f59b7d68ede13c759b983311)), closes [#I3NN7](https://gitee.com/openharmony/kernel_liteos_a/issues/I3NN7)
+* 自研shell命令回补 ([7bc68f4](https://gitee.com/openharmony/kernel_liteos_a/commits/7bc68f454ff5fbf415712c9b8479b8c832f68417)), closes [#I44U0](https://gitee.com/openharmony/kernel_liteos_a/issues/I44U0)
+
+
+### Performance Improvements
+
+* assign '-1' to uninitialized variable: ret ([e0a27ba](https://gitee.com/openharmony/kernel_liteos_a/commits/e0a27badde20868cf3a5b4a44305b90af00e4f3f))
+
+
+### Reverts
+
+* Revert "fix: 修改默认窗口宽度到400" ([1878849](https://gitee.com/openharmony/kernel_liteos_a/commits/187884937cd087e39a28c033c41033163d6b4766)), closes [#I42X9](https://gitee.com/openharmony/kernel_liteos_a/issues/I42X9)
+
+
+### BREAKING CHANGES
+
+* 1.新增一系列trace的对外API，位于los_trace.h中.
+        LOS_TRACE_EASY简易插桩
+        LOS_TRACE标准插桩
+        LOS_TraceInit配置Trace缓冲区的地址和大小
+        LOS_TraceStart开启事件记录
+        LOS_TraceStop停止事件记录
+        LOS_TraceRecordDump输出Trace缓冲区数据
+        LOS_TraceRecordGet获取Trace缓冲区的首地址
+        LOS_TraceReset清除Trace缓冲区中的事件
+        LOS_TraceEventMaskSet设置事件掩码，仅记录某些模块的事件
+        LOS_TraceHwiFilterHookReg注册过滤特定中断号事件的钩子函数
+* **vfs:** 执行exec类函数后，进程拥有的文件描述符情况发生变化：修改前，默认关闭所有的进程文件描述符，0，1，2重新打开；修改后，除非文件描述符拥有FD_CLOEXEC标记，否则该描述符不会被关闭。
+
+
+
--- a/3
+++ b/3
@@ -82,9 +82,6 @@ endif
 ifeq ($(LOSCFG_STORAGE_SPINAND), y)
 FSTYPE = yaffs2
 endif
-ifeq ($(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7), y)
-FSTYPE = jffs2
-endif
 ROOTFS_DIR = $(OUT)/rootfs
 ROOTFS_ZIP = $(OUT)/rootfs.zip

--- a/README.md
+++ b/README.md
@@ -4,10 +4,10 @@
 -   [Directory Structure](#section161941989596)
 -   [Constraints](#section119744591305)
 -   [Usage](#section741617511812)
-    -   [Preparations](#section1579912573329)
-    -   [Source Code Acquisition](#section11443189655)
-    -   [Compilation and Building](#section2081013992812)
-
+-   [Preparations](#section1579912573329)
+-   [Source Code Acquisition](#section11443189655)
+-   [Compilation and Building](#section2081013992812)
+-   [Contribution](#section1371123476304)
 -   [Repositories Involved](#section1371113476307)

 ## Introduction<a name="section11660541593"></a>
@@ -67,24 +67,33 @@ The OpenHarmony LiteOS Cortex-A is a new-generation kernel developed based on th

 ## Usage<a name="section741617511812"></a>

-OpenHarmony LiteOS Cortex-A supports the  [Hi3516D V300](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-lite-introduction-hi3516.md). You can develop and run your applications based on this development board.
+OpenHarmony LiteOS Cortex-A supports the  [Hi3516D V300](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-appendix-hi3516.md). You can develop and run your applications based on this development board.

 ### Preparations<a name="section1579912573329"></a>

-You need to set up the compilation environment on Linux.
+You need to set up the compilation environment on Ubuntu.

-   [Setting Up Ubuntu Development Environment](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-lite-env-setup.md)
-   For Hi3516D V300, see  [Setting Up the Hi3516 Development Environment](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-lite-steps-hi3516-setting.md).
+-   [Setting Up Ubuntu Development Environment](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/Readme-EN.md)

 ### Source Code Acquisition<a name="section11443189655"></a>

-Download and decompress a set of source code on a Linux server to acquire the  [source code](https://gitee.com/openharmony/docs/blob/master/en/device-dev/get-code/sourcecode-acquire.md).
+Download and decompress a set of source code on a Ubuntu server to acquire the  [source code](https://gitee.com/openharmony/docs/blob/master/en/device-dev/get-code/sourcecode-acquire.md).

 ### Compilation and Building<a name="section2081013992812"></a>

-For details about how to develop the first application, see:
+For details about how to develop the first application, see: [Developing the First Example Program Running on Hi3516](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-pkg-3516-helloworld.md)

-   [Developing the First Example Program Running on Hi3516](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-lite-steps-hi3516-running.md)
+For compilation, please refer to the [compilation instructions](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/quickstart-pkg-3516-build.md).
+
+## Contribution<a name="section1371123476304"></a>
+
+[How to involve](https://gitee.com/openharmony/docs/blob/HEAD/en/contribute/contribution.md)
+
+[Commit message spec](https://gitee.com/openharmony/kernel_liteos_a/wikis/Commit%20message%20%E8%A7%84%E8%8C%83)
+
+[C&C++ Secure Coding Guide](https://gitee.com/openharmony/docs/blob/master/en/contribute/OpenHarmony-c-cpp-secure-coding-guide.md)
+
+[LiteOS-A Kernel Coding Style Guide](https://gitee.com/openharmony/kernel_liteos_a/wikis/LiteOS-A%20%E5%86%85%E6%A0%B8%E7%BC%96%E7%A0%81%E8%A7%84%E8%8C%83%E6%8C%87%E5%8D%97)

 ## Repositories Involved<a name="section1371113476307"></a>

--- a/README_zh-HK.md
+++ b/README_zh-HK.md
@@ -4,10 +4,10 @@
 - [目錄](#section161941989596)
 - [約束](#section119744591305)
 - [使用說明](#section741617511812)
-    - [準備](#section1579912573329)
-    - [獲取源碼](#section11443189655)
-    - [編譯構建](#section2081013992812)
-
+- [準備](#section1579912573329)
+- [獲取源碼](#section11443189655)
+- [編譯構建](#section2081013992812)
+- [貢獻](#section1371123476304)
 - [相關倉](#section1371113476307)

 ## 簡介<a name="section11660541593"></a>
@@ -67,24 +67,33 @@ OpenHarmony LiteOS-A內核是基於Huawei LiteOS內核演進發展的新一代

 ## 使用說明<a name="section741617511812"></a>

-OpenHarmony LiteOS-A內核支持Hi3516DV300（[介紹](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-introduction-hi3516.md)）單板，開發者可基於此單板開發運行自己的應用程序。
+OpenHarmony LiteOS-A內核支持[Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-appendix-hi3516.md)單板，開發者可基於此單板開發運行自己的應用程序。

 ### 準備<a name="section1579912573329"></a>

-開發者需要在Linux上搭建編譯環境：
+開發者需要在Ubuntu上搭建編譯環境：

- [編譯環境凖備](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-env-setup.md);
- Hi3516DV300單板：參考[環境搭建](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-setting.md)。
+- [編譯環境凖備](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/Readme-CN.md);

 ### 獲取源碼<a name="section11443189655"></a>

-在Linux服務器上下載並解壓一套源代碼，源碼獲取方式參考[源碼獲取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。
+在Ubuntu服務器上下載並解壓一套源代碼，源碼獲取方式參考[源碼獲取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。

 ### 編譯構建<a name="section2081013992812"></a>

-開發者開發第一個應用程序可參考：
+開發者開發第一個應用程序可參考：[helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-pkg-3516-helloworld.md)。

- [helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-running.md)。
+編譯可以參考：[編譯指導](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-pkg-3516-build.md)
+
+## 貢獻<a name="section1371123476304"></a>
+
+[如何貢獻](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/contribute/%E5%8F%82%E4%B8%8E%E8%B4%A1%E7%8C%AE.md)
+
+[Commit message規範](https://gitee.com/openharmony/kernel_liteos_a/wikis/Commit%20message%20%E8%A7%84%E8%8C%83)
+
+[OpenHarmony C&C++ 安全編程指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/contribute/OpenHarmony-c-cpp-secure-coding-guide.md)
+
+[LiteOS-A 內核編碼規範指南](https://gitee.com/openharmony/kernel_liteos_a/wikis/LiteOS-A%20%E5%86%85%E6%A0%B8%E7%BC%96%E7%A0%81%E8%A7%84%E8%8C%83%E6%8C%87%E5%8D%97)

 ## 相關倉<a name="section1371113476307"></a>

--- a/README_zh.md
+++ b/README_zh.md
@@ -4,10 +4,10 @@
 -   [目录](#section161941989596)
 -   [约束](#section119744591305)
 -   [使用说明](#section741617511812)
-    -   [准备](#section1579912573329)
-    -   [获取源码](#section11443189655)
-    -   [编译构建](#section2081013992812)
-
+-   [准备](#section1579912573329)
+-   [获取源码](#section11443189655)
+-   [编译构建](#section2081013992812)
+-   [贡献](#section1371123476304)
 -   [相关仓](#section1371113476307)

 ## 简介<a name="section11660541593"></a>
@@ -69,24 +69,33 @@ OpenHarmony LiteOS-A内核是基于Huawei LiteOS内核演进发展的新一代

 ## 使用说明<a name="section741617511812"></a>

-OpenHarmony LiteOS-A内核支持[Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-introduction-hi3516.md)单板。开发者可基于此单板开发运行自己的应用程序。
+OpenHarmony LiteOS-A内核支持[Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-appendix-hi3516.md)单板。开发者可基于此单板开发运行自己的应用程序。

 ### 准备<a name="section1579912573329"></a>

-开发者需要在Linux上搭建编译环境：
+开发者需要在Ubuntu上搭建编译环境：

-   [编译环境准备](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-env-setup.md);
-   Hi3516DV300单板：参考[环境搭建](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-setting.md)。
+-   [编译环境准备](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/Readme-CN.md);

 ### 获取源码<a name="section11443189655"></a>

-在Linux服务器上下载并解压一套源代码，源码获取方式参考[源码获取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。
+在Ubuntu服务器源码获取方式参考: [源码获取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。

 ### 编译构建<a name="section2081013992812"></a>

-如果这是您的首次应用程序开发，可参考：
+如果这是您的首次应用程序开发，可参考：[helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-pkg-3516-helloworld.md)。

-   [helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-running.md)。
+编译可以参考：[编译指导](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-pkg-3516-build.md)
+
+## 贡献<a name="section1371123476304"></a>
+
+[如何贡献](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/contribute/%E5%8F%82%E4%B8%8E%E8%B4%A1%E7%8C%AE.md)
+
+[Commit message规范](https://gitee.com/openharmony/kernel_liteos_a/wikis/Commit%20message%20%E8%A7%84%E8%8C%83)
+
+[OpenHarmony C&C++ 安全编程指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/contribute/OpenHarmony-c-cpp-secure-coding-guide.md)
+
+[LiteOS-A 内核编码规范指南](https://gitee.com/openharmony/kernel_liteos_a/wikis/LiteOS-A%20%E5%86%85%E6%A0%B8%E7%BC%96%E7%A0%81%E8%A7%84%E8%8C%83%E6%8C%87%E5%8D%97)

 ## 相关仓<a name="section1371113476307"></a>

--- a/apps/config.mk
+++ b/apps/config.mk
@@ -58,6 +58,10 @@ APP_SUBDIRS += mksh
 APP_SUBDIRS += toybox
 endif

+ifeq ($(LOSCFG_KERNEL_LMS), y)
+APP_SUBDIRS += lms
+endif
+
 ifeq ($(LOSCFG_USER_INIT_DEBUG), y)
 APP_SUBDIRS += init
 endif
--- a/apps/lms/src/sample_usr_lms.c
+++ b/apps/lms/src/sample_usr_lms.c
@@ -231,7 +231,7 @@ int main(int argc, char * const *argv)
    printf("\n############### Lms Test start ###############\n");
    char *tmp = (char *)malloc(5000); /* 5000: test mem size */
    if (tmp == NULL) {
-        return;
+        return -1;
    }
    LmsMallocTest();
    LmsReallocTest();
@@ -246,4 +246,5 @@ int main(int argc, char * const *argv)
    LmsFreeTest();
    free(tmp);
    printf("\n############### Lms Test End ###############\n");
+    return 0;
 }
--- a/apps/shell/src/main.c
+++ b/apps/shell/src/main.c
@@ -49,7 +49,7 @@ ShellCB *OsGetShellCb()
    return g_shellCB;
 }

-void ShellDeinit(ShellCB *shellCB)
+static void ShellDeinit(ShellCB *shellCB)
 {
    (void)pthread_mutex_destroy(&shellCB->historyMutex);
    (void)pthread_mutex_destroy(&shellCB->keyMutex);
@@ -65,27 +65,23 @@ static int OsShellCreateTask(ShellCB *shellCB)

    ret = sched_getparam(getpid(), &param);
    if (ret != SH_OK) {
-        goto OUT;
+        return ret;
    }

    param.sched_priority = SHELL_PROCESS_PRIORITY_INIT;

    ret = sched_setparam(getpid(), &param);
    if (ret != SH_OK) {
-        goto OUT;
+        return ret;
    }

    ret = ShellTaskInit(shellCB);
    if (ret != SH_OK) {
-        goto OUT;
+        return ret;
    }

    shellCB->shellEntryHandle = pthread_self();
    return 0;
-
-OUT:
-    ShellDeinit(shellCB);
-    return ret;
 }

 static int DoShellExec(char **argv)
@@ -148,7 +144,7 @@ int main(int argc, char **argv)

    shellCB = (ShellCB *)malloc(sizeof(ShellCB));
    if (shellCB == NULL) {
-        goto ERR_OUT1;
+        return SH_NOK;
    }
    ret = memset_s(shellCB, sizeof(ShellCB), 0, sizeof(ShellCB));
    if (ret != SH_OK) {
@@ -176,7 +172,9 @@ int main(int argc, char **argv)
    g_shellCB = shellCB;
    ret = OsShellCreateTask(shellCB);
    if (ret != SH_OK) {
-        goto ERR_OUT3;
+        ShellDeinit(shellCB);
+        g_shellCB = NULL;
+        return ret;
    }

    ShellEntry(shellCB);
--- a/arch/arm/arm/src/include/los_hw_pri.h
+++ b/arch/arm/arm/src/include/los_hw_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -102,7 +102,7 @@ typedef struct {
 * Return      : pointer to the task context
 */
 extern VOID *OsTaskStackInit(UINT32 taskID, UINT32 stackSize, VOID *topStack, BOOL initFlag);
-extern VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTopOfStask, UINT32 parentStackSize);
+extern VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfStask, UINT32 parentStackSize);
 extern VOID OsUserTaskStackInit(TaskContext *context, UINTPTR taskEntry, UINTPTR stack);
 extern VOID OsInitSignalContext(const VOID *sp, VOID *signalContext, UINTPTR sigHandler, UINT32 signo, UINT32 param);
 extern void arm_clean_cache_range(UINTPTR start, UINTPTR end);
--- a/arch/arm/arm/src/los_hw.c
+++ b/arch/arm/arm/src/los_hw.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -103,7 +103,7 @@ LITE_OS_SEC_TEXT_INIT VOID *OsTaskStackInit(UINT32 taskID, UINT32 stackSize, VOI
    return (VOID *)taskContext;
 }

-LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTopOfStack, UINT32 parentStackSize)
+VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfStack, UINT32 parentStackSize)
 {
    LosTaskCB *task = OsCurrTaskGet();
    sig_cb *sigcb = &task->sig;
@@ -117,6 +117,10 @@ LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTop

    (VOID)memcpy_s(childStack, sizeof(TaskContext), cloneStack, sizeof(TaskContext));
    ((TaskContext *)childStack)->R0 = 0;
+    if (sp != 0) {
+        ((TaskContext *)childStack)->USP = TRUNCATE(sp, LOSCFG_STACK_POINT_ALIGN_SIZE);
+        ((TaskContext *)childStack)->ULR = 0;
+    }
 }

 LITE_OS_SEC_TEXT_INIT VOID OsUserTaskStackInit(TaskContext *context, UINTPTR taskEntry, UINTPTR stack)
--- a/compat/posix/include/mqueue.h
+++ b/compat/posix/include/mqueue.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -74,6 +74,10 @@ extern "C" {
 /* not support prio */
 #define MQ_PRIO_MAX 1

+#ifndef MAX_MQ_FD
+#define MAX_MQ_FD CONFIG_NQUEUE_DESCRIPTORS
+#endif
+
 typedef union send_receive_t {
    unsigned oth : 3;
    unsigned grp : 6;
--- a/compat/posix/src/misc.c
+++ b/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",
-                     KERNEL_NAME, KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE, __DATE__, __TIME__);
+    (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;
 }

--- a/compat/posix/src/mqueue.c
+++ b/compat/posix/src/mqueue.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -44,16 +44,19 @@

 #define FNONBLOCK   O_NONBLOCK

-#ifndef MAX_MQ_FD
-#define MAX_MQ_FD CONFIG_NQUEUE_DESCRIPTORS
-#endif
-
+#ifndef LOSCFG_IPC_CONTAINER
 /* GLOBALS */
 STATIC fd_set g_queueFdSet;
 STATIC struct mqarray g_queueTable[LOSCFG_BASE_IPC_QUEUE_LIMIT];
 STATIC pthread_mutex_t g_mqueueMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 STATIC struct mqpersonal *g_mqPrivBuf[MAX_MQ_FD];

+#define IPC_QUEUE_FD_SET g_queueFdSet
+#define IPC_QUEUE_TABLE  g_queueTable
+#define IPC_QUEUE_MUTEX  g_mqueueMutex
+#define IPC_QUEUE_MQ_PRIV_BUF g_mqPrivBuf
+#endif
+
 /* LOCAL FUNCTIONS */
 STATIC INLINE INT32 MqNameCheck(const CHAR *mqName)
 {
@@ -96,12 +99,12 @@ STATIC INLINE struct mqarray *GetMqueueCBByName(const CHAR *name)
    UINT32 mylen = strlen(name);

    for (index = 0; index < LOSCFG_BASE_IPC_QUEUE_LIMIT; index++) {
-        if ((g_queueTable[index].mq_name == NULL) || (strlen(g_queueTable[index].mq_name) != mylen)) {
+        if ((IPC_QUEUE_TABLE[index].mq_name == NULL) || (strlen(IPC_QUEUE_TABLE[index].mq_name) != mylen)) {
            continue;
        }

-        if (strncmp(name, (const CHAR *)(g_queueTable[index].mq_name), mylen) == 0) {
-            return &(g_queueTable[index]);
+        if (strncmp(name, (const CHAR *)(IPC_QUEUE_TABLE[index].mq_name), mylen) == 0) {
+            return &(IPC_QUEUE_TABLE[index]);
        }
    }
    return NULL;
@@ -170,8 +173,8 @@ STATIC struct mqpersonal *DoMqueueCreate(const struct mq_attr *attr, const CHAR
        goto ERROUT;
    }

-    if (g_queueTable[GET_QUEUE_INDEX(mqueueID)].mqcb == NULL) {
-        mqueueCB = &(g_queueTable[GET_QUEUE_INDEX(mqueueID)]);
+    if (IPC_QUEUE_TABLE[GET_QUEUE_INDEX(mqueueID)].mqcb == NULL) {
+        mqueueCB = &(IPC_QUEUE_TABLE[GET_QUEUE_INDEX(mqueueID)]);
        mqueueCB->mq_id = mqueueID;
    }

@@ -297,7 +300,7 @@ STATIC struct mqpersonal *MqGetPrivDataBuff(mqd_t personal)
        errno = EBADF;
        return NULL;
    }
-    return g_mqPrivBuf[id];
+    return IPC_QUEUE_MQ_PRIV_BUF[id];
 }

 /**
@@ -311,13 +314,13 @@ STATIC struct mqpersonal *MqGetPrivDataBuff(mqd_t personal)
 STATIC INT32 MqAllocSysFd(int maxfdp, struct mqpersonal *privateMqPersonal)
 {
    INT32 i;
-    fd_set *fdset = &g_queueFdSet;
+    fd_set *fdset = &IPC_QUEUE_FD_SET;
    for (i = 0; i < maxfdp; i++) {
        /* sysFd: used bit setting, and get the index of swtmrID buffer */
        if (fdset && !(FD_ISSET(i + MQUEUE_FD_OFFSET, fdset))) {
            FD_SET(i + MQUEUE_FD_OFFSET, fdset);
-            if (!g_mqPrivBuf[i]) {
-                g_mqPrivBuf[i] = privateMqPersonal;
+            if (!IPC_QUEUE_MQ_PRIV_BUF[i]) {
+                IPC_QUEUE_MQ_PRIV_BUF[i] = privateMqPersonal;
                return i + MQUEUE_FD_OFFSET;
            }
        }
@@ -328,10 +331,10 @@ STATIC INT32 MqAllocSysFd(int maxfdp, struct mqpersonal *privateMqPersonal)
 STATIC VOID MqFreeSysFd(mqd_t personal)
 {
    INT32 sysFd = (INT32)personal;
-    fd_set *fdset = &g_queueFdSet;
+    fd_set *fdset = &IPC_QUEUE_FD_SET;
    if (fdset && FD_ISSET(sysFd, fdset)) {
        FD_CLR(sysFd, fdset);
-        g_mqPrivBuf[sysFd - MQUEUE_FD_OFFSET] = NULL;
+        IPC_QUEUE_MQ_PRIV_BUF[sysFd - MQUEUE_FD_OFFSET] = NULL;
    }
 }

@@ -341,7 +344,7 @@ void MqueueRefer(int sysFd)
    struct mqarray *mqueueCB = NULL;
    struct mqpersonal *privateMqPersonal = NULL;

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    /* Get the personal sysFd and reset personal fd -1 */
    privateMqPersonal = MqGetPrivDataBuff((mqd_t)sysFd);
    if (privateMqPersonal == NULL) {
@@ -354,7 +357,7 @@ void MqueueRefer(int sysFd)

    privateMqPersonal->mq_refcount++;
 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return;
 }

@@ -498,7 +501,7 @@ mqd_t mq_open(const char *mqName, int openFlag, ...)
        return (mqd_t)-1;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    mqueueCB = GetMqueueCBByName(mqName);
    if ((UINT32)openFlag & (UINT32)O_CREAT) {
        if (mqueueCB != NULL) {
@@ -543,7 +546,7 @@ mqd_t mq_open(const char *mqName, int openFlag, ...)
        mqFd = (mqd_t)sysFd;
    }
 OUT:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return mqFd;
 }

@@ -552,7 +555,7 @@ int mq_close(mqd_t personal)
    INT32 ret = -1;
    struct mqpersonal *privateMqPersonal = NULL;

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);

    /* Get the personal sysFd and reset personal fd -1 */
    privateMqPersonal = MqGetPrivDataBuff(personal);
@@ -577,7 +580,7 @@ int mq_close(mqd_t personal)
    MqFreeSysFd(personal);

 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return ret;
 }

@@ -596,10 +599,10 @@ int OsMqGetAttr(mqd_t personal, struct mq_attr *mqAttr)
        return -1;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    if (privateMqPersonal->mq_status != MQ_USE_MAGIC) {
        errno = EBADF;
-        (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+        (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
        return -1;
    }

@@ -608,7 +611,7 @@ int OsMqGetAttr(mqd_t personal, struct mq_attr *mqAttr)
    mqAttr->mq_msgsize = mqueueCB->mqcb->queueSize - sizeof(UINT32);
    mqAttr->mq_curmsgs = mqueueCB->mqcb->readWriteableCnt[OS_QUEUE_READ];
    mqAttr->mq_flags = privateMqPersonal->mq_flags;
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return 0;
 }

@@ -626,10 +629,10 @@ int OsMqSetAttr(mqd_t personal, const struct mq_attr *mqSetAttr, struct mq_attr
        return -1;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    if (privateMqPersonal->mq_status != MQ_USE_MAGIC) {
        errno = EBADF;
-        (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+        (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
        return -1;
    }

@@ -641,7 +644,7 @@ int OsMqSetAttr(mqd_t personal, const struct mq_attr *mqSetAttr, struct mq_attr
    if (((UINT32)mqSetAttr->mq_flags & (UINT32)FNONBLOCK) == (UINT32)FNONBLOCK) {
        privateMqPersonal->mq_flags = (INT32)((UINT32)privateMqPersonal->mq_flags | (UINT32)FNONBLOCK);
    }
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return 0;
 }

@@ -662,7 +665,7 @@ int mq_unlink(const char *mqName)
        return -1;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    mqueueCB = GetMqueueCBByName(mqName);
    if (mqueueCB == NULL) {
        errno = ENOENT;
@@ -675,11 +678,11 @@ int mq_unlink(const char *mqName)
        ret = DoMqueueDelete(mqueueCB);
    }

-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return ret;

 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return -1;
 }

@@ -767,7 +770,7 @@ int mq_timedsend(mqd_t personal, const char *msg, size_t msgLen, unsigned int ms
    OS_MQ_GOTO_ERROUT_IF(!MqParamCheck(personal, msg, msgLen), errno);
    OS_MQ_GOTO_ERROUT_IF(msgPrio > (MQ_PRIO_MAX - 1), EINVAL);

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    privateMqPersonal = MqGetPrivDataBuff(personal);

    OS_MQ_GOTO_ERROUT_UNLOCK_IF(privateMqPersonal == NULL || privateMqPersonal->mq_status != MQ_USE_MAGIC, EBADF);
@@ -781,7 +784,7 @@ int mq_timedsend(mqd_t personal, const char *msg, size_t msgLen, unsigned int ms

    OS_MQ_GOTO_ERROUT_UNLOCK_IF(ConvertTimeout(privateMqPersonal->mq_flags, absTimeout, &absTicks) == -1, errno);
    mqueueID = mqueueCB->mq_id;
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);

    if (LOS_ListEmpty(&mqueueCB->mqcb->readWriteList[OS_QUEUE_READ])) {
        MqSendNotify(mqueueCB);
@@ -793,7 +796,7 @@ int mq_timedsend(mqd_t personal, const char *msg, size_t msgLen, unsigned int ms
    }
    return 0;
 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
 ERROUT:
    return -1;
 }
@@ -815,7 +818,7 @@ ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *
        *msgPrio = 0;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    privateMqPersonal = MqGetPrivDataBuff(personal);
    if (privateMqPersonal == NULL || privateMqPersonal->mq_status != MQ_USE_MAGIC) {
        errno = EBADF;
@@ -839,7 +842,7 @@ ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *

    receiveLen = msgLen;
    mqueueID = mqueueCB->mq_id;
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);

    err = LOS_QueueReadCopy(mqueueID, (VOID *)msg, &receiveLen, (UINT32)absTicks);
    if (map_errno(err) == ENOERR) {
@@ -849,7 +852,7 @@ ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *
    }

 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
 ERROUT:
    return -1;
 }
@@ -898,7 +901,7 @@ int OsMqNotify(mqd_t personal, const struct sigevent *sigev)
        goto ERROUT;
    }

-    (VOID)pthread_mutex_lock(&g_mqueueMutex);
+    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
    privateMqPersonal = MqGetPrivDataBuff(personal);
    if (privateMqPersonal == NULL) {
        goto OUT_UNLOCK;
@@ -936,10 +939,10 @@ int OsMqNotify(mqd_t personal, const struct sigevent *sigev)
        mqnotify->pid = LOS_GetCurrProcessID();
    }

-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
    return 0;
 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
+    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
 ERROUT:
    return -1;
 }
--- a/compat/posix/src/pthread.c
+++ b/compat/posix/src/pthread.c
@@ -240,9 +240,9 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
    taskInitParam.usTaskPrio   = (UINT16)userAttr.schedparam.sched_priority;
    taskInitParam.uwStackSize  = userAttr.stacksize;
    if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        taskInitParam.processID = OsGetKernelInitProcessID();
+        taskInitParam.processID = (UINTPTR)OsGetKernelInitProcess();
    } else {
-        taskInitParam.processID = OsCurrProcessGet()->processID;
+        taskInitParam.processID = (UINTPTR)OsCurrProcessGet();
    }
    if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {
        taskInitParam.uwResved = LOS_TASK_STATUS_DETACHED;
--- a/compat/posix/src/time.c
+++ b/compat/posix/src/time.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -117,7 +117,7 @@ STATIC INLINE BOOL ValidTimerID(UINT16 swtmrID)
    }

    /* check owner of this timer */
-    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != LOS_GetCurrProcessID()) {
+    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != (UINTPTR)OsCurrProcessGet()) {
        return FALSE;
    }

@@ -484,7 +484,7 @@ static int PthreadGetCputime(clockid_t clockID, struct timespec *ats)

    LosTaskCB *task = OsGetTaskCB(tid);

-    if (OsCurrTaskGet()->processID != task->processID) {
+    if (OsCurrTaskGet()->processCB != task->processCB) {
        return -EINVAL;
    }

@@ -599,13 +599,22 @@ int clock_gettime(clockid_t clockID, struct timespec *tp)

    switch (clockID) {
        case CLOCK_MONOTONIC_RAW:
+#ifdef LOSCFG_TIME_CONTAINER
+            tmp = OsTimeSpecAdd(hwTime, CLOCK_MONOTONIC_TIME_BASE);
+            tp->tv_sec = tmp.tv_sec;
+            tp->tv_nsec = tmp.tv_nsec;
+#else
            tp->tv_sec = hwTime.tv_sec;
            tp->tv_nsec = hwTime.tv_nsec;
+#endif
            break;
        case CLOCK_MONOTONIC:
            LOS_SpinLockSave(&g_timeSpin, &intSave);
            tmp = OsTimeSpecAdd(hwTime, g_accDeltaFromAdj);
            LOS_SpinUnlockRestore(&g_timeSpin, intSave);
+#ifdef LOSCFG_TIME_CONTAINER
+            tmp = OsTimeSpecAdd(tmp, CLOCK_MONOTONIC_TIME_BASE);
+#endif
            tp->tv_sec = tmp.tv_sec;
            tp->tv_nsec = tmp.tv_nsec;
            break;
@@ -639,7 +648,7 @@ int clock_gettime(clockid_t clockID, struct timespec *tp)

    return 0;

-    ERROUT:
+ERROUT:
    TIME_RETURN(EINVAL);
 }

@@ -748,7 +757,7 @@ static VOID SwtmrProc(UINTPTR tmrArg)
        /* Make sure that the para is valid */
        OS_GOTO_EXIT_IF(OS_TID_CHECK_INVALID(arg->tid), EINVAL);
        stcb = OsGetTaskCB(arg->tid);
-        ret = OsUserProcessOperatePermissionsCheck(stcb, stcb->processID);
+        ret = OsUserProcessOperatePermissionsCheck(stcb, stcb->processCB);
        OS_GOTO_EXIT_IF(ret != LOS_OK, -ret);

        /* Dispatch the signal to thread, bypassing normal task group thread
@@ -1087,8 +1096,7 @@ clock_t times(struct tms *buf)
 int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue)
 {
    UINT32 intSave;
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OsCurrProcessGet();
    timer_t timerID = 0;
    struct itimerspec spec;
    struct itimerspec ospec;
@@ -1141,8 +1149,7 @@ int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue

 int getitimer(int which, struct itimerval *value)
 {
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OsCurrProcessGet();
    struct itimerspec spec = {};

    int ret = LOS_OK;
--- a/drivers/block/disk/src/disk.c
+++ b/drivers/block/disk/src/disk.c
@@ -1465,7 +1465,7 @@ INT32 los_disk_init(const CHAR *diskName, const struct block_operations *bops,
    ret = VnodeLookup(diskName, &blkDriver, 0);
    if (ret < 0) {
        VnodeDrop();
-        ret = ENOENT;
+        PRINT_ERR("disk_init : %s, failed to find the vnode, ERRNO=%d\n", diskName, ret);
        goto DISK_FIND_ERROR;
    }
    struct block_operations *bops2 = (struct block_operations *)((struct drv_data *)blkDriver->data)->ops;
--- a/drivers/char/quickstart/src/quickstart.c
+++ b/drivers/char/quickstart/src/quickstart.c
@@ -112,7 +112,7 @@ static ssize_t QuickstartIoctl(struct file *filep, int cmd, unsigned long arg)
        return QuickstartNotify(arg);
    }

-    if (OsGetUserInitProcessID() != LOS_GetCurrProcessID()) {
+    if (LOS_GetCurrProcessID() != OS_USER_ROOT_PROCESS_ID) {
        PRINT_ERR("Permission denios!\n");
        return -EACCES;
    }
--- a/drivers/mtd/multi_partition/BUILD.gn
+++ b/drivers/mtd/multi_partition/BUILD.gn
@@ -39,10 +39,6 @@ kernel_module(module_name) {

  include_dirs = [ "$LITEOSTOPDIR/fs/jffs2/include" ]

-  if (defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)) {
-    include_dirs += [ "//device/qemu/drivers/cfiflash" ]
-  }
-
  public_configs = [ ":public" ]
 }

--- a/drivers/mtd/multi_partition/Makefile
+++ b/drivers/mtd/multi_partition/Makefile
@@ -36,10 +36,6 @@ LOCAL_SRCS :=  $(wildcard src/*.c)
 LOCAL_INCLUDE := \
    -I $(LITEOSTOPDIR)/fs/jffs2/include

-ifeq ($(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7), y)
-LOCAL_INCLUDE += -I $(LITEOSTOPDIR)/../../device/qemu/drivers/cfiflash
-endif
-
 LOCAL_FLAGS := $(LOCAL_INCLUDE)

 include $(MODULE)
--- a/drivers/mtd/multi_partition/src/mtd_partition.c
+++ b/drivers/mtd/multi_partition/src/mtd_partition.c
@@ -39,11 +39,6 @@
 #include "fs/driver.h"
 #include "mtd/mtd_legacy_lite.h"

-#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
-#include "cfiflash.h"
-#endif
-
-
 #define DRIVER_NAME_ADD_SIZE    3
 pthread_mutex_t g_mtdPartitionLock = PTHREAD_MUTEX_INITIALIZER;

@@ -134,17 +129,10 @@ static VOID MtdNorParamAssign(partition_param *spinorParam, const struct MtdDev
     * you can change the SPIBLK_NAME or SPICHR_NAME to NULL.
     */
    spinorParam->flash_mtd = (struct MtdDev *)spinorMtd;
-#ifndef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
    spinorParam->flash_ops = GetDevSpinorOps();
    spinorParam->char_ops = GetMtdCharFops();
    spinorParam->blockname = SPIBLK_NAME;
    spinorParam->charname = SPICHR_NAME;
-#else
-    spinorParam->flash_ops = GetCfiBlkOps();
-    spinorParam->char_ops = NULL;
-    spinorParam->blockname = CFI_DRIVER;
-    spinorParam->charname = NULL;
-#endif
    spinorParam->partition_head = g_spinorPartitionHead;
    spinorParam->block_size = spinorMtd->eraseSize;
 }
@@ -158,11 +146,7 @@ static VOID MtdDeinitSpinorParam(VOID)

 static partition_param *MtdInitSpinorParam(partition_param *spinorParam)
 {
-#ifndef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
    struct MtdDev *spinorMtd = GetMtd("spinor");
-#else
-    struct MtdDev *spinorMtd = GetCfiMtdDev();
-#endif
    if (spinorMtd == NULL) {
        return NULL;
    }
--- a/figures/OpenHarmony-LiteOS-A内核架构图.png
+++ b/figures/OpenHarmony-LiteOS-A内核架构图.png
--- a/figures/architecture-of-the-openharmony-liteos-cortex-a-kernel.png
+++ b/figures/architecture-of-the-openharmony-liteos-cortex-a-kernel.png
--- a/fs/include/fs/fd_table.h
+++ b/fs/include/fs/fd_table.h
@@ -59,6 +59,9 @@ struct files_struct {
    spinlock_t workdir_lock;
    char workdir[PATH_MAX];
 #endif
+#ifdef LOSCFG_CHROOT
+    struct Vnode *rootVnode;
+#endif
 };

 typedef struct ProcessCB LosProcessCB;
--- a/fs/include/fs/mount.h
+++ b/fs/include/fs/mount.h
@@ -39,6 +39,7 @@
 #define MS_NOSYNC 2

 struct MountOps;
+struct fsmap_t;

 struct Mount {
    LIST_ENTRY mountList;              /* mount list */
@@ -69,8 +70,11 @@ typedef int (*foreach_mountpoint_t)(const char *devpoint,
                                    struct statfs *statbuf,
                                    void *arg);

-struct Mount* MountAlloc(struct Vnode* vnode, struct MountOps* mop);
-LIST_HEAD* GetMountList(void);
+struct Mount *MountAlloc(struct Vnode *vnode, struct MountOps *mop);
+LIST_HEAD *GetMountList(void);
+#ifdef LOSCFG_MNT_CONTAINER
+LIST_HEAD *GetMountCache(void);
+#endif
 int foreach_mountpoint(foreach_mountpoint_t handler, void *arg);
 int ForceUmountDev(struct Vnode *dev);
 #endif
--- a/fs/jffs2/jffs2.patch
+++ b/fs/jffs2/jffs2.patch
@@ -2778,7 +2778,11 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 	ri->version = cpu_to_je32(++f->highest_version);
 +	ri->uid = cpu_to_je16(inode->i_uid);
 +	ri->gid = cpu_to_je16(inode->i_gid);
-+
+ 
+-	ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
+-		from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
+-	ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
+-		from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
 +	if (ivalid & CHG_UID) {
 +		if (((c_uid != inode->i_uid) || (attr->attr_chg_uid != inode->i_uid)) && (!IsCapPermit(CAP_CHOWN))) {
 +			jffs2_complete_reservation(c);
@@ -2800,16 +2804,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 +			ri->gid = cpu_to_je16(attr->attr_chg_gid);
 +		}
 +	}
- 
-	ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
-		from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
-	ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
-		from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
-
-	if (ivalid & ATTR_MODE)
-		ri->mode = cpu_to_jemode(iattr->ia_mode);
-	else
-		ri->mode = cpu_to_jemode(inode->i_mode);
+
 +	if (ivalid & CHG_MODE) {
 +		if (!IsCapPermit(CAP_FOWNER) && (c_uid != inode->i_uid)) {
 +			jffs2_complete_reservation(c);
@@ -2823,6 +2818,10 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 +		}
 +	}
 
+-	if (ivalid & ATTR_MODE)
+-		ri->mode = cpu_to_jemode(iattr->ia_mode);
+-	else
+-		ri->mode = cpu_to_jemode(inode->i_mode);
 +	if (ivalid & CHG_ATIME) {
 +		if ((c_uid != inode->i_uid) || (attr->attr_chg_uid != inode->i_uid)) {
 +			return -EPERM;
@@ -2832,7 +2831,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 +	} else {
 +		ri->atime = cpu_to_je32(inode->i_atime);
 +	}
-+
+ 
 +	if (ivalid & CHG_MTIME) {
 +		if ((c_uid != inode->i_uid) || (attr->attr_chg_uid != inode->i_uid)) {
 +			return -EPERM;
@@ -2884,7 +2883,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 	if (IS_ERR(new_metadata)) {
 		jffs2_complete_reservation(c);
 		jffs2_free_raw_inode(ri);
-@@ -147,23 +140,20 @@ int jffs2_do_setattr (struct inode *inod
+@@ -147,23 +140,20 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 		return PTR_ERR(new_metadata);
 	}
 	/* It worked. Update the inode */
@@ -2917,7 +2916,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 		f->metadata = NULL;
 	} else {
 		f->metadata = new_metadata;
-@@ -182,315 +172,201 @@ int jffs2_do_setattr (struct inode *inod
+@@ -182,315 +172,201 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 	   We are protected from a simultaneous write() extending i_size
 	   back past iattr->ia_size, because do_truncate() holds the
 	   generic inode semaphore. */
@@ -2936,31 +2935,43 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 {
 -	struct inode *inode = d_inode(dentry);
 -	int rc;
-
-	rc = setattr_prepare(dentry, iattr);
-	if (rc)
-		return rc;
-
-	rc = jffs2_do_setattr(inode, iattr);
-	if (!rc && (iattr->ia_valid & ATTR_MODE))
-		rc = posix_acl_chmod(inode, inode->i_mode);
 +	/* We can forget about this inode for now - drop all
 +	 *  the nodelists associated with it, etc.
 +	 */
 +	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 +	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+
+	jffs2_do_clear_inode(c, f);
+}
+ 
+-	rc = setattr_prepare(dentry, iattr);
+-	if (rc)
+-		return rc;
+static struct jffs2_inode *ilookup(struct super_block *sb, uint32_t ino)
+{
+	struct jffs2_inode *node = NULL;
+ 
+-	rc = jffs2_do_setattr(inode, iattr);
+-	if (!rc && (iattr->ia_valid & ATTR_MODE))
+-		rc = posix_acl_chmod(inode, inode->i_mode);
+	if (sb->s_root == NULL) {
+		return NULL;
+	}
 
 -	return rc;
-+	jffs2_do_clear_inode(c, f);
+	// Check for this inode in the cache
+	Jffs2NodeLock();
+	(void)Jffs2HashGet(&sb->s_node_hash_lock, &sb->s_node_hash[0], sb, ino, &node);
+	Jffs2NodeUnlock();
+	return node;
 }
 
 -int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
-+static struct jffs2_inode *ilookup(struct super_block *sb, uint32_t ino)
+struct jffs2_inode *new_inode(struct super_block *sb)
 {
 -	struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 -	unsigned long avail;
-+	struct jffs2_inode *node = NULL;
- 
+-
 -	buf->f_type = JFFS2_SUPER_MAGIC;
 -	buf->f_bsize = 1 << PAGE_SHIFT;
 -	buf->f_blocks = c->flash_size >> PAGE_SHIFT;
@@ -2979,47 +2990,35 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -	spin_unlock(&c->erase_completion_lock);
 -
 -	buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
-+	if (sb->s_root == NULL) {
-+		return NULL;
-+	}
+	struct jffs2_inode *inode = NULL;
 
 -	return 0;
-+	// Check for this inode in the cache
-+	Jffs2NodeLock();
-+	(void)Jffs2HashGet(&sb->s_node_hash_lock, &sb->s_node_hash[0], sb, ino, &node);
-+	Jffs2NodeUnlock();
-+	return node;
- }
+-}
+	inode = zalloc(sizeof (struct jffs2_inode));
+	if (inode == NULL)
+		return 0;
+ 
+	D2(PRINTK("malloc new_inode %x ####################################\n",
+		inode));
 
-
 -void jffs2_evict_inode (struct inode *inode)
-+struct jffs2_inode *new_inode(struct super_block *sb)
- {
+-{
 -	/* We can forget about this inode for now - drop all
 -	 *  the nodelists associated with it, etc.
 -	 */
 -	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 -	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
-+	struct jffs2_inode *inode = NULL;
+	inode->i_sb = sb;
+	inode->i_ino = 1;
+	inode->i_nlink = 1;    // Let JFFS2 manage the link count
+	inode->i_size = 0;
+	LOS_ListInit((&(inode->i_hashlist)));
 
 -	jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
 -		  __func__, inode->i_ino, inode->i_mode);
 -	truncate_inode_pages_final(&inode->i_data);
 -	clear_inode(inode);
 -	jffs2_do_clear_inode(c, f);
-+	inode = zalloc(sizeof (struct jffs2_inode));
-+	if (inode == NULL)
-+		return 0;
-+
-+	D2(PRINTK("malloc new_inode %x ####################################\n",
-+		inode));
-+
-+	inode->i_sb = sb;
-+	inode->i_ino = 1;
-+	inode->i_nlink = 1;    // Let JFFS2 manage the link count
-+	inode->i_size = 0;
-+	LOS_ListInit((&(inode->i_hashlist)));
-+
 +	return inode;
 }
 
@@ -3084,16 +3083,16 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -	inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 -
 -	set_nlink(inode, f->inocache->pino_nlink);
+-
+-	inode->i_blocks = (inode->i_size + 511) >> 9;
 +	inode->i_atime = je32_to_cpu(latest_node.atime);
 +	inode->i_mtime = je32_to_cpu(latest_node.mtime);
 +	inode->i_ctime = je32_to_cpu(latest_node.ctime);
 +	inode->i_nlink = f->inocache->pino_nlink;
 
-	inode->i_blocks = (inode->i_size + 511) >> 9;
+-	switch (inode->i_mode & S_IFMT) {
 +	(void)mutex_unlock(&f->sem);
 
-	switch (inode->i_mode & S_IFMT) {
-
 -	case S_IFLNK:
 -		inode->i_op = &jffs2_symlink_inode_operations;
 -		inode->i_link = f->target;
@@ -3163,20 +3162,21 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 	jffs2_dbg(1, "jffs2_read_inode() returning\n");
 -	unlock_new_inode(inode);
 -	return inode;
-
+	Jffs2NodeUnlock();
+ 
 -error_io:
 -	ret = -EIO;
 -error:
 -	mutex_unlock(&f->sem);
 -	iget_failed(inode);
 -	return ERR_PTR(ret);
-}
-+	Jffs2NodeUnlock();
+	return inode;
+ }
 
 -void jffs2_dirty_inode(struct inode *inode, int flags)
 -{
 -	struct iattr iattr;
-
+ 
 -	if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 -		jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
 -			  __func__, inode->i_ino);
@@ -3195,16 +3195,19 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -	iattr.ia_ctime = inode->i_ctime;
 -
 -	jffs2_do_setattr(inode, &iattr);
-+	return inode;
- }
+-}
+// -------------------------------------------------------------------------
+// Decrement the reference count on an inode. If this makes the ref count
+// zero, then this inode can be freed.
 
 -int jffs2_do_remount_fs(struct super_block *sb, struct fs_context *fc)
-{
+int jffs2_iput(struct jffs2_inode *i)
+ {
 -	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 -
 -	if (c->flags & JFFS2_SB_FLAG_RO && !sb_rdonly(sb))
 -		return -EROFS;
- 
+-
 -	/* We stop if it was running, then restart if it needs to.
 -	   This also catches the case where it was stopped and this
 -	   is just a remount to restart it.
@@ -3215,12 +3218,9 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -		jffs2_flush_wbuf_pad(c);
 -		mutex_unlock(&c->alloc_sem);
 -	}
-+// -------------------------------------------------------------------------
-+// Decrement the reference count on an inode. If this makes the ref count
-+// zero, then this inode can be freed.
-+
-+int jffs2_iput(struct jffs2_inode *i)
-+{
+-
+-	if (!(fc->sb_flags & SB_RDONLY))
+-		jffs2_start_garbage_collect_thread(c);
 +	// Called in jffs2_find
 +	// (and jffs2_open and jffs2_ops_mkdir?)
 +	// super.c jffs2_fill_super,
@@ -3242,9 +3242,6 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 +	free(i);
 +	Jffs2NodeUnlock();
 
-	if (!(fc->sb_flags & SB_RDONLY))
-		jffs2_start_garbage_collect_thread(c);
-
 -	fc->sb_flags |= SB_NOATIME;
 	return 0;
 }
@@ -3351,7 +3348,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 {
 	/*
 	 * Pick a inocache hash size based on the size of the medium.
-@@ -510,117 +386,17 @@ static int calculate_inocache_hashsize(u
+@@ -510,118 +386,17 @@ static int calculate_inocache_hashsize(uint32_t flash_size)
 	return hashsize;
 }
 
@@ -3447,8 +3444,9 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -	jffs2_free_ino_caches(c);
 -	jffs2_free_raw_node_refs(c);
 -	kvfree(c->blocks);
- out_inohash:
 -	jffs2_clear_xattr_subsystem(c);
+-	jffs2_sum_exit(c);
+- out_inohash:
 -	kfree(c->inocache_list);
 - out_wbuf:
 -	jffs2_flash_cleanup(c);
@@ -3457,8 +3455,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -}
 -
 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
-				   struct jffs2_inode_info *f)
-+		   	    struct jffs2_inode_info *f)
+ 				   struct jffs2_inode_info *f)
 {
 -	iput(OFNI_EDONI_2SFFJ(f));
 +	struct jffs2_inode *node = OFNI_EDONI_2SFFJ(f);
@@ -3473,7 +3470,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 	struct jffs2_inode_cache *ic;
 
 	if (unlinked) {
-@@ -668,72 +444,9 @@ struct jffs2_inode_info *jffs2_gc_fetch_
+@@ -669,72 +444,9 @@ struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 		   Just iget() it, and if read_inode() is necessary that's OK.
 		*/
 		inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
@@ -5565,7 +5562,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 
 #define DEFAULT_EMPTY_SCAN_SIZE 256
 
-@@ -74,7 +73,7 @@ static int file_dirty(struct jffs2_sb_in
+@@ -74,7 +73,7 @@ static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 		return ret;
 	if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
 		return ret;
@@ -5574,15 +5571,13 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	   think it's recoverable now. */
 	jeb->dirty_size += jeb->wasted_size;
 	c->dirty_size += jeb->wasted_size;
-@@ -95,40 +94,26 @@ int jffs2_scan_medium(struct jffs2_sb_in
+@@ -95,40 +94,26 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
 	unsigned char *flashbuf = NULL;
 	uint32_t buf_size = 0;
 	struct jffs2_summary *s = NULL; /* summary info collected by the scan process */
 -#ifndef __ECOS
 -	size_t pointlen, try_size;
-+	struct super_block *sb = NULL;
-+	struct MtdNorDev *device = NULL;
- 
+-
 -	ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen,
 -			(void **)&flashbuf, NULL);
 -	if (!ret && pointlen < c->mtd->size) {
@@ -5595,6 +5590,9 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 -	if (ret && ret != -EOPNOTSUPP)
 -		jffs2_dbg(1, "MTD point failed %d\n", ret);
 -#endif
+	struct super_block *sb = NULL;
+	struct MtdNorDev *device = NULL;
+
 	if (!flashbuf) {
 		/* For NAND it's quicker to read a whole eraseblock at a time,
 		   apparently */
@@ -5622,7 +5620,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	}
 
 	if (jffs2_sum_active()) {
-@@ -140,7 +125,9 @@ int jffs2_scan_medium(struct jffs2_sb_in
+@@ -140,7 +125,9 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
 		}
 	}
 
@@ -5633,7 +5631,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 		struct jffs2_eraseblock *jeb = &c->blocks[i];
 
 		cond_resched();
-@@ -269,19 +256,12 @@ int jffs2_scan_medium(struct jffs2_sb_in
+@@ -269,14 +256,10 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
 			ret = -EIO;
 			goto out;
 		}
@@ -5643,20 +5641,13 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	}
 	ret = 0;
  out:
-	if (buf_size)
-		kfree(flashbuf);
-#ifndef __ECOS
-	else
-		mtd_unpoint(c->mtd, 0, c->mtd->size);
-#endif
+-	jffs2_sum_reset_collected(s);
 -	kfree(s);
-+
 +	kfree(flashbuf);
-+
- 	return ret;
- }
- 
-@@ -411,7 +391,7 @@ static int jffs2_scan_xref_node(struct j
+  out_buf:
+ 	if (buf_size)
+ 		kfree(flashbuf);
+@@ -413,7 +396,7 @@ static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock
 	if (!ref)
 		return -ENOMEM;
 
@@ -5665,7 +5656,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	 * and AFTER xattr_ref is marked as a dead xref,
 	 * ref->xid is used to store 32bit xid, xd is not used
 	 * ref->ino is used to store 32bit inode-number, ic is not used
-@@ -484,10 +464,10 @@ static int jffs2_scan_eraseblock (struct
+@@ -486,10 +469,10 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 		struct jffs2_sum_marker *sm;
 		void *sumptr = NULL;
 		uint32_t sumlen;
@@ -5678,7 +5669,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 			if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
 				sumptr = buf + je32_to_cpu(sm->offset);
 				sumlen = c->sector_size - je32_to_cpu(sm->offset);
-@@ -500,13 +480,13 @@ static int jffs2_scan_eraseblock (struct
+@@ -502,13 +485,13 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 				buf_len = sizeof(*sm);
 
 			/* Read as much as we want into the _end_ of the preallocated buffer */
@@ -5695,7 +5686,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 			if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
 				sumlen = c->sector_size - je32_to_cpu(sm->offset);
 				sumptr = buf + buf_size - sumlen;
-@@ -521,18 +501,15 @@ static int jffs2_scan_eraseblock (struct
+@@ -523,18 +506,15 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 					sumptr = kmalloc(sumlen, GFP_KERNEL);
 					if (!sumptr)
 						return -ENOMEM;
@@ -5718,7 +5709,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 				}
 			}
 
-@@ -543,7 +520,7 @@ static int jffs2_scan_eraseblock (struct
+@@ -545,7 +525,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 
 			if (buf_size && sumlen > buf_size)
 				kfree(sumptr);
@@ -5727,7 +5718,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 			   If it returns positive, that's a block classification
 			   (i.e. BLK_STATE_xxx) so return that too.
 			   If it returns zero, fall through to full scan. */
-@@ -605,7 +582,7 @@ full_scan:
+@@ -607,7 +587,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 	/* Now ofs is a complete physical flash offset as it always was... */
 	ofs += jeb->offset;
 
@@ -5736,7 +5727,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 
 	dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
 
-@@ -698,7 +675,7 @@ scan_more:
+@@ -700,7 +680,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 				scan_end = buf_len;
 				goto more_empty;
 			}
@@ -5745,7 +5736,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 			/* See how much more there is to read in this eraseblock... */
 			buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
 			if (!buf_len) {
-@@ -948,7 +925,7 @@ scan_more:
+@@ -950,7 +930,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 	jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
 		  jeb->offset, jeb->free_size, jeb->dirty_size,
 		  jeb->unchecked_size, jeb->used_size, jeb->wasted_size);
@@ -5754,7 +5745,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	/* mark_node_obsolete can add to wasted !! */
 	if (jeb->wasted_size) {
 		jeb->dirty_size += jeb->wasted_size;
-@@ -976,7 +953,6 @@ struct jffs2_inode_cache *jffs2_scan_mak
+@@ -978,7 +958,6 @@ struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uin
 		pr_notice("%s(): allocation of inode cache failed\n", __func__);
 		return NULL;
 	}
@@ -5762,7 +5753,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 
 	ic->ino = ino;
 	ic->nodes = (void *)ic;
-@@ -1067,7 +1043,7 @@ static int jffs2_scan_dirent_node(struct
+@@ -1069,7 +1048,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
 	pseudo_random += je32_to_cpu(rd->version);
 
 	/* Should never happen. Did. (OLPC trac #4184)*/
@@ -5771,7 +5762,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	if (checkedlen < rd->nsize) {
 		pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
 		       ofs, checkedlen);
-@@ -1079,7 +1055,7 @@ static int jffs2_scan_dirent_node(struct
+@@ -1081,7 +1060,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
 	memcpy(&fd->name, rd->name, checkedlen);
 	fd->name[checkedlen] = 0;
 
@@ -5780,7 +5771,248 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
 	if (crc != je32_to_cpu(rd->name_crc)) {
 		pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
 			  __func__, ofs, je32_to_cpu(rd->name_crc), crc);
-@@ -1104,7 +1080,7 @@ static int jffs2_scan_dirent_node(struct
+@@ -1106,7 +1085,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 	fd->next = NULL;
+ 	fd->version = je32_to_cpu(rd->version);
+ 	fd->ino = je32_to_cpu(rd->ino);
+-	fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
+	fd->nhash = full_name_hash(fd->name, checkedlen);
+ 	fd->type = rd->type;
+ 	jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
+ 
+diff
+@@ -9,18 +9,17 @@
+  *
+  */
+ 
+-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+-
+ #include <linux/kernel.h>
+ #include <linux/sched.h>
+ #include <linux/slab.h>
+-#include <linux/mtd/mtd.h>
+ #include <linux/pagemap.h>
+-#include <linux/crc32.h>
+ #include <linux/compiler.h>
+ #include "nodelist.h"
+ #include "summary.h"
+ #include "debug.h"
+#include "mtd_dev.h"
+#include "los_typedef.h"
+#include "los_crc32.h"
+ 
+ #define DEFAULT_EMPTY_SCAN_SIZE 256
+ 
+@@ -74,7 +73,7 @@ static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+ 		return ret;
+ 	if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
+ 		return ret;
+-	/* Turned wasted size into dirty, since we apparently 
+	/* Turned wasted size into dirty, since we apparently
+ 	   think it's recoverable now. */
+ 	jeb->dirty_size += jeb->wasted_size;
+ 	c->dirty_size += jeb->wasted_size;
+@@ -95,40 +94,26 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
+ 	unsigned char *flashbuf = NULL;
+ 	uint32_t buf_size = 0;
+ 	struct jffs2_summary *s = NULL; /* summary info collected by the scan process */
+-#ifndef __ECOS
+-	size_t pointlen, try_size;
+-
+-	ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen,
+-			(void **)&flashbuf, NULL);
+-	if (!ret && pointlen < c->mtd->size) {
+-		/* Don't muck about if it won't let us point to the whole flash */
+-		jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n",
+-			  pointlen);
+-		mtd_unpoint(c->mtd, 0, pointlen);
+-		flashbuf = NULL;
+-	}
+-	if (ret && ret != -EOPNOTSUPP)
+-		jffs2_dbg(1, "MTD point failed %d\n", ret);
+-#endif
+	struct super_block *sb = NULL;
+	struct MtdNorDev *device = NULL;
+
+ 	if (!flashbuf) {
+ 		/* For NAND it's quicker to read a whole eraseblock at a time,
+ 		   apparently */
+ 		if (jffs2_cleanmarker_oob(c))
+-			try_size = c->sector_size;
+			buf_size = c->sector_size;
+ 		else
+-			try_size = PAGE_SIZE;
+			buf_size = PAGE_SIZE;
+ 
+ 		jffs2_dbg(1, "Trying to allocate readbuf of %zu "
+-			  "bytes\n", try_size);
+			  "bytes\n", buf_size);
+ 
+-		flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
+		flashbuf = kmalloc(buf_size, GFP_KERNEL);
+ 		if (!flashbuf)
+ 			return -ENOMEM;
+ 
+ 		jffs2_dbg(1, "Allocated readbuf of %zu bytes\n",
+-			  try_size);
+-
+-		buf_size = (uint32_t)try_size;
+			  buf_size);
+ 	}
+ 
+ 	if (jffs2_sum_active()) {
+@@ -140,7 +125,9 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
+ 		}
+ 	}
+ 
+-	for (i=0; i<c->nr_blocks; i++) {
+	sb = OFNI_BS_2SFFJ(c);
+	device = (struct MtdNorDev*)(sb->s_dev);
+	for (i=device->blockStart; i<c->nr_blocks + device->blockStart; i++) {
+ 		struct jffs2_eraseblock *jeb = &c->blocks[i];
+ 
+ 		cond_resched();
+@@ -269,14 +256,10 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
+ 			ret = -EIO;
+ 			goto out;
+ 		}
+-		spin_lock(&c->erase_completion_lock);
+-		jffs2_garbage_collect_trigger(c);
+-		spin_unlock(&c->erase_completion_lock);
+ 	}
+ 	ret = 0;
+  out:
+-	jffs2_sum_reset_collected(s);
+-	kfree(s);
+	kfree(flashbuf);
+  out_buf:
+ 	if (buf_size)
+ 		kfree(flashbuf);
+@@ -413,7 +396,7 @@ static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock
+ 	if (!ref)
+ 		return -ENOMEM;
+ 
+-	/* BEFORE jffs2_build_xattr_subsystem() called, 
+	/* BEFORE jffs2_build_xattr_subsystem() called,
+ 	 * and AFTER xattr_ref is marked as a dead xref,
+ 	 * ref->xid is used to store 32bit xid, xd is not used
+ 	 * ref->ino is used to store 32bit inode-number, ic is not used
+@@ -486,10 +469,10 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 		struct jffs2_sum_marker *sm;
+ 		void *sumptr = NULL;
+ 		uint32_t sumlen;
+-	      
+
+ 		if (!buf_size) {
+ 			/* XIP case. Just look, point at the summary if it's there */
+-			sm = (void *)buf + c->sector_size - sizeof(*sm);
+			sm = (struct jffs2_sum_marker *)((uint8_t *)buf + c->sector_size - sizeof(*sm));
+ 			if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
+ 				sumptr = buf + je32_to_cpu(sm->offset);
+ 				sumlen = c->sector_size - je32_to_cpu(sm->offset);
+@@ -502,13 +485,13 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 				buf_len = sizeof(*sm);
+ 
+ 			/* Read as much as we want into the _end_ of the preallocated buffer */
+-			err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 
+			err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len,
+ 						  jeb->offset + c->sector_size - buf_len,
+-						  buf_len);				
+						  buf_len);
+ 			if (err)
+ 				return err;
+ 
+-			sm = (void *)buf + buf_size - sizeof(*sm);
+			sm = (struct jffs2_sum_marker *)((uint8_t *)buf + buf_size - sizeof(*sm));
+ 			if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
+ 				sumlen = c->sector_size - je32_to_cpu(sm->offset);
+ 				sumptr = buf + buf_size - sumlen;
+@@ -523,18 +506,15 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 					sumptr = kmalloc(sumlen, GFP_KERNEL);
+ 					if (!sumptr)
+ 						return -ENOMEM;
+-					memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
+					memcpy((uint8_t *)sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
+ 				}
+ 				if (buf_len < sumlen) {
+ 					/* Need to read more so that the entire summary node is present */
+-					err = jffs2_fill_scan_buf(c, sumptr, 
+					err = jffs2_fill_scan_buf(c, sumptr,
+ 								  jeb->offset + c->sector_size - sumlen,
+-								  sumlen - buf_len);				
+-					if (err) {
+-						if (sumlen > buf_size)
+-							kfree(sumptr);
+								  sumlen - buf_len);
+					if (err)
+ 						return err;
+-					}
+ 				}
+ 			}
+ 
+@@ -545,7 +525,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 
+ 			if (buf_size && sumlen > buf_size)
+ 				kfree(sumptr);
+-			/* If it returns with a real error, bail. 
+			/* If it returns with a real error, bail.
+ 			   If it returns positive, that's a block classification
+ 			   (i.e. BLK_STATE_xxx) so return that too.
+ 			   If it returns zero, fall through to full scan. */
+@@ -607,7 +587,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 	/* Now ofs is a complete physical flash offset as it always was... */
+ 	ofs += jeb->offset;
+ 
+-	noise = 10;
+	noise = 1;
+ 
+ 	dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
+ 
+@@ -700,7 +680,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 				scan_end = buf_len;
+ 				goto more_empty;
+ 			}
+-			
+
+ 			/* See how much more there is to read in this eraseblock... */
+ 			buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
+ 			if (!buf_len) {
+@@ -950,7 +930,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 	jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
+ 		  jeb->offset, jeb->free_size, jeb->dirty_size,
+ 		  jeb->unchecked_size, jeb->used_size, jeb->wasted_size);
+-	
+
+ 	/* mark_node_obsolete can add to wasted !! */
+ 	if (jeb->wasted_size) {
+ 		jeb->dirty_size += jeb->wasted_size;
+@@ -978,7 +958,6 @@ struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uin
+ 		pr_notice("%s(): allocation of inode cache failed\n", __func__);
+ 		return NULL;
+ 	}
+-	memset(ic, 0, sizeof(*ic));
+ 
+ 	ic->ino = ino;
+ 	ic->nodes = (void *)ic;
+@@ -1069,7 +1048,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 	pseudo_random += je32_to_cpu(rd->version);
+ 
+ 	/* Should never happen. Did. (OLPC trac #4184)*/
+-	checkedlen = strnlen(rd->name, rd->nsize);
+	checkedlen = strnlen((const char *)rd->name, rd->nsize);
+ 	if (checkedlen < rd->nsize) {
+ 		pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
+ 		       ofs, checkedlen);
+@@ -1081,7 +1060,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
+ 	memcpy(&fd->name, rd->name, checkedlen);
+ 	fd->name[checkedlen] = 0;
+ 
+-	crc = crc32(0, fd->name, checkedlen);
+	crc = crc32(0, fd->name, rd->nsize);
+ 	if (crc != je32_to_cpu(rd->name_crc)) {
+ 		pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
+ 			  __func__, ofs, je32_to_cpu(rd->name_crc), crc);
+@@ -1106,7 +1085,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
 	fd->next = NULL;
 	fd->version = je32_to_cpu(rd->version);
 	fd->ino = je32_to_cpu(rd->ino);
--- a/fs/proc/BUILD.gn
+++ b/fs/proc/BUILD.gn
@@ -34,7 +34,9 @@ module_name = get_path_info(rebase_path("."), "name")
 kernel_module(module_name) {
  sources = [
    "os_adapt/fd_proc.c",
+    "os_adapt/file_sys.c",
    "os_adapt/fs_cache_proc.c",
+    "os_adapt/mem_info.c",
    "os_adapt/mounts_proc.c",
    "os_adapt/power_proc.c",
    "os_adapt/proc_init.c",
--- a/fs/proc/Kconfig
+++ b/fs/proc/Kconfig
@@ -4,3 +4,8 @@ config FS_PROC
    depends on FS_VFS
    help
      Answer Y to enable LiteOS support proc filesystem.
+
+config PROC_PROCESS_DIR
+    bool "Enable Process mount directory"
+    default n
+    depends on FS_PROC
--- a/fs/proc/include/internal.h
+++ b/fs/proc/include/internal.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -45,6 +45,16 @@ extern "C" {
 extern spinlock_t procfsLock;
 extern bool procfsInit;

+#ifdef LOSCFG_PROC_PROCESS_DIR
+int ProcCreateProcessDir(UINT32 pid, uintptr_t process);
+
+void ProcFreeProcessDir(struct ProcDirEntry *processDir);
+
+void ProcSysMemInfoInit(void);
+
+void ProcFileSysInit(void);
+#endif
+
 void ProcPmInit(void);

 void ProcVmmInit(void);
@@ -57,15 +67,15 @@ struct ProcDirEntry *ProcFindEntry(const char *path);

 void ProcFreeEntry(struct ProcDirEntry *pde);

-extern int ProcStat(const char *file, struct ProcStat *buf);
+int ProcStat(const char *file, struct ProcStat *buf);

-extern void ProcMountsInit(void);
+void ProcMountsInit(void);

-extern void ProcUptimeInit(void);
+void ProcUptimeInit(void);

-extern void ProcFsCacheInit(void);
+void ProcFsCacheInit(void);

-extern void ProcFdInit(void);
+void ProcFdInit(void);

 #ifdef __cplusplus
 #if __cplusplus
--- a/fs/proc/include/proc_fs.h
+++ b/fs/proc/include/proc_fs.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -82,6 +82,7 @@ typedef unsigned short fmode_t;
 #define FMODE_READ        ((fmode_t)0x1)

 struct ProcFile;
+struct ProcDirEntry;

 struct ProcFileOperations {
    char *name;
@@ -89,6 +90,7 @@ struct ProcFileOperations {
    int (*open)(struct Vnode *vnode, struct ProcFile *pf);
    int (*release)(struct Vnode *vnode, struct ProcFile *pf);
    int (*read)(struct SeqBuf *m, void *v);
+    ssize_t (*readLink)(struct ProcDirEntry *pde, char *buf, size_t bufLen);
 };

 struct ProcDirEntry {
@@ -244,6 +246,35 @@ extern struct ProcDirEntry *ProcMkdir(const char *name, struct ProcDirEntry *par
 extern struct ProcDirEntry *ProcCreate(const char *name, mode_t mode,
    struct ProcDirEntry *parent, const struct ProcFileOperations *procFops);

+/**
+ * @ingroup  procfs
+ * @brief create a proc node
+ *
+ * @par Description:
+ * This API is used to create the node by 'name' and parent vnode,
+ * And assignment operation function
+ *
+ * @attention
+ * <ul>
+ * <li>This interface should be called after system initialization.</li>
+ * <li>The parameter name should be a valid string.</li>
+ * </ul>
+ *
+ * @param  name      [IN] Type #const char * The name of the node to be created.
+ * @param  mode      [IN] Type #mode_t the mode of create's node.
+ * @param  parent    [IN] Type #struct ProcDirEntry * the parent node of the node to be created.
+ * @param  procFops  [IN] Type #const struct ProcFileOperations * operation function of the node.
+ * @param  data      [IN] Type #void * data of the node.
+ *
+ * @retval #NULL               Create failed.
+ * @retval #ProcDirEntry*    Create successfully.
+ * @par Dependency:
+ * <ul><li>proc_fs.h: the header file that contains the API declaration.</li></ul>
+ * @see
+ *
+ */
+extern struct ProcDirEntry *ProcCreateData(const char *name, mode_t mode, struct ProcDirEntry *parent,
+                                           const struct ProcFileOperations *procFileOps, void *data);
 /**
 * @ingroup  procfs
 * @brief init proc fs
--- a/fs/proc/os_adapt/file_sys.c
+++ b/fs/proc/os_adapt/file_sys.c
@@ -0,0 +1,69 @@
+/*
+ * 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 "fs/fs.h"
+#include "proc_fs.h"
+#include "proc_file.h"
+#include "errno.h"
+#include "sys/mount.h"
+
+extern struct fsmap_t g_fsmap[];
+extern struct fsmap_t g_fsmap_end;
+
+static int FsFileSysProcRead(struct SeqBuf *seqBuf, void *buf)
+{
+    (void)buf;
+
+    struct fsmap_t *m = NULL;
+    for (m = &g_fsmap[0]; m != &g_fsmap_end; ++m) {
+        if (m->fs_filesystemtype) {
+            if (m->is_bdfs == true) {
+                (void)LosBufPrintf(seqBuf, "\n       %s\n", m->fs_filesystemtype);
+            } else {
+                (void)LosBufPrintf(seqBuf, "%s  %s\n", "nodev", m->fs_filesystemtype);
+            }
+        }
+    }
+    return 0;
+}
+
+static const struct ProcFileOperations FILESYS_PROC_FOPS = {
+    .read = FsFileSysProcRead,
+};
+
+void ProcFileSysInit(void)
+{
+    struct ProcDirEntry *pde = CreateProcEntry("filesystems", 0, NULL);
+    if (pde == NULL) {
+        PRINT_ERR("creat /proc/filesystems error!\n");
+        return;
+    }
+    pde->procFileOps = &FILESYS_PROC_FOPS;
+}
--- a/fs/proc/os_adapt/mem_info.c
+++ b/fs/proc/os_adapt/mem_info.c
@@ -0,0 +1,69 @@
+/*
+ * 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 "internal.h"
+#include "proc_fs.h"
+#include "vnode.h"
+#include "los_memory.h"
+#include "los_vm_filemap.h"
+#include "los_memory_pri.h"
+
+static int SysMemInfoFill(struct SeqBuf *seqBuf, void *arg)
+{
+    (void)arg;
+    LOS_MEM_POOL_STATUS mem = {0};
+    if (LOS_MemInfoGet(m_aucSysMem0, &mem) == LOS_NOK) {
+        return -EBADF;
+    }
+    (void)LosBufPrintf(seqBuf, "\nUsedSize:        %u byte\n", mem.totalUsedSize);
+    (void)LosBufPrintf(seqBuf, "FreeSize:        %u byte\n", mem.totalFreeSize);
+    (void)LosBufPrintf(seqBuf, "MaxFreeNodeSize: %u byte\n", mem.maxFreeNodeSize);
+    (void)LosBufPrintf(seqBuf, "UsedNodeNum:     %u\n", mem.usedNodeNum);
+    (void)LosBufPrintf(seqBuf, "FreeNodeNum:     %u\n", mem.freeNodeNum);
+#ifdef LOSCFG_MEM_WATERLINE
+    (void)LosBufPrintf(seqBuf, "UsageWaterLine:  %u byte\n", mem.usageWaterLine);
+#endif
+     return 0;
+}
+
+static const struct ProcFileOperations SYS_MEMINFO_PROC_FOPS = {
+    .read = SysMemInfoFill,
+};
+
+void ProcSysMemInfoInit(void)
+{
+    struct ProcDirEntry *pde = CreateProcEntry("meminfo", 0, NULL);
+    if (pde == NULL) {
+        PRINT_ERR("create mem_info error!\n");
+        return;
+    }
+
+    pde->procFileOps = &SYS_MEMINFO_PROC_FOPS;
+}
--- a/fs/proc/os_adapt/proc_init.c
+++ b/fs/proc/os_adapt/proc_init.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -68,6 +68,10 @@ void ProcFsInit(void)
 #ifdef LOSCFG_KERNEL_PM
    ProcPmInit();
 #endif
+#ifdef LOSCFG_PROC_PROCESS_DIR
+    ProcSysMemInfoInit();
+    ProcFileSysInit();
+#endif
 }

 LOS_MODULE_INIT(ProcFsInit, LOS_INIT_LEVEL_KMOD_EXTENDED);
--- a/fs/proc/os_adapt/proc_vfs.c
+++ b/fs/proc/os_adapt/proc_vfs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-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:
@@ -125,10 +125,18 @@ int VfsProcfsRead(struct file *filep, char *buffer, size_t buflen)
        return -EINVAL;
    }

+    VnodeHold();
    entry = VnodeToEntry(filep->f_vnode);
+    if (entry == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }
+
+    spin_lock(&entry->pdeUnloadLock);
    size = (ssize_t)ReadProcFile(entry, (void *)buffer, buflen);
    filep->f_pos = entry->pf->fPos;
-
+    spin_unlock(&entry->pdeUnloadLock);
+    VnodeDrop();
    return size;
 }

@@ -140,10 +148,18 @@ int VfsProcfsWrite(struct file *filep, const char *buffer, size_t buflen)
        return -EINVAL;
    }

+    VnodeHold();
    entry = VnodeToEntry(filep->f_vnode);
+    if (entry == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }
+
+    spin_lock(&entry->pdeUnloadLock);
    size = (ssize_t)WriteProcFile(entry, (void *)buffer, buflen);
    filep->f_pos = entry->pf->fPos;
-
+    spin_unlock(&entry->pdeUnloadLock);
+    VnodeDrop();
    return size;
 }

@@ -156,9 +172,12 @@ int VfsProcfsLookup(struct Vnode *parent, const char *name, int len, struct Vnod
    if (entry == NULL) {
        return -ENODATA;
    }
+
+    spin_lock(&procfsLock);
    entry = entry->subdir;
    while (1) {
        if (entry == NULL) {
+            spin_unlock(&procfsLock);
            return -ENOENT;
        }
        if (EntryMatch(name, len, entry)) {
@@ -166,6 +185,7 @@ int VfsProcfsLookup(struct Vnode *parent, const char *name, int len, struct Vnod
        }
        entry = entry->next;
    }
+    spin_unlock(&procfsLock);

    *vpp = EntryToVnode(entry);
    if ((*vpp) == NULL) {
@@ -214,11 +234,17 @@ int VfsProcfsUnmount(void *handle, struct Vnode **blkdriver)

 int VfsProcfsStat(struct Vnode *node, struct stat *buf)
 {
+    VnodeHold();
    struct ProcDirEntry *entry = VnodeToEntry(node);
-
+    if (entry == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }
    (void)memset_s(buf, sizeof(struct stat), 0, sizeof(struct stat));
+    spin_lock(&entry->pdeUnloadLock);
    buf->st_mode = entry->mode;
-
+    spin_unlock(&entry->pdeUnloadLock);
+    VnodeDrop();
    return LOS_OK;
 }

@@ -226,9 +252,7 @@ int VfsProcfsReaddir(struct Vnode *node, struct fs_dirent_s *dir)
 {
    int result;
    char *buffer = NULL;
-    int buflen = NAME_MAX;
-    unsigned int min_size;
-    unsigned int dst_name_size;
+    unsigned int minSize, dstNameSize;
    struct ProcDirEntry *pde = NULL;
    int i = 0;

@@ -238,28 +262,38 @@ int VfsProcfsReaddir(struct Vnode *node, struct fs_dirent_s *dir)
    if (node->type != VNODE_TYPE_DIR) {
        return -ENOTDIR;
    }
+    VnodeHold();
    pde = VnodeToEntry(node);
+    if (pde == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }

+    spin_lock(&pde->pdeUnloadLock);
    while (i < dir->read_cnt) {
        buffer = (char *)zalloc(sizeof(char) * NAME_MAX);
        if (buffer == NULL) {
+            spin_unlock(&pde->pdeUnloadLock);
+            VnodeDrop();
            PRINT_ERR("malloc failed\n");
            return -ENOMEM;
        }

-        result = ReadProcFile(pde, (void *)buffer, buflen);
+        result = ReadProcFile(pde, (void *)buffer, NAME_MAX);
        if (result != ENOERR) {
            free(buffer);
            break;
        }
-        dst_name_size = sizeof(dir->fd_dir[i].d_name);
-        min_size = (dst_name_size < NAME_MAX) ? dst_name_size : NAME_MAX;
-        result = strncpy_s(dir->fd_dir[i].d_name, dst_name_size, buffer, min_size);
+        dstNameSize = sizeof(dir->fd_dir[i].d_name);
+        minSize = (dstNameSize < NAME_MAX) ? dstNameSize : NAME_MAX;
+        result = strncpy_s(dir->fd_dir[i].d_name, dstNameSize, buffer, minSize);
        if (result != EOK) {
+            spin_unlock(&pde->pdeUnloadLock);
+            VnodeDrop();
            free(buffer);
            return -ENAMETOOLONG;
        }
-        dir->fd_dir[i].d_name[dst_name_size - 1] = '\0';
+        dir->fd_dir[i].d_name[dstNameSize - 1] = '\0';
        dir->fd_position++;
        dir->fd_dir[i].d_off = dir->fd_position;
        dir->fd_dir[i].d_reclen = (uint16_t)sizeof(struct dirent);
@@ -267,19 +301,30 @@ int VfsProcfsReaddir(struct Vnode *node, struct fs_dirent_s *dir)
        i++;
        free(buffer);
    }
-
+    spin_unlock(&pde->pdeUnloadLock);
+    VnodeDrop();
    return i;
 }

 int VfsProcfsOpendir(struct Vnode *node,  struct fs_dirent_s *dir)
 {
+    VnodeHold();
    struct ProcDirEntry *pde = VnodeToEntry(node);
    if (pde == NULL) {
+        VnodeDrop();
        return -EINVAL;
    }
-    pde->pdirCurrent = pde->subdir;
-    pde->pf->fPos = 0;

+    spin_lock(&pde->pdeUnloadLock);
+    pde->pdirCurrent = pde->subdir;
+    if (pde->pf == NULL) {
+        spin_unlock(&pde->pdeUnloadLock);
+        VnodeDrop();
+        return -EINVAL;
+    }
+    pde->pf->fPos = 0;
+    spin_unlock(&pde->pdeUnloadLock);
+    VnodeDrop();
    return LOS_OK;
 }

@@ -288,9 +333,17 @@ int VfsProcfsOpen(struct file *filep)
    if (filep == NULL) {
        return -EINVAL;
    }
+    VnodeHold();
    struct Vnode *node = filep->f_vnode;
    struct ProcDirEntry *pde = VnodeToEntry(node);
+    if (pde == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }
+
+    spin_lock(&pde->pdeUnloadLock);
    if (ProcOpen(pde->pf) != OK) {
+        spin_unlock(&pde->pdeUnloadLock);
        return -ENOMEM;
    }
    if (S_ISREG(pde->mode) && (pde->procFileOps != NULL) && (pde->procFileOps->open != NULL)) {
@@ -301,6 +354,8 @@ int VfsProcfsOpen(struct file *filep)
        pde->pf->fPos = 0;
    }
    filep->f_priv = (void *)pde;
+    spin_unlock(&pde->pdeUnloadLock);
+    VnodeDrop();
    return LOS_OK;
 }

@@ -310,15 +365,24 @@ int VfsProcfsClose(struct file *filep)
    if (filep == NULL) {
        return -EINVAL;
    }
+
+    VnodeHold();
    struct Vnode *node = filep->f_vnode;
    struct ProcDirEntry *pde = VnodeToEntry(node);
+    if (pde == NULL) {
+        VnodeDrop();
+        return -EPERM;
+    }
+
+    spin_lock(&pde->pdeUnloadLock);
    pde->pf->fPos = 0;
    if ((pde->procFileOps != NULL) && (pde->procFileOps->release != NULL)) {
        result = pde->procFileOps->release((struct Vnode *)pde, pde->pf);
    }
    LosBufRelease(pde->pf->sbuf);
    pde->pf->sbuf = NULL;
-
+    spin_unlock(&pde->pdeUnloadLock);
+    VnodeDrop();
    return result;
 }

@@ -335,6 +399,26 @@ int VfsProcfsClosedir(struct Vnode *vp, struct fs_dirent_s *dir)
    return LOS_OK;
 }

+ssize_t VfsProcfsReadlink(struct Vnode *vnode, char *buffer, size_t bufLen)
+{
+    int result = -EINVAL;
+    if (vnode == NULL) {
+        return result;
+    }
+
+    struct ProcDirEntry *pde = VnodeToEntry(vnode);
+    if (pde == NULL) {
+        return -EPERM;
+    }
+
+    spin_lock(&pde->pdeUnloadLock);
+    if ((pde->procFileOps != NULL) && (pde->procFileOps->readLink != NULL)) {
+        result = pde->procFileOps->readLink(pde, buffer, bufLen);
+    }
+    spin_unlock(&pde->pdeUnloadLock);
+    return result;
+}
+
 const struct MountOps procfs_operations = {
    .Mount = VfsProcfsMount,
    .Unmount = NULL,
@@ -347,7 +431,8 @@ static struct VnodeOps g_procfsVops = {
    .Readdir = VfsProcfsReaddir,
    .Opendir = VfsProcfsOpendir,
    .Closedir = VfsProcfsClosedir,
-    .Truncate = VfsProcfsTruncate
+    .Truncate = VfsProcfsTruncate,
+    .Readlink = VfsProcfsReadlink,
 };

 static struct file_operations_vfs g_procfsFops = {
--- a/fs/proc/os_adapt/process_proc.c
+++ b/fs/proc/os_adapt/process_proc.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -32,7 +32,453 @@
 #include <sys/statfs.h>
 #include <sys/mount.h>
 #include "proc_fs.h"
+#include "internal.h"
 #include "los_process_pri.h"
+#include "user_copy.h"
+#include "los_memory.h"
+
+#ifdef LOSCFG_PROC_PROCESS_DIR
+#include "los_vm_dump.h"
+
+typedef enum {
+    PROC_PID,
+    PROC_PID_MEM,
+#ifdef LOSCFG_KERNEL_CPUP
+    PROC_PID_CPUP,
+#endif
+} ProcessDataType;
+
+struct ProcProcess {
+    char         *name;
+    mode_t       mode;
+    int          type;
+    const struct ProcFileOperations *fileOps;
+};
+
+struct ProcessData {
+    uintptr_t process;
+    unsigned int type;
+};
+
+static LosProcessCB *ProcGetProcessCB(struct ProcessData *data)
+{
+    if (data->process != 0) {
+        return (LosProcessCB *)data->process;
+    }
+    return OsCurrProcessGet();
+}
+
+#define PROC_PID_PRIVILEGE 7
+#define PROC_PID_DIR_LEN 100
+#ifdef LOSCFG_KERNEL_CONTAINER
+static ssize_t ProcessContainerLink(unsigned int containerID, ContainerType type, char *buffer, size_t bufLen)
+{
+    ssize_t count = -1;
+    if ((type == PID_CONTAINER) || (type == PID_CHILD_CONTAINER)) {
+        count = snprintf_s(buffer, bufLen, bufLen - 1, "'pid:[%u]'", containerID);
+    } else if (type == UTS_CONTAINER) {
+        count = snprintf_s(buffer, bufLen, bufLen - 1, "'uts:[%u]'", containerID);
+    } else if (type == MNT_CONTAINER) {
+        count = snprintf_s(buffer, bufLen, bufLen - 1, "'mnt:[%u]'", containerID);
+    } else if (type == IPC_CONTAINER) {
+        count = snprintf_s(buffer, bufLen, bufLen - 1, "'ipc:[%u]'", containerID);
+    } else if ((type == TIME_CONTAINER) || (type == TIME_CHILD_CONTAINER)) {
+        count = snprintf_s(buffer, bufLen, bufLen - 1, "'time:[%u]'", containerID);
+    }
+
+    if (count < 0) {
+        return -EBADF;
+    }
+    return count;
+}
+
+static ssize_t ProcessContainerReadLink(struct ProcDirEntry *entry, char *buffer, size_t bufLen)
+{
+    ssize_t count;
+    unsigned int intSave;
+    if (entry == NULL) {
+        return -EINVAL;
+    }
+    struct ProcessData *data = (struct ProcessData *)entry->data;
+    if (data == NULL) {
+        return -EINVAL;
+    }
+    LosProcessCB *processCB = ProcGetProcessCB(data);
+    SCHEDULER_LOCK(intSave);
+    UINT32 containerID = OsGetContainerID(processCB->container, (ContainerType)data->type);
+    SCHEDULER_UNLOCK(intSave);
+    if (containerID != OS_INVALID_VALUE) {
+        return ProcessContainerLink(containerID, (ContainerType)data->type, buffer, bufLen);
+    }
+    count = strlen("(unknown)");
+    if (memcpy_s(buffer, bufLen, "(unknown)", count + 1) != EOK) {
+        return -EBADF;
+    }
+    return count;
+}
+
+static const struct ProcFileOperations PID_CONTAINER_FOPS = {
+    .readLink = ProcessContainerReadLink,
+};
+#endif /* LOSCFG_KERNEL_CONTAINER */
+
+static int ProcessMemInfoRead(struct SeqBuf *seqBuf, LosProcessCB *pcb)
+{
+    unsigned int intSave;
+    unsigned int size = sizeof(LosVmSpace) + sizeof(LosVmMapRegion);
+    LosVmSpace *vmSpace = (LosVmSpace *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (vmSpace == NULL) {
+        return -ENOMEM;
+    }
+    (void)memset_s(vmSpace, size, 0, size);
+    LosVmMapRegion *heap = (LosVmMapRegion *)((char *)vmSpace + sizeof(LosVmSpace));
+
+    SCHEDULER_LOCK(intSave);
+    if (OsProcessIsInactive(pcb)) {
+        SCHEDULER_UNLOCK(intSave);
+        (void)LOS_MemFree(m_aucSysMem1, vmSpace);
+        return -EINVAL;
+    }
+    (void)memcpy_s(vmSpace, sizeof(LosVmSpace), pcb->vmSpace, sizeof(LosVmSpace));
+    (void)memcpy_s(heap, sizeof(LosVmMapRegion), pcb->vmSpace->heap, sizeof(LosVmMapRegion));
+    SCHEDULER_UNLOCK(intSave);
+
+    (void)LosBufPrintf(seqBuf, "\nVMSpaceSize:      %u byte\n", vmSpace->size);
+    (void)LosBufPrintf(seqBuf, "VMSpaceMapSize:   %u byte\n", vmSpace->mapSize);
+    (void)LosBufPrintf(seqBuf, "VM TLB Asid:      %u\n", vmSpace->archMmu.asid);
+    (void)LosBufPrintf(seqBuf, "VMHeapSize:       %u byte\n", heap->range.size);
+    (void)LosBufPrintf(seqBuf, "VMHeapRegionName: %s\n", OsGetRegionNameOrFilePath(heap));
+    (void)LosBufPrintf(seqBuf, "VMHeapRegionType: 0x%x\n", heap->regionType);
+    (void)LOS_MemFree(m_aucSysMem1, vmSpace);
+    return 0;
+}
+
+#ifdef LOSCFG_KERNEL_CPUP
+#define TIME_CYCLE_TO_US(time) ((((UINT64)time) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US)
+static int ProcessCpupRead(struct SeqBuf *seqBuf, LosProcessCB *pcb)
+{
+    unsigned int intSave;
+    OsCpupBase *processCpup = (OsCpupBase *)LOS_MemAlloc(m_aucSysMem1, sizeof(OsCpupBase));
+    if (processCpup == NULL) {
+        return -ENOMEM;
+    }
+    (void)memset_s(processCpup, sizeof(OsCpupBase), 0, sizeof(OsCpupBase));
+
+    SCHEDULER_LOCK(intSave);
+    if (OsProcessIsInactive(pcb)) {
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, processCpup);
+        return -EINVAL;
+    }
+    (void)memcpy_s(processCpup, sizeof(OsCpupBase), pcb->processCpup, sizeof(OsCpupBase));
+    SCHEDULER_UNLOCK(intSave);
+
+    (void)LosBufPrintf(seqBuf, "\nTotalRunningTime: %lu us\n", TIME_CYCLE_TO_US(processCpup->allTime));
+    (void)LosBufPrintf(seqBuf, "HistoricalRunningTime:(us) ");
+    for (UINT32 i = 0; i < OS_CPUP_HISTORY_RECORD_NUM + 1; i++) {
+        (void)LosBufPrintf(seqBuf, "%lu  ", TIME_CYCLE_TO_US(processCpup->historyTime[i]));
+    }
+    (void)LosBufPrintf(seqBuf, "\n");
+    (void)LOS_MemFree(m_aucSysMem1, processCpup);
+    return 0;
+}
+#endif
+
+#ifdef LOSCFG_TIME_CONTAINER
+static const CHAR *g_monotonic = "monotonic";
+#define DECIMAL_BASE 10
+
+static int ProcTimeContainerRead(struct SeqBuf *m, void *v)
+{
+    int ret;
+    unsigned int intSave;
+    struct timespec64 offsets = {0};
+
+    if ((m == NULL) || (v == NULL)) {
+        return -EINVAL;
+    }
+
+    struct ProcessData *data = (struct ProcessData *)v;
+    SCHEDULER_LOCK(intSave);
+    LosProcessCB *processCB = ProcGetProcessCB(data);
+    ret = OsGetTimeContainerMonotonic(processCB, &offsets);
+    SCHEDULER_UNLOCK(intSave);
+    if (ret != LOS_OK) {
+        return -ret;
+    }
+
+    LosBufPrintf(m, "monotonic %lld %ld\n", offsets.tv_sec, offsets.tv_nsec);
+    return 0;
+}
+
+static int ProcSetTimensOffset(const char *buf, LosProcessCB *processCB)
+{
+    unsigned int intSave;
+    struct timespec64 offsets;
+    char *endptr = NULL;
+
+    offsets.tv_sec = strtoll(buf, &endptr, DECIMAL_BASE);
+    offsets.tv_nsec = strtoll(endptr, NULL, DECIMAL_BASE);
+    if (offsets.tv_nsec >= OS_SYS_NS_PER_SECOND) {
+        return -EACCES;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    unsigned int ret = OsSetTimeContainerMonotonic(processCB, &offsets);
+    SCHEDULER_UNLOCK(intSave);
+    if (ret != LOS_OK) {
+        return -ret;
+    }
+    return 0;
+}
+
+static int ProcTimeContainerWrite(struct ProcFile *pf, const char *buf, size_t count, loff_t *ppos)
+{
+    (void)ppos;
+    char *kbuf = NULL;
+    int ret;
+
+    if ((pf == NULL) || (count <= 0)) {
+        return -EINVAL;
+    }
+
+    struct ProcDirEntry *entry = pf->pPDE;
+    if (entry == NULL) {
+        return -EINVAL;
+    }
+
+    struct ProcessData *data = (struct ProcessData *)entry->data;
+    if (data == NULL) {
+        return -EINVAL;
+    }
+
+    if (LOS_IsUserAddressRange((VADDR_T)(UINTPTR)buf, count)) {
+        kbuf = LOS_MemAlloc(m_aucSysMem1, count + 1);
+        if (kbuf == NULL) {
+            return -ENOMEM;
+        }
+
+        if (LOS_ArchCopyFromUser(kbuf, buf, count) != 0) {
+            (VOID)LOS_MemFree(m_aucSysMem1, kbuf);
+            return -EFAULT;
+        }
+        kbuf[count] = '\0';
+        buf = kbuf;
+    }
+
+    ret = strncmp(buf, g_monotonic, strlen(g_monotonic));
+    if (ret != 0) {
+        (VOID)LOS_MemFree(m_aucSysMem1, kbuf);
+        return -EINVAL;
+    }
+
+    buf += strlen(g_monotonic);
+    ret = ProcSetTimensOffset(buf, ProcGetProcessCB(data));
+    if (ret < 0) {
+        (VOID)LOS_MemFree(m_aucSysMem1, kbuf);
+        return ret;
+    }
+    (VOID)LOS_MemFree(m_aucSysMem1, kbuf);
+    return count;
+}
+
+static const struct ProcFileOperations TIME_CONTAINER_FOPS = {
+    .read = ProcTimeContainerRead,
+    .write = ProcTimeContainerWrite,
+};
+#endif
+
+static int ProcProcessRead(struct SeqBuf *m, void *v)
+{
+    if ((m == NULL) || (v == NULL)) {
+        return -EINVAL;
+    }
+    struct ProcessData *data = (struct ProcessData *)v;
+    switch (data->type) {
+        case PROC_PID_MEM:
+            return ProcessMemInfoRead(m, ProcGetProcessCB(data));
+#ifdef LOSCFG_KERNEL_CPUP
+        case PROC_PID_CPUP:
+            return ProcessCpupRead(m, ProcGetProcessCB(data));
+#endif
+        default:
+            break;
+    }
+    return -EINVAL;
+}
+
+static const struct ProcFileOperations PID_FOPS = {
+    .read = ProcProcessRead,
+};
+
+static struct ProcProcess g_procProcess[] = {
+    {
+        .name = NULL,
+        .mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IROTH,
+        .type = PROC_PID,
+        .fileOps = &PID_FOPS
+
+    },
+    {
+        .name = "meminfo",
+        .mode = 0,
+        .type = PROC_PID_MEM,
+        .fileOps = &PID_FOPS
+    },
+#ifdef LOSCFG_KERNEL_CPUP
+    {
+        .name = "cpup",
+        .mode = 0,
+        .type = PROC_PID_CPUP,
+        .fileOps = &PID_FOPS
+
+    },
+#endif
+#ifdef LOSCFG_KERNEL_CONTAINER
+    {
+        .name = "container",
+        .mode = S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH,
+        .type = CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+
+    },
+#ifdef LOSCFG_PID_CONTAINER
+    {
+        .name = "container/pid",
+        .mode = S_IFLNK,
+        .type = PID_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+    {
+        .name = "container/pid_for_children",
+        .mode = S_IFLNK,
+        .type = PID_CHILD_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    {
+        .name = "container/uts",
+        .mode = S_IFLNK,
+        .type = UTS_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    {
+        .name = "container/mnt",
+        .mode = S_IFLNK,
+        .type = MNT_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    {
+        .name = "container/ipc",
+        .mode = S_IFLNK,
+        .type = IPC_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+    {
+        .name = "container/time",
+        .mode = S_IFLNK,
+        .type = TIME_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+    {
+        .name = "container/time_for_children",
+        .mode = S_IFLNK,
+        .type = TIME_CHILD_CONTAINER,
+        .fileOps = &PID_CONTAINER_FOPS
+    },
+    {
+        .name = "time_offsets",
+        .mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
+        .type = TIME_CONTAINER,
+        .fileOps = &TIME_CONTAINER_FOPS
+    },
+#endif
+#endif
+};
+
+void ProcFreeProcessDir(struct ProcDirEntry *processDir)
+{
+    if (processDir == NULL) {
+        return;
+    }
+    RemoveProcEntry(processDir->name, NULL);
+}
+
+static struct ProcDirEntry *ProcCreatePorcess(UINT32 pid, struct ProcProcess *porcess, uintptr_t processCB)
+{
+    int ret;
+    char pidName[PROC_PID_DIR_LEN] = {0};
+    struct ProcessData *data = (struct ProcessData *)malloc(sizeof(struct ProcessData));
+    if (data == NULL) {
+        return NULL;
+    }
+    if (pid != OS_INVALID_VALUE) {
+        if (porcess->name != NULL) {
+            ret = snprintf_s(pidName, PROC_PID_DIR_LEN, PROC_PID_DIR_LEN - 1, "%u/%s", pid, porcess->name);
+        } else {
+            ret = snprintf_s(pidName, PROC_PID_DIR_LEN, PROC_PID_DIR_LEN - 1, "%u", pid);
+        }
+    } else {
+        if (porcess->name != NULL) {
+            ret = snprintf_s(pidName, PROC_PID_DIR_LEN, PROC_PID_DIR_LEN - 1, "%s/%s", "self", porcess->name);
+        } else {
+            ret = snprintf_s(pidName, PROC_PID_DIR_LEN, PROC_PID_DIR_LEN - 1, "%s", "self");
+        }
+    }
+    if (ret < 0) {
+        free(data);
+        return NULL;
+    }
+
+    data->process = processCB;
+    data->type = porcess->type;
+    struct ProcDirEntry *container = ProcCreateData(pidName, porcess->mode, NULL, porcess->fileOps, (void *)data);
+    if (container == NULL) {
+        free(data);
+        PRINT_ERR("create /proc/%s error!\n", pidName);
+        return NULL;
+    }
+    return container;
+}
+
+int ProcCreateProcessDir(UINT32 pid, uintptr_t process)
+{
+    unsigned int intSave;
+    struct ProcDirEntry *pidDir = NULL;
+    for (int index = 0; index < (sizeof(g_procProcess) / sizeof(struct ProcProcess)); index++) {
+        struct ProcProcess *procProcess = &g_procProcess[index];
+        struct ProcDirEntry *dir = ProcCreatePorcess(pid, procProcess, process);
+        if (dir == NULL) {
+            PRINT_ERR("create /proc/%s error!\n", procProcess->name);
+            goto CREATE_ERROR;
+        }
+        if (index == 0) {
+            pidDir = dir;
+        }
+    }
+
+    if (process != 0) {
+        SCHEDULER_LOCK(intSave);
+        ((LosProcessCB *)process)->procDir = pidDir;
+        SCHEDULER_UNLOCK(intSave);
+    }
+
+    return 0;
+
+CREATE_ERROR:
+    if (pidDir != NULL) {
+        RemoveProcEntry(pidDir->name, NULL);
+    }
+    return -1;
+}
+#endif /* LOSCFG_PROC_PROCESS_DIR */

 static int ProcessProcFill(struct SeqBuf *m, void *v)
 {
@@ -52,7 +498,18 @@ void ProcProcessInit(void)
        PRINT_ERR("create /proc/process error!\n");
        return;
    }
-
    pde->procFileOps = &PROCESS_PROC_FOPS;
-}

+#ifdef LOSCFG_PROC_PROCESS_DIR
+    int ret = ProcCreateProcessDir(OS_INVALID_VALUE, 0);
+    if (ret < 0) {
+        PRINT_ERR("Create proc process self dir failed!\n");
+    }
+
+    ret = ProcCreateProcessDir(OS_USER_ROOT_PROCESS_ID, (uintptr_t)OsGetUserInitProcess());
+    if (ret < 0) {
+        PRINT_ERR("Create proc process %d dir failed!\n", OS_USER_ROOT_PROCESS_ID);
+    }
+#endif
+    return;
+}
--- a/fs/proc/src/proc_file.c
+++ b/fs/proc/src/proc_file.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -351,7 +351,11 @@ static struct ProcDirEntry *ProcCreateFile(struct ProcDirEntry *parent, const ch
    }

    pn->procFileOps = procFileOps;
-    pn->type = VNODE_TYPE_REG;
+    if (S_ISLNK(mode)) {
+        pn->type = VNODE_TYPE_LNK;
+    } else {
+        pn->type = VNODE_TYPE_REG;
+    }
    ret = ProcAddNode(parent, pn);
    if (ret != 0) {
        free(pn->pf);
@@ -374,15 +378,43 @@ struct ProcDirEntry *CreateProcEntry(const char *name, mode_t mode, struct ProcD
    return pde;
 }

+static void ProcEntryClearVnode(struct ProcDirEntry *entry)
+{
+    struct Vnode *item = NULL;
+    struct Vnode *nextItem = NULL;
+
+    VnodeHold();
+    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, GetVnodeActiveList(), struct Vnode, actFreeEntry) {
+        if ((struct ProcDirEntry *)item->data != entry) {
+            continue;
+        }
+
+        if (VnodeFree(item) != LOS_OK) {
+            PRINT_ERR("ProcEntryClearVnode free failed, entry: %s : 0x%x \n", entry->name, item);
+        }
+    }
+    VnodeDrop();
+    return;
+}
+
 static void FreeProcEntry(struct ProcDirEntry *entry)
 {
    if (entry == NULL) {
        return;
    }
+
+    ProcEntryClearVnode(entry);
+
+    spin_lock(&entry->pdeUnloadLock);
    if (entry->pf != NULL) {
        free(entry->pf);
        entry->pf = NULL;
    }
+    if (entry->data != NULL) {
+        free(entry->data);
+        entry->data = NULL;
+    }
+    spin_unlock(&entry->pdeUnloadLock);
    free(entry);
 }

@@ -529,7 +561,7 @@ static int ProcRead(struct ProcDirEntry *pde, char *buf, size_t len)

    if (sb->buf == NULL) {
        // only read once to build the storage buffer
-        if (pde->procFileOps->read(sb, NULL) != 0) {
+        if (pde->procFileOps->read(sb, pde->data) != 0) {
            return PROC_ERROR;
        }
    }
@@ -554,22 +586,21 @@ static int ProcRead(struct ProcDirEntry *pde, char *buf, size_t len)

 struct ProcDirEntry *OpenProcFile(const char *fileName, int flags, ...)
 {
-    unsigned int intSave;
    struct ProcDirEntry *pn = ProcFindEntry(fileName);
    if (pn == NULL) {
        return NULL;
    }

-    SCHEDULER_LOCK(intSave);
+    spin_lock(&pn->pdeUnloadLock);
    if (S_ISREG(pn->mode) && (pn->count != 1)) {
-        SCHEDULER_UNLOCK(intSave);
+        spin_unlock(&pn->pdeUnloadLock);
        return NULL;
    }

    pn->flags = (unsigned int)(pn->flags) | (unsigned int)flags;
    atomic_set(&pn->count, PROC_INUSE);
-    SCHEDULER_UNLOCK(intSave);
    if (ProcOpen(pn->pf) != OK) {
+        spin_unlock(&pn->pdeUnloadLock);
        return NULL;
    }
    if (S_ISREG(pn->mode) && (pn->procFileOps != NULL) && (pn->procFileOps->open != NULL)) {
@@ -579,6 +610,7 @@ struct ProcDirEntry *OpenProcFile(const char *fileName, int flags, ...)
        pn->pdirCurrent = pn->subdir;
        pn->pf->fPos = 0;
    }
+    spin_unlock(&pn->pdeUnloadLock);

    return pn;
 }
--- a/fs/rootfs/Makefile
+++ b/fs/rootfs/Makefile
@@ -33,10 +33,6 @@ MODULE_NAME := rootfs

 LOCAL_SRCS := $(wildcard los_rootfs.c los_bootargs.c)

-ifeq ($(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7), y)
-LOCAL_INCLUDE += -I $(LITEOSTOPDIR)/../../device/qemu/drivers/cfiflash
-endif
-
 LOCAL_FLAGS := $(LOCAL_INCLUDE)

 include $(MODULE)
--- a/fs/rootfs/los_bootargs.c
+++ b/fs/rootfs/los_bootargs.c
@@ -32,14 +32,10 @@
 #include "los_base.h"
 #include "string.h"

-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
+#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
 #include "mtd_list.h"
 #endif

-#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
-#include "cfiflash.h"
-#endif
-
 #ifdef LOSCFG_STORAGE_EMMC
 #include "disk.h"
 #endif
@@ -98,19 +94,6 @@ INT32 LOS_GetCmdLine(VOID)
    }
 #endif

-#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
-    struct MtdDev *mtd = GetCfiMtdDev();
-    if (mtd == NULL) {
-        PRINT_ERR("Get CFI mtd failed!\n");
-        goto ERROUT;
-    }
-    g_alignSize = mtd->eraseSize;
-    ret = mtd->read(mtd, CFIFLASH_BOOTARGS_ADDR, COMMAND_LINE_SIZE, g_cmdLine);
-    if (ret == COMMAND_LINE_SIZE) {
-        return LOS_OK;
-    }
-#endif
-
    PRINT_ERR("Read cmdline error!\n");
 ERROUT:
    free(g_cmdLine);
--- a/fs/rootfs/los_rootfs.c
+++ b/fs/rootfs/los_rootfs.c
@@ -37,15 +37,11 @@
 #include "sys/stat.h"
 #include "sys/types.h"

-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
+#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
 #include "mtd_list.h"
 #include "mtd_partition.h"
 #endif

-#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
-#include "cfiflash.h"
-#endif
-
 #ifdef LOSCFG_STORAGE_EMMC
 #include "disk.h"
 #include "ff.h"
@@ -128,14 +124,7 @@ STATIC INT32 AddEmmcParts(INT32 rootAddr, INT32 rootSize, INT32 userAddr, INT32

 STATIC INT32 AddPartitions(CHAR *dev, UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
 {
-#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
-    if ((strcmp(dev, "cfi-flash") == 0) && (rootAddr != CFIFLASH_ROOT_ADDR)) {
-        PRINT_ERR("Error rootAddr, must be %#0x!\n", CFIFLASH_ROOT_ADDR);
-        return LOS_NOK;
-    }
-#endif
-
-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
+#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
    INT32 ret;
    INT32 blk0 = 0;
    INT32 blk2 = 2;
--- a/fs/rootfs/los_rootfs.h
+++ b/fs/rootfs/los_rootfs.h
@@ -59,12 +59,6 @@
 #define ROOTFS_ADDR             0x600000
 #define ROOTFS_SIZE             0x800000
 #define USERFS_SIZE             0x80000
-#elif defined (LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
-#define ROOT_DEV_NAME           "/dev/cfiflash0"
-#define USER_DEV_NAME           "/dev/cfiflash2"
-#define ROOTFS_ADDR             CFIFLASH_ROOT_ADDR
-#define ROOTFS_SIZE             0x1B00000
-#define USERFS_SIZE             (CFIFLASH_CAPACITY - ROOTFS_ADDR - ROOTFS_SIZE)
 #elif defined (LOSCFG_STORAGE_EMMC)
 #define ROOT_DEV_NAME           "/dev/mmcblk0p0"
 #ifdef LOSCFG_PLATFORM_PATCHFS
--- a/fs/vfs/include/vnode.h
+++ b/fs/vfs/include/vnode.h
@@ -127,6 +127,9 @@ struct Vnode {
    struct Mount *newMount;             /* fs info about who mount on this vnode */
    char *filePath;                     /* file path of the vnode */
    struct page_mapping mapping;        /* page mapping of the vnode */
+#ifdef LOSCFG_MNT_CONTAINER
+    int mntCount;                       /* ref count of mounts */
+#endif
 };

 struct VnodeOps {
@@ -185,5 +188,5 @@ LIST_HEAD* GetVnodeFreeList(void);
 LIST_HEAD* GetVnodeActiveList(void);
 LIST_HEAD* GetVnodeVirtualList(void);
 int VnodeClearCache(void);
-
+struct Vnode *GetCurrRootVnode(void);
 #endif /* !_VNODE_H_ */
--- a/fs/vfs/mount.c
+++ b/fs/vfs/mount.c
@@ -37,11 +37,16 @@
 #include "stdlib.h"
 #endif

+#ifdef LOSCFG_MNT_CONTAINER
+#include "los_mnt_container_pri.h"
+static LIST_HEAD *g_mountCache = NULL;
+#else
 static LIST_HEAD *g_mountList = NULL;
+#endif

-struct Mount* MountAlloc(struct Vnode* vnodeBeCovered, struct MountOps* fsop)
+struct Mount *MountAlloc(struct Vnode *vnodeBeCovered, struct MountOps *fsop)
 {
-    struct Mount* mnt = (struct Mount*)zalloc(sizeof(struct Mount));
+    struct Mount *mnt = (struct Mount *)zalloc(sizeof(struct Mount));
    if (mnt == NULL) {
        PRINT_ERR("MountAlloc failed no memory!\n");
        return NULL;
@@ -62,7 +67,26 @@ struct Mount* MountAlloc(struct Vnode* vnodeBeCovered, struct MountOps* fsop)
    return mnt;
 }

-LIST_HEAD* GetMountList()
+#ifdef LOSCFG_MNT_CONTAINER
+LIST_HEAD *GetMountList(void)
+{
+    return GetContainerMntList();
+}
+
+LIST_HEAD *GetMountCache(void)
+{
+    if (g_mountCache == NULL) {
+        g_mountCache = zalloc(sizeof(LIST_HEAD));
+        if (g_mountCache == NULL) {
+            PRINT_ERR("init cache mount list failed, no memory.");
+            return NULL;
+        }
+        LOS_ListInit(g_mountCache);
+    }
+    return g_mountCache;
+}
+#else
+LIST_HEAD* GetMountList(void)
 {
    if (g_mountList == NULL) {
        g_mountList = zalloc(sizeof(LIST_HEAD));
@@ -74,3 +98,4 @@ LIST_HEAD* GetMountList()
    }
    return g_mountList;
 }
+#endif
--- a/fs/vfs/operation/vfs_other.c
+++ b/fs/vfs/operation/vfs_other.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -482,7 +482,7 @@ exit_with_nomem:
    return (char *)NULL;
 }

-static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name)
+static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name, const char *linkName)
 {
    mode_t mode;
    char str[UGO_NUMS][UGO_NUMS + 1] = {0};
@@ -504,11 +504,18 @@ static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name)
        dirFlag = '-';
    }

-    PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s\n", dirFlag,
-           str[0], str[1], str[UGO_NUMS - 1], stat64Info->st_size, stat64Info->st_uid, stat64Info->st_gid, name);
+    if (S_ISLNK(stat64Info->st_mode)) {
+        PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s -> %s\n", dirFlag,
+               str[0], str[1], str[UGO_NUMS - 1], stat64Info->st_size,
+               stat64Info->st_uid, stat64Info->st_gid, name, linkName);
+    } else {
+        PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s\n", dirFlag,
+               str[0], str[1], str[UGO_NUMS - 1], stat64Info->st_size,
+               stat64Info->st_uid, stat64Info->st_gid, name);
+    }
 }

-static void PrintFileInfo(const struct stat *statInfo, const char *name)
+static void PrintFileInfo(const struct stat *statInfo, const char *name, const char *linkName)
 {
    mode_t mode;
    char str[UGO_NUMS][UGO_NUMS + 1] = {0};
@@ -530,19 +537,33 @@ static void PrintFileInfo(const struct stat *statInfo, const char *name)
        dirFlag = '-';
    }

-    PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s\n", dirFlag,
-           str[0], str[1], str[UGO_NUMS - 1], statInfo->st_size, statInfo->st_uid, statInfo->st_gid, name);
+    if (S_ISLNK(statInfo->st_mode)) {
+        PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s -> %s\n", dirFlag,
+               str[0], str[1], str[UGO_NUMS - 1], statInfo->st_size,
+               statInfo->st_uid, statInfo->st_gid, name, linkName);
+    } else {
+        PRINTK("%c%s%s%s %-8lld u:%-5d g:%-5d %-10s\n", dirFlag,
+               str[0], str[1], str[UGO_NUMS - 1], statInfo->st_size,
+               statInfo->st_uid, statInfo->st_gid, name);
+    }
 }

 int LsFile(const char *path)
 {
    struct stat64 stat64Info;
    struct stat statInfo;
+    char linkName[NAME_MAX] = { 0 };

    if (stat64(path, &stat64Info) == 0) {
-        PrintFileInfo64(&stat64Info, path);
+        if (S_ISLNK(stat64Info.st_mode)) {
+            readlink(path, linkName, NAME_MAX);
+        }
+        PrintFileInfo64(&stat64Info, path, (const char *)linkName);
    } else if (stat(path, &statInfo) == 0) {
-        PrintFileInfo(&statInfo, path);
+        if (S_ISLNK(statInfo.st_mode)) {
+            readlink(path, linkName, NAME_MAX);
+        }
+        PrintFileInfo(&statInfo, path, (const char *)linkName);
    } else {
        return -1;
    }
@@ -554,6 +575,7 @@ int LsDir(const char *path)
 {
    struct stat statInfo = { 0 };
    struct stat64 stat64Info = { 0 };
+    char linkName[NAME_MAX] = { 0 };
    DIR *d = NULL;
    char *fullpath = NULL;
    char *fullpath_bak = NULL;
@@ -569,28 +591,34 @@ int LsDir(const char *path)
        pdirent = readdir(d);
        if (pdirent == NULL) {
            break;
-        } else {
-            if (!strcmp(pdirent->d_name, ".") || !strcmp(pdirent->d_name, "..")) {
-                continue;
-            }
-            (void)memset_s(&statInfo, sizeof(struct stat), 0, sizeof(struct stat));
-            (void)memset_s(&stat64Info, sizeof(struct stat), 0, sizeof(struct stat));
-            fullpath = ls_get_fullpath(path, pdirent);
-            if (fullpath == NULL) {
-                (void)closedir(d);
-                return -1;
-            }
-
-            fullpath_bak = fullpath;
-            if (stat64(fullpath, &stat64Info) == 0) {
-                PrintFileInfo64(&stat64Info, pdirent->d_name);
-            } else if (stat(fullpath, &statInfo) == 0) {
-                PrintFileInfo(&statInfo, pdirent->d_name);
-            } else {
-                PRINTK("BAD file: %s\n", pdirent->d_name);
-            }
-            free(fullpath_bak);
        }
+        if (!strcmp(pdirent->d_name, ".") || !strcmp(pdirent->d_name, "..")) {
+            continue;
+        }
+        (void)memset_s(&statInfo, sizeof(struct stat), 0, sizeof(struct stat));
+        (void)memset_s(&stat64Info, sizeof(struct stat), 0, sizeof(struct stat));
+        (void)memset_s(&linkName, sizeof(linkName), 0, sizeof(linkName));
+        fullpath = ls_get_fullpath(path, pdirent);
+        if (fullpath == NULL) {
+            (void)closedir(d);
+            return -1;
+        }
+
+        fullpath_bak = fullpath;
+        if (stat64(fullpath, &stat64Info) == 0) {
+            if (S_ISLNK(stat64Info.st_mode)) {
+                readlink(fullpath, linkName, NAME_MAX);
+            }
+            PrintFileInfo64(&stat64Info, pdirent->d_name, linkName);
+        } else if (stat(fullpath, &statInfo) == 0) {
+            if (S_ISLNK(statInfo.st_mode)) {
+                readlink(fullpath, linkName, NAME_MAX);
+            }
+            PrintFileInfo(&statInfo, pdirent->d_name, linkName);
+        } else {
+            PRINTK("BAD file: %s\n", pdirent->d_name);
+        }
+        free(fullpath_bak);
    } while (1);
    (void)closedir(d);

@@ -730,3 +758,45 @@ mode_t SysUmask(mode_t mask)
    return oldUmask;
 }

+#ifdef LOSCFG_CHROOT
+int chroot(const char *path)
+{
+    int ret;
+    struct Vnode *vnode = NULL;
+
+    if (!path) {
+        set_errno(EFAULT);
+        return VFS_ERROR;
+    }
+
+    if (!strlen(path)) {
+        set_errno(ENOENT);
+        return VFS_ERROR;
+    }
+
+    if (strlen(path) > PATH_MAX) {
+        set_errno(ENAMETOOLONG);
+        return VFS_ERROR;
+    }
+    VnodeHold();
+    ret = VnodeLookup(path, &vnode, 0);
+    if (ret != LOS_OK) {
+        VnodeDrop();
+        return ret;
+    }
+
+    LosProcessCB *curr = OsCurrProcessGet();
+    if ((curr->files == NULL) || (curr->files->rootVnode == NULL)) {
+        VnodeDrop();
+        return VFS_ERROR;
+    }
+    if (curr->files->rootVnode->useCount > 0) {
+        curr->files->rootVnode->useCount--;
+    }
+    vnode->useCount++;
+    curr->files->rootVnode = vnode;
+
+    VnodeDrop();
+    return LOS_OK;
+}
+#endif
--- a/fs/vfs/vfs_cmd/vfs_shellcmd.c
+++ b/fs/vfs/vfs_cmd/vfs_shellcmd.c
@@ -259,7 +259,6 @@ int osShellCmdCat(int argc, const char **argv)
    init_param.uwStackSize  = CAT_TASK_STACK_SIZE;
    init_param.pcName       = "shellcmd_cat";
    init_param.uwResved     = LOS_TASK_STATUS_DETACHED | OS_TASK_FLAG_SPECIFIES_PROCESS;
-    init_param.processID    = 2; /* 2: kProcess */

    ret = (int)LOS_TaskCreate(&ca_task, &init_param);
    if (ret != LOS_OK) {
--- a/fs/vfs/vnode.c
+++ b/fs/vfs/vnode.c
@@ -29,9 +29,11 @@
 */

 #include "los_mux.h"
-#include "vnode.h"
 #include "fs/dirent_fs.h"
 #include "path_cache.h"
+#include "vnode.h"
+#include "los_process.h"
+#include "los_process_pri.h"

 LIST_HEAD g_vnodeFreeList;              /* free vnodes list */
 LIST_HEAD g_vnodeVirtualList;           /* dev vnodes list */
@@ -67,6 +69,13 @@ int VnodesInit(void)
    g_rootVnode->type = VNODE_TYPE_DIR;
    g_rootVnode->filePath = "/";

+#ifdef LOSCFG_CHROOT
+    LosProcessCB *processCB = OsGetKernelInitProcess();
+    if (processCB->files != NULL) {
+        g_rootVnode->useCount++;
+        processCB->files->rootVnode = g_rootVnode;
+    }
+#endif
    return LOS_OK;
 }

@@ -281,7 +290,7 @@ static int PreProcess(const char *originPath, struct Vnode **startVnode, char **

    ret = vfs_normalize_path(NULL, originPath, &absolutePath);
    if (ret == LOS_OK) {
-        *startVnode = g_rootVnode;
+        *startVnode = GetCurrRootVnode();
        *path = absolutePath;
    }

@@ -293,7 +302,21 @@ static struct Vnode *ConvertVnodeIfMounted(struct Vnode *vnode)
    if ((vnode == NULL) || !(vnode->flag & VNODE_FLAG_MOUNT_ORIGIN)) {
        return vnode;
    }
+#ifdef LOSCFG_MNT_CONTAINER
+    LIST_HEAD *mntList = GetMountList();
+    struct Mount *mnt = NULL;
+    LOS_DL_LIST_FOR_EACH_ENTRY(mnt, mntList, struct Mount, mountList) {
+        if ((mnt != NULL) && (mnt->vnodeBeCovered == vnode)) {
+            return mnt->vnodeCovered;
+        }
+    }
+    if (strcmp(vnode->filePath, "/dev") == 0) {
+        return vnode->newMount->vnodeCovered;
+    }
+    return vnode;
+#else
    return vnode->newMount->vnodeCovered;
+#endif
 }

 static void RefreshLRU(struct Vnode *vnode)
@@ -394,7 +417,7 @@ int VnodeLookupAt(const char *path, struct Vnode **result, uint32_t flags, struc
    }

    if (normalizedPath[1] == '\0' && normalizedPath[0] == '/') {
-        *result = g_rootVnode;
+        *result = GetCurrRootVnode();
        free(normalizedPath);
        return LOS_OK;
    }
@@ -454,7 +477,7 @@ int VnodeLookup(const char *path, struct Vnode **vnode, uint32_t flags)

 int VnodeLookupFullpath(const char *fullpath, struct Vnode **vnode, uint32_t flags)
 {
-    return VnodeLookupAt(fullpath, vnode, flags, g_rootVnode);
+    return VnodeLookupAt(fullpath, vnode, flags, GetCurrRootVnode());
 }

 static void ChangeRootInternal(struct Vnode *rootOld, char *dirname)
@@ -496,6 +519,17 @@ void ChangeRoot(struct Vnode *rootNew)
 {
    struct Vnode *rootOld = g_rootVnode;
    g_rootVnode = rootNew;
+#ifdef LOSCFG_CHROOT
+    LosProcessCB *curr = OsCurrProcessGet();
+    if ((curr->files != NULL) &&
+        (curr->files->rootVnode != NULL) &&
+        (curr->files->rootVnode->useCount > 0)) {
+        curr->files->rootVnode->useCount--;
+    }
+    rootNew->useCount++;
+    curr->files->rootVnode = rootNew;
+#endif
+
    ChangeRootInternal(rootOld, "proc");
    ChangeRootInternal(rootOld, "dev");
 }
@@ -682,6 +716,25 @@ void VnodeMemoryDump(void)
    PRINTK("Vnode memory size = %d(B)\n", vnodeCount * sizeof(struct Vnode));
 }

+struct Vnode *GetVnode(INT32 fd)
+{
+    INT32 sysFd;
+
+    if (fd < 0) {
+        PRINT_ERR("Error. fd is invalid as %d\n", fd);
+        return NULL;
+    }
+
+    /* Process fd convert to system global fd */
+    sysFd = GetAssociatedSystemFd(fd);
+    if (sysFd < 0) {
+        PRINT_ERR("Error. sysFd is invalid as %d\n", sysFd);
+        return NULL;
+    }
+
+    return files_get_openfile((int)sysFd);
+}
+
 LIST_HEAD* GetVnodeFreeList()
 {
    return &g_vnodeFreeList;
@@ -719,3 +772,13 @@ int VnodeClearCache(void)

    return count;
 }
+
+struct Vnode *GetCurrRootVnode(void)
+{
+#ifdef LOSCFG_CHROOT
+    LosProcessCB *curr = OsCurrProcessGet();
+    return curr->files->rootVnode;
+#else
+    return g_rootVnode;
+#endif
+}
--- a/kernel/Kconfig
+++ b/kernel/Kconfig
@@ -67,13 +67,49 @@ config PAGE_TABLE_FINE_LOCK
    help
      This option will enable fine lock for page table.

+######################### config options of container ####################
+config KERNEL_CONTAINER
+    bool "Enable container Feature"
+    default n
+    depends on KERNEL_VM
+
+config PID_CONTAINER
+    bool "Enable pid container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
+config UTS_CONTAINER
+    bool "Enable uts container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
+config MNT_CONTAINER
+    bool "Enable mnt container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
+config CHROOT
+    bool "Enable chroot"
+    default n
+    depends on MNT_CONTAINER
+
+config IPC_CONTAINER
+    bool "Enable ipc container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
+config TIME_CONTAINER
+    bool "Enable time container"
+    default n
+    depends on KERNEL_CONTAINER
+
+######################### config options of extended #####################
+source "kernel/extended/Kconfig"
+
 config ENABLE_KERNEL_TEST
    bool "Enable kernel test"
    default n
    help
      This option will enable kernel test.

-######################### config options of extended #####################
-source "kernel/extended/Kconfig"
-
 endmenu
--- a/kernel/base/BUILD.gn
+++ b/kernel/base/BUILD.gn
@@ -1,5 +1,5 @@
 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-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:
@@ -32,7 +32,14 @@ import("//kernel/liteos_a/liteos.gni")
 module_name = get_path_info(rebase_path("."), "name")
 kernel_module(module_name) {
  sources = [
+    "container/los_container.c",
+    "container/los_ipc_container.c",
+    "container/los_mnt_container.c",
+    "container/los_pid_container.c",
+    "container/los_time_container.c",
+    "container/los_uts_container.c",
    "core/los_bitmap.c",
+    "core/los_info.c",
    "core/los_process.c",
    "core/los_smp.c",
    "core/los_swtmr.c",
--- a/kernel/base/Makefile
+++ b/kernel/base/Makefile
@@ -1,5 +1,5 @@
 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-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:
@@ -38,7 +38,9 @@ LOCAL_SRCS := 	$(wildcard ipc/*.c) $(wildcard core/*.c) $(wildcard mem/membox/*.
 		$(wildcard mem/tlsf/*.c) \
 		$(wildcard mp/*.c) \
 		$(wildcard sched/*.c) \
-		$(wildcard vm/*.c)
+		$(wildcard vm/*.c) \
+		$(wildcard container/*.c)
+

 LOCAL_FLAGS := $(LITEOS_CFLAGS_INTERWORK) -Wno-frame-address

--- a/kernel/base/container/los_container.c
+++ b/kernel/base/container/los_container.c
@@ -0,0 +1,354 @@
+/*
+ * 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 "los_container_pri.h"
+#include "los_process_pri.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+
+STATIC Container g_rootContainer;
+STATIC Atomic g_containerCount = 0xF0000000U;
+
+UINT32 OsAllocContainerID(VOID)
+{
+    return LOS_AtomicIncRet(&g_containerCount);
+}
+
+VOID OsContainerInitSystemProcess(LosProcessCB *processCB)
+{
+    processCB->container = &g_rootContainer;
+    LOS_AtomicInc(&processCB->container->rc);
+#ifdef LOSCFG_PID_CONTAINER
+    (VOID)OsAllocSpecifiedVpidUnsafe(processCB->processID, processCB, NULL);
+#endif
+    return;
+}
+
+VOID OsInitRootContainer(VOID)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    (VOID)OsInitRootPidContainer(&g_rootContainer.pidContainer);
+    g_rootContainer.pidForChildContainer = g_rootContainer.pidContainer;
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    (VOID)OsInitRootUtsContainer(&g_rootContainer.utsContainer);
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    (VOID)OsInitRootMntContainer(&g_rootContainer.mntContainer);
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    (VOID)OsInitRootIpcContainer(&g_rootContainer.ipcContainer);
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+    (VOID)OsInitRootTimeContainer(&g_rootContainer.timeContainer);
+    g_rootContainer.timeForChildContainer = g_rootContainer.timeContainer;
+#endif
+    return;
+}
+
+STATIC INLINE Container *CreateContainer(VOID)
+{
+    Container *container = (Container *)LOS_MemAlloc(m_aucSysMem1, sizeof(Container));
+    if (container == NULL) {
+        return NULL;
+    }
+
+    (VOID)memset_s(container, sizeof(Container), 0, sizeof(Container));
+
+    LOS_AtomicInc(&container->rc);
+    return container;
+}
+
+STATIC UINT32 CopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
+{
+    UINT32 ret = LOS_OK;
+    /* Pid container initialization must precede other container initialization. */
+#ifdef LOSCFG_PID_CONTAINER
+    ret = OsCopyPidContainer(flags, child, parent, processID);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    ret = OsCopyUtsContainer(flags, child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    ret = OsCopyMntContainer(flags, child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    ret = OsCopyIpcContainer(flags, child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+    ret = OsCopyTimeContainer(flags, child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+    return ret;
+}
+
+/*
+ * called from clone.  This now handles copy for Container and all
+ * namespaces therein.
+ */
+UINT32 OsCopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
+{
+    UINT32 intSave;
+
+#ifdef LOSCFG_TIME_CONTAINER
+    flags &= ~CLONE_NEWTIME;
+#endif
+
+    if (!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWPID | CLONE_NEWNET | CLONE_NEWTIME))) {
+#ifdef LOSCFG_PID_CONTAINER
+        if (parent->container->pidContainer != parent->container->pidForChildContainer) {
+            goto CREATE_CONTAINER;
+        }
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+        if (parent->container->timeContainer != parent->container->timeForChildContainer) {
+            goto CREATE_CONTAINER;
+        }
+#endif
+        SCHEDULER_LOCK(intSave);
+        child->container = parent->container;
+        LOS_AtomicInc(&child->container->rc);
+        SCHEDULER_UNLOCK(intSave);
+        goto COPY_CONTAINERS;
+    }
+
+#if defined(LOSCFG_PID_CONTAINER) || defined(LOSCFG_TIME_CONTAINER)
+CREATE_CONTAINER:
+#endif
+    child->container = CreateContainer();
+    if (child->container == NULL) {
+        return ENOMEM;
+    }
+
+COPY_CONTAINERS:
+    return CopyContainers(flags, child, parent, processID);
+}
+
+VOID OsContainerFree(LosProcessCB *processCB)
+{
+    LOS_AtomicDec(&processCB->container->rc);
+    if (LOS_AtomicRead(&processCB->container->rc) == 0) {
+        (VOID)LOS_MemFree(m_aucSysMem1, processCB->container);
+        processCB->container = NULL;
+    }
+}
+
+VOID OsContainersDestroy(LosProcessCB *processCB)
+{
+   /* All processes in the container must be destroyed before the container is destroyed. */
+#ifdef LOSCFG_PID_CONTAINER
+    if (processCB->processID == OS_USER_ROOT_PROCESS_ID) {
+        OsPidContainerDestroyAllProcess(processCB);
+    }
+#endif
+
+#ifdef LOSCFG_UTS_CONTAINER
+    OsUtsContainerDestroy(processCB->container);
+#endif
+
+#ifdef LOSCFG_MNT_CONTAINER
+    OsMntContainerDestroy(processCB->container);
+#endif
+
+#ifdef LOSCFG_IPC_CONTAINER
+    OsIpcContainerDestroy(processCB->container);
+#endif
+
+#ifdef LOSCFG_TIME_CONTAINER
+    OsTimeContainerDestroy(processCB);
+#endif
+
+#ifndef LOSCFG_PID_CONTAINER
+    UINT32 intSave;
+    SCHEDULER_LOCK(intSave);
+    OsContainerFree(processCB);
+    SCHEDULER_UNLOCK(intSave);
+#endif
+}
+
+UINT32 OsGetContainerID(Container *container, ContainerType type)
+{
+    if (container == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    switch (type) {
+#ifdef LOSCFG_PID_CONTAINER
+        case PID_CONTAINER:
+            return OsGetPidContainerID(container->pidContainer);
+        case PID_CHILD_CONTAINER:
+            return OsGetPidContainerID(container->pidForChildContainer);
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+        case UTS_CONTAINER:
+            return OsGetUtsContainerID(container->utsContainer);
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+        case MNT_CONTAINER:
+            return OsGetMntContainerID(container->mntContainer);
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+        case IPC_CONTAINER:
+            return OsGetIpcContainerID(container->ipcContainer);
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+        case TIME_CONTAINER:
+            return OsGetTimeContainerID(container->timeContainer);
+        case TIME_CHILD_CONTAINER:
+            return OsGetTimeContainerID(container->timeForChildContainer);
+#endif
+        default:
+            break;
+    }
+    return OS_INVALID_VALUE;
+}
+
+STATIC VOID UnshareDeInitContainer(UINT32 flags, Container *container)
+{
+    UINT32 intSave;
+    if (container == NULL) {
+        return;
+    }
+
+#ifdef LOSCFG_PID_CONTAINER
+    UnshareDeInitPidContainer(container);
+#endif
+
+#ifdef LOSCFG_UTS_CONTAINER
+    if ((flags & CLONE_NEWUTS) != 0) {
+        OsUtsContainerDestroy(container);
+    }
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    if ((flags & CLONE_NEWNS) != 0) {
+        OsMntContainerDestroy(container);
+    }
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    if ((flags & CLONE_NEWIPC) != 0) {
+        OsIpcContainerDestroy(container);
+    }
+#endif
+
+#ifdef LOSCFG_TIME_CONTAINER
+    UnshareDeInitTimeContainer(container);
+#endif
+
+    SCHEDULER_LOCK(intSave);
+    LOS_AtomicDec(&container->rc);
+    if (LOS_AtomicRead(&container->rc) == 0) {
+        (VOID)LOS_MemFree(m_aucSysMem1, container);
+    }
+    SCHEDULER_UNLOCK(intSave);
+}
+
+STATIC UINT32 CreateNewContainers(UINT32 flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 ret = LOS_OK;
+#ifdef LOSCFG_PID_CONTAINER
+    ret = OsUnsharePidContainer(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    ret = OsUnshareUtsContainer(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    ret = OsUnshareMntContainer(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    ret = OsUnshareIpcContainer(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+    ret = OsUnshareTimeContainer(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+    return ret;
+}
+
+INT32 OsUnshare(UINT32 flags)
+{
+    UINT32 ret;
+    UINT32 intSave;
+    LosProcessCB *curr = OsCurrProcessGet();
+    Container *oldContainer = curr->container;
+    UINT32 unshareFlags = CLONE_NEWPID | CLONE_NEWTIME | CLONE_NEWUTS | CLONE_NEWNS | CLONE_NEWIPC;
+
+    if (!(flags & unshareFlags) || ((flags & (~unshareFlags)) != 0)) {
+        return -EINVAL;
+    }
+
+    Container *newContainer = CreateContainer();
+    if (newContainer == NULL) {
+        return -ENOMEM;
+    }
+
+    ret = CreateNewContainers(flags, curr, newContainer);
+    if (ret != LOS_OK) {
+        goto EXIT;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    oldContainer = curr->container;
+    curr->container = newContainer;
+    SCHEDULER_UNLOCK(intSave);
+
+    UnshareDeInitContainer(flags, oldContainer);
+    return LOS_OK;
+
+EXIT:
+    UnshareDeInitContainer(flags, newContainer);
+    return -ret;
+}
+#endif
--- a/kernel/base/container/los_ipc_container.c
+++ b/kernel/base/container/los_ipc_container.c
@@ -0,0 +1,193 @@
+/*
+ * 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.
+ */
+#ifdef LOSCFG_IPC_CONTAINER
+#include "los_ipc_container_pri.h"
+#include "los_config.h"
+#include "los_queue_pri.h"
+#include "los_vm_shm_pri.h"
+#include "los_process_pri.h"
+#include "vnode.h"
+#include "proc_fs.h"
+#include "pthread.h"
+
+#define IPC_INIT_NUM 3
+
+STATIC UINT32 g_currentIpcContainerNum = 0;
+
+STATIC IpcContainer *CreateNewIpcContainer(IpcContainer *parent)
+{
+    pthread_mutexattr_t attr;
+    UINT32 size = sizeof(IpcContainer);
+    IpcContainer *ipcContainer = (IpcContainer *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (ipcContainer == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(ipcContainer, size, 0, size);
+
+    ipcContainer->allQueue = OsAllQueueCBInit(&ipcContainer->freeQueueList);
+    if (ipcContainer->allQueue == NULL) {
+        (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer);
+        return NULL;
+    }
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+    pthread_mutex_init(&ipcContainer->mqueueMutex, &attr);
+
+    ipcContainer->shmSegs = OsShmCBInit(&ipcContainer->sysvShmMux, &ipcContainer->shmInfo,
+                                        &ipcContainer->shmUsedPageCount);
+    if (ipcContainer->shmSegs == NULL) {
+        (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer->allQueue);
+        (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer);
+        return NULL;
+    }
+    ipcContainer->containerID = OsAllocContainerID();
+
+    if (parent != NULL) {
+        LOS_AtomicSet(&ipcContainer->rc, 1);
+    } else {
+        LOS_AtomicSet(&ipcContainer->rc, 3); /* 3: Three system processes */
+    }
+    return ipcContainer;
+}
+
+STATIC UINT32 CreateIpcContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    IpcContainer *parentContainer = parent->container->ipcContainer;
+    IpcContainer *newIpcContainer = CreateNewIpcContainer(parentContainer);
+    if (newIpcContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentIpcContainerNum++;
+    child->container->ipcContainer = newIpcContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsInitRootIpcContainer(IpcContainer **ipcContainer)
+{
+    UINT32 intSave;
+    IpcContainer *newIpcContainer = CreateNewIpcContainer(NULL);
+    if (newIpcContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentIpcContainerNum++;
+    *ipcContainer = newIpcContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsCopyIpcContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    IpcContainer *currIpcContainer = parent->container->ipcContainer;
+
+    if (!(flags & CLONE_NEWIPC)) {
+        SCHEDULER_LOCK(intSave);
+        LOS_AtomicInc(&currIpcContainer->rc);
+        child->container->ipcContainer = currIpcContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    return CreateIpcContainer(child, parent);
+}
+
+UINT32 OsUnshareIpcContainer(UINTPTR flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 intSave;
+    IpcContainer *parentContainer = curr->container->ipcContainer;
+
+    if (!(flags & CLONE_NEWIPC)) {
+        SCHEDULER_LOCK(intSave);
+        newContainer->ipcContainer = parentContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    IpcContainer *ipcContainer = CreateNewIpcContainer(parentContainer);
+    if (ipcContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    newContainer->ipcContainer = ipcContainer;
+    g_currentIpcContainerNum++;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+VOID OsIpcContainerDestroy(Container *container)
+{
+    UINT32 intSave;
+    if (container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    IpcContainer *ipcContainer = container->ipcContainer;
+    if (ipcContainer == NULL) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    LOS_AtomicDec(&ipcContainer->rc);
+    if (LOS_AtomicRead(&ipcContainer->rc) > 0) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    g_currentIpcContainerNum--;
+    SCHEDULER_UNLOCK(intSave);
+    ShmDeinit();
+    container->ipcContainer = NULL;
+    (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer->allQueue);
+    (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer);
+    return;
+}
+
+UINT32 OsGetIpcContainerID(IpcContainer *ipcContainer)
+{
+    if (ipcContainer == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    return ipcContainer->containerID;
+}
+
+IpcContainer *OsGetCurrIpcContainer(VOID)
+{
+    return OsCurrProcessGet()->container->ipcContainer;
+}
+#endif
--- a/kernel/base/container/los_mnt_container.c
+++ b/kernel/base/container/los_mnt_container.c
@@ -0,0 +1,226 @@
+/*
+ * 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 <unistd.h>
+#include "los_mnt_container_pri.h"
+#include "los_container_pri.h"
+#include "los_process_pri.h"
+#include "sys/mount.h"
+#include "vnode.h"
+#include "internal.h"
+
+#ifdef LOSCFG_MNT_CONTAINER
+STATIC UINT32 g_currentMntContainerNum;
+
+LIST_HEAD *GetContainerMntList(VOID)
+{
+    return &OsCurrProcessGet()->container->mntContainer->mountList;
+}
+
+STATIC MntContainer *CreateNewMntContainer(MntContainer *parent)
+{
+    MntContainer *mntContainer = (MntContainer *)LOS_MemAlloc(m_aucSysMem1, sizeof(MntContainer));
+    if (mntContainer == NULL) {
+        return NULL;
+    }
+    mntContainer->containerID = OsAllocContainerID();
+    LOS_ListInit(&mntContainer->mountList);
+
+    if (parent != NULL) {
+        LOS_AtomicSet(&mntContainer->rc, 1);
+    } else {
+        LOS_AtomicSet(&mntContainer->rc, 3); /* 3: Three system processes */
+    }
+    return mntContainer;
+}
+
+STATIC UINT32 CreateMntContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    MntContainer *parentContainer = parent->container->mntContainer;
+    MntContainer *newMntContainer = CreateNewMntContainer(parentContainer);
+    if (newMntContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentMntContainerNum++;
+    child->container->mntContainer = newMntContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsInitRootMntContainer(MntContainer **mntContainer)
+{
+    UINT32 intSave;
+    MntContainer *newMntContainer = CreateNewMntContainer(NULL);
+    if (newMntContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentMntContainerNum++;
+    *mntContainer = newMntContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC UINT32 CopyMountList(MntContainer *parentContainer, MntContainer *newContainer)
+{
+    struct Mount *mnt = NULL;
+    VnodeHold();
+    LOS_DL_LIST_FOR_EACH_ENTRY(mnt, &parentContainer->mountList, struct Mount, mountList) {
+        struct Mount *newMnt = (struct Mount *)zalloc(sizeof(struct Mount));
+        if (newMnt == NULL) {
+            VnodeDrop();
+            return ENOMEM;
+        }
+        *newMnt = *mnt;
+        LOS_ListTailInsert(&newContainer->mountList, &newMnt->mountList);
+        newMnt->vnodeCovered->mntCount++;
+    }
+    VnodeDrop();
+    return LOS_OK;
+}
+
+UINT32 OsCopyMntContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 ret;
+    UINT32 intSave;
+    MntContainer *currMntContainer = parent->container->mntContainer;
+
+    if (!(flags & CLONE_NEWNS)) {
+        SCHEDULER_LOCK(intSave);
+        LOS_AtomicInc(&currMntContainer->rc);
+        child->container->mntContainer = currMntContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    ret = CreateMntContainer(child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    return CopyMountList(currMntContainer, child->container->mntContainer);
+}
+
+UINT32 OsUnshareMntContainer(UINTPTR flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 intSave;
+    UINT32 ret;
+    MntContainer *parentContainer = curr->container->mntContainer;
+
+    if (!(flags & CLONE_NEWNS)) {
+        SCHEDULER_LOCK(intSave);
+        newContainer->mntContainer = parentContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    MntContainer *mntContainer = CreateNewMntContainer(parentContainer);
+    if (mntContainer == NULL) {
+        return ENOMEM;
+    }
+
+    ret = CopyMountList(parentContainer, mntContainer);
+    if (ret != LOS_OK) {
+        (VOID)LOS_MemFree(m_aucSysMem1, mntContainer);
+        return ret;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    newContainer->mntContainer = mntContainer;
+    g_currentMntContainerNum++;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC VOID FreeMountList(LIST_HEAD *mountList)
+{
+    struct Mount *mnt = NULL;
+    struct Mount *nextMnt = NULL;
+
+    VnodeHold();
+    if (LOS_ListEmpty(mountList)) {
+        VnodeDrop();
+        return;
+    }
+
+    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(mnt, nextMnt, mountList, struct Mount, mountList) {
+        if (mnt->vnodeCovered->mntCount > 0) {
+            mnt->vnodeCovered->mntCount--;
+            LOS_ListDelete(&mnt->mountList);
+            free(mnt);
+        } else {
+            umount(mnt->pathName);
+        }
+    }
+    VnodeDrop();
+    return;
+}
+
+VOID OsMntContainerDestroy(Container *container)
+{
+    UINT32 intSave;
+    if (container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    MntContainer *mntContainer = container->mntContainer;
+    if (mntContainer == NULL) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    LOS_AtomicDec(&mntContainer->rc);
+    if (LOS_AtomicRead(&mntContainer->rc) > 0) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    g_currentMntContainerNum--;
+    SCHEDULER_UNLOCK(intSave);
+    FreeMountList(&mntContainer->mountList);
+    container->mntContainer = NULL;
+    (VOID)LOS_MemFree(m_aucSysMem1, mntContainer);
+    return;
+}
+
+UINT32 OsGetMntContainerID(MntContainer *mntContainer)
+{
+    if (mntContainer == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    return mntContainer->containerID;
+}
+#endif
--- a/kernel/base/container/los_pid_container.c
+++ b/kernel/base/container/los_pid_container.c
@@ -0,0 +1,560 @@
+/*
+ * 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 <sched.h>
+#include "los_pid_container_pri.h"
+#include "los_config.h"
+#include "los_process_pri.h"
+#include "los_container_pri.h"
+
+#ifdef LOSCFG_PID_CONTAINER
+
+STATIC UINT32 g_currentPidContainerNum;
+STATIC LosProcessCB *g_defaultProcessCB = NULL;
+STATIC LosTaskCB *g_defaultTaskCB = NULL;
+
+STATIC VOID FreeVpid(LosProcessCB *processCB)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    UINT32 vpid = processCB->processID;
+
+    while ((pidContainer != NULL) && !OS_PID_CHECK_INVALID(vpid)) {
+        ProcessVid *processVid = &pidContainer->pidArray[vpid];
+        processVid->cb = (UINTPTR)g_defaultProcessCB;
+        vpid = processVid->vpid;
+        processVid->vpid = OS_INVALID_VALUE;
+        LOS_ListTailInsert(&pidContainer->pidFreeList, &processVid->node);
+        LOS_AtomicDec(&pidContainer->rc);
+        pidContainer = pidContainer->parent;
+    }
+}
+
+STATIC ProcessVid *OsGetFreeVpid(PidContainer *pidContainer)
+{
+    if (LOS_ListEmpty(&pidContainer->pidFreeList)) {
+        return NULL;
+    }
+
+    ProcessVid *vpid = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&pidContainer->pidFreeList), ProcessVid, node);
+    LOS_ListDelete(&vpid->node);
+    return vpid;
+}
+
+UINT32 OsAllocSpecifiedVpidUnsafe(UINT32 vpid, LosProcessCB *processCB, LosProcessCB *parent)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    if ((pidContainer == NULL) || OS_PID_CHECK_INVALID(vpid)) {
+        return OS_INVALID_VALUE;
+    }
+
+    if (LOS_AtomicRead(&pidContainer->lock) > 0) {
+        return OS_INVALID_VALUE;
+    }
+
+    ProcessVid *processVid = &pidContainer->pidArray[vpid];
+    if (processVid->cb != (UINTPTR)g_defaultProcessCB) {
+        return OS_INVALID_VALUE;
+    }
+
+    processVid->cb = (UINTPTR)processCB;
+    processCB->processID = vpid;
+    LOS_ListDelete(&processVid->node);
+    LOS_AtomicInc(&pidContainer->rc);
+
+    if ((vpid == OS_USER_ROOT_PROCESS_ID) && (parent != NULL)) {
+        ProcessVid *vppidItem = &pidContainer->pidArray[0];
+        LOS_ListDelete(&vppidItem->node);
+        vppidItem->cb = (UINTPTR)parent;
+    }
+
+    pidContainer = pidContainer->parent;
+    while (pidContainer != NULL) {
+        ProcessVid *item = OsGetFreeVpid(pidContainer);
+        if (item == NULL) {
+            break;
+        }
+
+        item->cb = (UINTPTR)processCB;
+        processVid->vpid = item->vid;
+        LOS_AtomicInc(&pidContainer->rc);
+        processVid = item;
+        pidContainer = pidContainer->parent;
+    }
+    return processCB->processID;
+}
+
+STATIC UINT32 OsAllocVpid(LosProcessCB *processCB)
+{
+    ProcessVid *oldProcessVid = NULL;
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    if ((pidContainer == NULL) || (LOS_AtomicRead(&pidContainer->lock) > 0)) {
+        return OS_INVALID_VALUE;
+    }
+
+    processCB->processID = OS_INVALID_VALUE;
+    do {
+        ProcessVid *vpid = OsGetFreeVpid(pidContainer);
+        if (vpid == NULL) {
+            break;
+        }
+        vpid->cb = (UINTPTR)processCB;
+        if (processCB->processID == OS_INVALID_VALUE) {
+            processCB->processID = vpid->vid;
+        } else {
+            oldProcessVid->vpid = vpid->vid;
+        }
+        LOS_AtomicInc(&pidContainer->rc);
+        oldProcessVid = vpid;
+        pidContainer = pidContainer->parent;
+    } while (pidContainer != NULL);
+    return processCB->processID;
+}
+
+STATIC ProcessVid *OsGetFreeVtid(PidContainer *pidContainer)
+{
+    if (LOS_ListEmpty(&pidContainer->tidFreeList)) {
+        return NULL;
+    }
+
+    ProcessVid *vtid = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&pidContainer->tidFreeList), ProcessVid, node);
+    LOS_ListDelete(&vtid->node);
+    return vtid;
+}
+
+VOID OsFreeVtid(LosTaskCB *taskCB)
+{
+    PidContainer *pidContainer = taskCB->pidContainer;
+    UINT32 vtid = taskCB->taskID;
+
+    while ((pidContainer != NULL) && !OS_TID_CHECK_INVALID(vtid)) {
+        ProcessVid *item = &pidContainer->tidArray[vtid];
+        item->cb = (UINTPTR)g_defaultTaskCB;
+        vtid = item->vpid;
+        item->vpid = OS_INVALID_VALUE;
+        LOS_ListTailInsert(&pidContainer->tidFreeList, &item->node);
+        pidContainer = pidContainer->parent;
+    }
+    taskCB->pidContainer = NULL;
+}
+
+UINT32 OsAllocVtid(LosTaskCB *taskCB, const LosProcessCB *processCB)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    ProcessVid *oldTaskVid = NULL;
+
+    do {
+        ProcessVid *item = OsGetFreeVtid(pidContainer);
+        if (item == NULL) {
+            return OS_INVALID_VALUE;
+        }
+
+        if ((pidContainer->parent != NULL) && (item->vid == 0)) {
+            item->cb = (UINTPTR)OsCurrTaskGet();
+            item->vpid = OsCurrTaskGet()->taskID;
+            continue;
+        }
+
+        item->cb = (UINTPTR)taskCB;
+        if (taskCB->pidContainer == NULL) {
+            taskCB->pidContainer = pidContainer;
+            taskCB->taskID = item->vid;
+        } else {
+            oldTaskVid->vpid = item->vid;
+        }
+        oldTaskVid = item;
+        pidContainer = pidContainer->parent;
+    } while (pidContainer != NULL);
+
+    return taskCB->taskID;
+}
+
+VOID OsPidContainerDestroyAllProcess(LosProcessCB *curr)
+{
+    INT32 ret;
+    UINT32 intSave;
+    PidContainer *pidContainer = curr->container->pidContainer;
+    LOS_AtomicInc(&pidContainer->lock);
+
+    for (UINT32 index = 2; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) { /* 2: ordinary process */
+        SCHEDULER_LOCK(intSave);
+        LosProcessCB *processCB = OS_PCB_FROM_PID(index);
+        if (OsProcessIsUnused(processCB)) {
+            SCHEDULER_UNLOCK(intSave);
+            continue;
+        }
+
+        if (curr != processCB->parentProcess) {
+            LOS_ListDelete(&processCB->siblingList);
+            if (OsProcessIsInactive(processCB)) {
+                LOS_ListTailInsert(&curr->exitChildList, &processCB->siblingList);
+            } else {
+                LOS_ListTailInsert(&curr->childrenList, &processCB->siblingList);
+            }
+            processCB->parentProcess = curr;
+        }
+        SCHEDULER_UNLOCK(intSave);
+
+        ret = OsKillLock(index, SIGKILL);
+        if (ret < 0) {
+            PRINT_ERR("Pid container kill all process failed, pid %u, errno=%d\n", index, -ret);
+        }
+
+        ret = LOS_Wait(index, NULL, 0, NULL);
+        if (ret != index) {
+            PRINT_ERR("Pid container wait pid %d failed, errno=%d\n", index, -ret);
+        }
+    }
+}
+
+STATIC PidContainer *CreateNewPidContainer(PidContainer *parent)
+{
+    UINT32 index;
+    PidContainer *newPidContainer = (PidContainer *)LOS_MemAlloc(m_aucSysMem1, sizeof(PidContainer));
+    if (newPidContainer == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(newPidContainer, sizeof(PidContainer), 0, sizeof(PidContainer));
+
+    newPidContainer->containerID = OsAllocContainerID();
+    LOS_ListInit(&newPidContainer->pidFreeList);
+    for (index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        ProcessVid *vpid = &newPidContainer->pidArray[index];
+        vpid->vid = index;
+        vpid->vpid = OS_INVALID_VALUE;
+        vpid->cb = (UINTPTR)g_defaultProcessCB;
+        LOS_ListTailInsert(&newPidContainer->pidFreeList, &vpid->node);
+    }
+
+    LOS_ListInit(&newPidContainer->tidFreeList);
+    for (index = 0; index < LOSCFG_BASE_CORE_TSK_LIMIT; index++) {
+        ProcessVid *vtid = &newPidContainer->tidArray[index];
+        vtid->vid = index;
+        vtid->vpid = OS_INVALID_VALUE;
+        vtid->cb = (UINTPTR)g_defaultTaskCB;
+        LOS_ListTailInsert(&newPidContainer->tidFreeList, &vtid->node);
+    }
+
+    newPidContainer->parent = parent;
+    if (parent != NULL) {
+        LOS_AtomicSet(&newPidContainer->level, parent->level + 1);
+        newPidContainer->referenced = FALSE;
+    } else {
+        LOS_AtomicSet(&newPidContainer->level, 0);
+        newPidContainer->referenced = TRUE;
+    }
+    return newPidContainer;
+}
+
+VOID OsPidContainerDestroy(LosProcessCB *curr)
+{
+    if (curr->container == NULL) {
+        return;
+    }
+
+    PidContainer *pidContainer = curr->container->pidContainer;
+    if (pidContainer == NULL) {
+        return;
+    }
+
+    FreeVpid(curr);
+
+    if (pidContainer != curr->container->pidForChildContainer) {
+        LOS_AtomicDec(&curr->container->pidForChildContainer->rc);
+        if (LOS_AtomicRead(&curr->container->pidForChildContainer->rc) <= 0) {
+            g_currentPidContainerNum--;
+            (VOID)LOS_MemFree(m_aucSysMem1, curr->container->pidForChildContainer);
+            curr->container->pidForChildContainer = NULL;
+        }
+    }
+
+    if (LOS_AtomicRead(&pidContainer->rc) <= 0) {
+        g_currentPidContainerNum--;
+        curr->container->pidContainer = NULL;
+        curr->container->pidForChildContainer = NULL;
+        (VOID)LOS_MemFree(m_aucSysMem1, pidContainer);
+    }
+
+    OsContainerFree(curr);
+}
+
+STATIC UINT32 CreatePidContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 ret;
+    UINT32 intSave;
+
+    PidContainer *parentContainer = parent->container->pidContainer;
+    PidContainer *newPidContainer = CreateNewPidContainer(parentContainer);
+    if (newPidContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if ((parentContainer->level + 1) >= PID_CONTAINER_LEVEL_LIMIT) {
+        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
+        SCHEDULER_UNLOCK(intSave);
+        return EINVAL;
+    }
+
+    g_currentPidContainerNum++;
+    newPidContainer->referenced = TRUE;
+    child->container->pidContainer = newPidContainer;
+    child->container->pidForChildContainer = newPidContainer;
+    ret = OsAllocSpecifiedVpidUnsafe(OS_USER_ROOT_PROCESS_ID, child, parent);
+    if (ret == OS_INVALID_VALUE) {
+        g_currentPidContainerNum--;
+        FreeVpid(child);
+        child->container->pidContainer = NULL;
+        child->container->pidForChildContainer = NULL;
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
+        return ENOSPC;
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC UINT32 UnshareCreatePidContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 ret;
+
+    parent->container->pidForChildContainer->referenced = TRUE;
+    child->container->pidContainer = parent->container->pidForChildContainer;
+    child->container->pidForChildContainer = parent->container->pidForChildContainer;
+    ret = OsAllocSpecifiedVpidUnsafe(OS_USER_ROOT_PROCESS_ID, child, parent);
+    if (ret == OS_INVALID_VALUE) {
+        FreeVpid(child);
+        child->container->pidContainer = NULL;
+        child->container->pidForChildContainer = NULL;
+        return ENOSPC;
+    }
+    return LOS_OK;
+}
+
+UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
+{
+    UINT32 ret;
+    UINT32 intSave;
+
+    SCHEDULER_LOCK(intSave);
+    PidContainer *parentPidContainer = parent->container->pidContainer;
+    PidContainer *parentPidContainerForChild = parent->container->pidForChildContainer;
+    if ((parentPidContainer == parentPidContainerForChild) || (parentPidContainerForChild->referenced == TRUE)) {
+        /* The current process is not executing unshare */
+        if (!(flags & CLONE_NEWPID)) {
+            child->container->pidContainer = parentPidContainer;
+            child->container->pidForChildContainer = parentPidContainer;
+            ret = OsAllocVpid(child);
+            SCHEDULER_UNLOCK(intSave);
+            if (ret == OS_INVALID_VALUE) {
+                PRINT_ERR("[%s] alloc vpid failed\n", __FUNCTION__);
+                return ENOSPC;
+            }
+            *processID = child->processID;
+            return LOS_OK;
+        }
+        SCHEDULER_UNLOCK(intSave);
+
+        ret = CreatePidContainer(child, parent);
+        if (ret != LOS_OK) {
+            return ret;
+        }
+    } else {
+        /* Create the first process after unshare */
+        ret = UnshareCreatePidContainer(child, parent);
+        SCHEDULER_UNLOCK(intSave);
+        if (ret != LOS_OK) {
+            return ret;
+        }
+    }
+
+    PidContainer *pidContainer = child->container->pidContainer;
+    if (pidContainer->pidArray[child->processID].vpid == OS_INVALID_VALUE) {
+        *processID = child->processID;
+    } else {
+        *processID = pidContainer->pidArray[child->processID].vpid;
+    }
+    return LOS_OK;
+}
+
+VOID UnshareDeInitPidContainer(Container *container)
+{
+    UINT32 intSave;
+    PidContainer *pidForChildContainer = NULL;
+    if (container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if ((container->pidForChildContainer != NULL) && (container->pidContainer != container->pidForChildContainer)) {
+        LOS_AtomicDec(&container->pidForChildContainer->rc);
+        if (LOS_AtomicRead(&container->pidForChildContainer->rc) <= 0) {
+            g_currentPidContainerNum--;
+            pidForChildContainer = container->pidForChildContainer;
+            container->pidForChildContainer = NULL;
+            container->pidContainer = NULL;
+        }
+    }
+    SCHEDULER_UNLOCK(intSave);
+    (VOID)LOS_MemFree(m_aucSysMem1, pidForChildContainer);
+}
+
+UINT32 OsUnsharePidContainer(UINTPTR flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 intSave;
+    if (!(flags & CLONE_NEWPID)) {
+        SCHEDULER_LOCK(intSave);
+        newContainer->pidContainer = curr->container->pidContainer;
+        newContainer->pidForChildContainer = curr->container->pidForChildContainer;
+        if (newContainer->pidContainer != newContainer->pidForChildContainer) {
+            LOS_AtomicInc(&newContainer->pidForChildContainer->rc);
+        }
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    PidContainer *pidForChild = CreateNewPidContainer(curr->container->pidContainer);
+    if (pidForChild == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if (curr->container->pidContainer != curr->container->pidForChildContainer) {
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, pidForChild);
+        return EINVAL;
+    }
+
+    if (pidForChild->level >= PID_CONTAINER_LEVEL_LIMIT) {
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, pidForChild);
+        return EINVAL;
+    }
+
+    g_currentPidContainerNum++;
+    newContainer->pidContainer = curr->container->pidContainer;
+    newContainer->pidForChildContainer = pidForChild;
+    LOS_AtomicSet(&pidForChild->rc, 1);
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsInitRootPidContainer(PidContainer **pidContainer)
+{
+    UINT32 intSave;
+    g_defaultTaskCB = OsGetDefaultTaskCB();
+    g_defaultProcessCB = OsGetDefaultProcessCB();
+
+    PidContainer *newPidContainer = CreateNewPidContainer(NULL);
+    if (newPidContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentPidContainerNum++;
+    *pidContainer = newPidContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsGetVpidFromCurrContainer(const LosProcessCB *processCB)
+{
+    UINT32 vpid = processCB->processID;
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    PidContainer *currPidContainer = OsCurrTaskGet()->pidContainer;
+    while (pidContainer != NULL) {
+        ProcessVid *vid = &pidContainer->pidArray[vpid];
+        if (currPidContainer != pidContainer) {
+            vpid = vid->vpid;
+            pidContainer = pidContainer->parent;
+            continue;
+        }
+
+        return vid->vid;
+    }
+    return OS_INVALID_VALUE;
+}
+
+UINT32 OsGetVpidFromRootContainer(const LosProcessCB *processCB)
+{
+    UINT32 vpid = processCB->processID;
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    while (pidContainer != NULL) {
+        ProcessVid *vid = &pidContainer->pidArray[vpid];
+        if (pidContainer->parent != NULL) {
+            vpid = vid->vpid;
+            pidContainer = pidContainer->parent;
+            continue;
+        }
+
+        return vid->vid;
+    }
+    return OS_INVALID_VALUE;
+}
+
+UINT32 OsGetVtidFromCurrContainer(const LosTaskCB *taskCB)
+{
+    UINT32 vtid = taskCB->taskID;
+    PidContainer *pidContainer = taskCB->pidContainer;
+    PidContainer *currPidContainer = OsCurrTaskGet()->pidContainer;
+    while (pidContainer != NULL) {
+        ProcessVid *vid = &pidContainer->tidArray[vtid];
+        if (currPidContainer != pidContainer) {
+            vtid = vid->vpid;
+            pidContainer = pidContainer->parent;
+            continue;
+        }
+        return vid->vid;
+    }
+    return OS_INVALID_VALUE;
+}
+
+LosProcessCB *OsGetPCBFromVpid(UINT32 vpid)
+{
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    ProcessVid *processVid = &pidContainer->pidArray[vpid];
+    return (LosProcessCB *)processVid->cb;
+}
+
+LosTaskCB *OsGetTCBFromVtid(UINT32 vtid)
+{
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    ProcessVid *taskVid = &pidContainer->tidArray[vtid];
+    return (LosTaskCB *)taskVid->cb;
+}
+
+UINT32 OsGetPidContainerID(PidContainer *pidContainer)
+{
+    if (pidContainer == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    return pidContainer->containerID;
+}
+#endif
--- a/kernel/base/container/los_time_container.c
+++ b/kernel/base/container/los_time_container.c
@@ -0,0 +1,245 @@
+/*
+ * 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 "los_time_container_pri.h"
+#include "los_process_pri.h"
+
+#ifdef LOSCFG_TIME_CONTAINER
+STATIC UINT32 g_currentTimeContainerNum;
+
+STATIC TimeContainer *CreateNewTimeContainer(TimeContainer *parent)
+{
+    UINT32 size = sizeof(TimeContainer);
+    TimeContainer *timeContainer = (TimeContainer *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (timeContainer == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(timeContainer, size, 0, size);
+
+    timeContainer->containerID = OsAllocContainerID();
+    if (parent != NULL) {
+        timeContainer->frozenOffsets = FALSE;
+        LOS_AtomicSet(&timeContainer->rc, 1);
+    } else {
+        timeContainer->frozenOffsets = TRUE;
+        LOS_AtomicSet(&timeContainer->rc, 3); /* 3: Three system processes */
+    }
+    return timeContainer;
+}
+
+STATIC UINT32 CreateTimeContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+
+    SCHEDULER_LOCK(intSave);
+    TimeContainer *newTimeContainer = parent->container->timeForChildContainer;
+    LOS_AtomicInc(&newTimeContainer->rc);
+    newTimeContainer->frozenOffsets = TRUE;
+    child->container->timeContainer = newTimeContainer;
+    child->container->timeForChildContainer = newTimeContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsInitRootTimeContainer(TimeContainer **timeContainer)
+{
+    UINT32 intSave;
+    TimeContainer *newTimeContainer = CreateNewTimeContainer(NULL);
+    if (newTimeContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    *timeContainer = newTimeContainer;
+    g_currentTimeContainerNum++;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsCopyTimeContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    TimeContainer *currTimeContainer = parent->container->timeContainer;
+
+    if (currTimeContainer == parent->container->timeForChildContainer) {
+        SCHEDULER_LOCK(intSave);
+        LOS_AtomicInc(&currTimeContainer->rc);
+        child->container->timeContainer = currTimeContainer;
+        child->container->timeForChildContainer = currTimeContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    return CreateTimeContainer(child, parent);
+}
+
+UINT32 OsUnshareTimeContainer(UINTPTR flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 intSave;
+    if (!(flags & CLONE_NEWTIME)) {
+        SCHEDULER_LOCK(intSave);
+        newContainer->timeContainer = curr->container->timeContainer;
+        newContainer->timeForChildContainer = curr->container->timeForChildContainer;
+        if (newContainer->timeContainer != newContainer->timeForChildContainer) {
+            LOS_AtomicInc(&newContainer->timeForChildContainer->rc);
+        }
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    TimeContainer *timeForChild = CreateNewTimeContainer(curr->container->timeContainer);
+    if (timeForChild == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if (curr->container->timeContainer != curr->container->timeForChildContainer) {
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, timeForChild);
+        return EINVAL;
+    }
+
+    (VOID)memcpy_s(&timeForChild->monotonic, sizeof(struct timespec64),
+                   &curr->container->timeContainer->monotonic, sizeof(struct timespec64));
+    newContainer->timeContainer = curr->container->timeContainer;
+    newContainer->timeForChildContainer = timeForChild;
+    g_currentTimeContainerNum++;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+VOID UnshareDeInitTimeContainer(Container *container)
+{
+    UINT32 intSave;
+    TimeContainer *timeForChildContainer = NULL;
+    if (container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if ((container->timeForChildContainer != NULL) && (container->timeForChildContainer != container->timeContainer)) {
+        LOS_AtomicDec(&container->timeForChildContainer->rc);
+        if (LOS_AtomicRead(&container->timeForChildContainer->rc) <= 0) {
+            g_currentTimeContainerNum--;
+            timeForChildContainer = container->timeForChildContainer;
+            container->timeForChildContainer = NULL;
+            container->timeContainer = NULL;
+        }
+    }
+    SCHEDULER_UNLOCK(intSave);
+    (VOID)LOS_MemFree(m_aucSysMem1, timeForChildContainer);
+}
+
+VOID OsTimeContainerDestroy(LosProcessCB *curr)
+{
+    UINT32 intSave;
+    TimeContainer *timeContainer = NULL;
+    TimeContainer *timeForChild = NULL;
+
+    if (curr->container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if (curr->container->timeContainer == NULL) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    if (curr->container->timeContainer != curr->container->timeForChildContainer) {
+        LOS_AtomicDec(&curr->container->timeForChildContainer->rc);
+        if (LOS_AtomicRead(&curr->container->timeForChildContainer->rc) <= 0) {
+            g_currentTimeContainerNum--;
+            timeForChild = curr->container->timeForChildContainer;
+            curr->container->timeForChildContainer = NULL;
+        }
+    }
+
+    LOS_AtomicDec(&curr->container->timeContainer->rc);
+    if (LOS_AtomicRead(&curr->container->timeContainer->rc) <= 0) {
+        g_currentTimeContainerNum--;
+        timeContainer = curr->container->timeContainer;
+        curr->container->timeContainer = NULL;
+        curr->container->timeForChildContainer = NULL;
+    }
+    SCHEDULER_UNLOCK(intSave);
+    (VOID)LOS_MemFree(m_aucSysMem1, timeForChild);
+    (VOID)LOS_MemFree(m_aucSysMem1, timeContainer);
+    return;
+}
+
+UINT32 OsGetTimeContainerID(TimeContainer *timeContainer)
+{
+    if (timeContainer == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    return timeContainer->containerID;
+}
+
+TimeContainer *OsGetCurrTimeContainer(VOID)
+{
+    return OsCurrProcessGet()->container->timeContainer;
+}
+
+UINT32 OsGetTimeContainerMonotonic(LosProcessCB *processCB, struct timespec64 *offsets)
+{
+    if ((processCB == NULL) || (offsets == NULL)) {
+        return EINVAL;
+    }
+
+    if (OsProcessIsInactive(processCB)) {
+        return ESRCH;
+    }
+
+    TimeContainer *timeContainer = processCB->container->timeForChildContainer;
+    (VOID)memcpy_s(offsets, sizeof(struct timespec64), &timeContainer->monotonic, sizeof(struct timespec64));
+    return LOS_OK;
+}
+
+UINT32 OsSetTimeContainerMonotonic(LosProcessCB *processCB, struct timespec64 *offsets)
+{
+    if ((processCB == NULL) || (offsets == NULL)) {
+        return EINVAL;
+    }
+
+    if (OsProcessIsInactive(processCB)) {
+        return ESRCH;
+    }
+
+    TimeContainer *timeContainer = processCB->container->timeForChildContainer;
+    if (timeContainer->frozenOffsets) {
+        return EACCES;
+    }
+
+    timeContainer->monotonic.tv_sec = offsets->tv_sec;
+    timeContainer->monotonic.tv_nsec = offsets->tv_nsec;
+    return LOS_OK;
+}
+#endif
--- a/kernel/base/container/los_uts_container.c
+++ b/kernel/base/container/los_uts_container.c
@@ -0,0 +1,215 @@
+/*
+ * 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 InitUtsContainer(struct utsname *name)
+{
+    INT32 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;
+}
+
+STATIC UtsContainer *CreateNewUtsContainer(UtsContainer *parent)
+{
+    UINT32 ret;
+    UINT32 size = sizeof(UtsContainer);
+    UtsContainer *utsContainer = (UtsContainer *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (utsContainer == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(utsContainer, sizeof(UtsContainer), 0, sizeof(UtsContainer));
+
+    utsContainer->containerID = OsAllocContainerID();
+    if (parent != NULL) {
+        LOS_AtomicSet(&utsContainer->rc, 1);
+        return utsContainer;
+    }
+    LOS_AtomicSet(&utsContainer->rc, 3); /* 3: Three system processes */
+    ret = InitUtsContainer(&utsContainer->utsName);
+    if (ret != LOS_OK) {
+        (VOID)LOS_MemFree(m_aucSysMem1, utsContainer);
+        return NULL;
+    }
+    return utsContainer;
+}
+
+STATIC UINT32 CreateUtsContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    UtsContainer *parentContainer = parent->container->utsContainer;
+    UtsContainer *newUtsContainer = CreateNewUtsContainer(parentContainer);
+    if (newUtsContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentUtsContainerNum++;
+    (VOID)memcpy_s(&newUtsContainer->utsName, sizeof(newUtsContainer->utsName),
+                   &parentContainer->utsName, sizeof(parentContainer->utsName));
+    child->container->utsContainer = newUtsContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsInitRootUtsContainer(UtsContainer **utsContainer)
+{
+    UINT32 intSave;
+    UtsContainer *newUtsContainer = CreateNewUtsContainer(NULL);
+    if (newUtsContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentUtsContainerNum++;
+    *utsContainer = newUtsContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsCopyUtsContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    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;
+    }
+
+    return CreateUtsContainer(child, parent);
+}
+
+UINT32 OsUnshareUtsContainer(UINTPTR flags, LosProcessCB *curr, Container *newContainer)
+{
+    UINT32 intSave;
+    UtsContainer *parentContainer = curr->container->utsContainer;
+
+    if (!(flags & CLONE_NEWUTS)) {
+        SCHEDULER_LOCK(intSave);
+        newContainer->utsContainer = parentContainer;
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_OK;
+    }
+
+    UtsContainer *utsContainer = CreateNewUtsContainer(parentContainer);
+    if (utsContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    newContainer->utsContainer = utsContainer;
+    g_currentUtsContainerNum++;
+    (VOID)memcpy_s(&utsContainer->utsName, sizeof(utsContainer->utsName),
+                   &parentContainer->utsName, sizeof(parentContainer->utsName));
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+VOID OsUtsContainerDestroy(Container *container)
+{
+    UINT32 intSave;
+    if (container == NULL) {
+        return;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    UtsContainer *utsContainer = container->utsContainer;
+    if (utsContainer == NULL) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    LOS_AtomicDec(&utsContainer->rc);
+    if (LOS_AtomicRead(&utsContainer->rc) > 0) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+    g_currentUtsContainerNum--;
+    container->utsContainer = NULL;
+    SCHEDULER_UNLOCK(intSave);
+    (VOID)LOS_MemFree(m_aucSysMem1, utsContainer);
+    return;
+}
+
+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;
+}
+
+UINT32 OsGetUtsContainerID(UtsContainer *utsContainer)
+{
+    if (utsContainer == NULL) {
+        return OS_INVALID_VALUE;
+    }
+
+    return utsContainer->containerID;
+}
+
+#endif
--- a/kernel/base/core/los_info.c
+++ b/kernel/base/core/los_info.c
@@ -0,0 +1,249 @@
+/*
+ * 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 "los_info_pri.h"
+#include "los_task_pri.h"
+#include "los_vm_dump.h"
+
+STATIC UINT32 GetCurrParentPid(UINT32 pid, const LosProcessCB *processCB)
+{
+    if (processCB->parentProcess == NULL) {
+        return 0;
+    }
+
+#ifdef LOSCFG_PID_CONTAINER
+    if (pid == OS_USER_ROOT_PROCESS_ID) {
+        return 0;
+    }
+
+    if (OS_PROCESS_CONTAINER_CHECK(processCB->parentProcess, OsCurrProcessGet())) {
+        return OsGetVpidFromCurrContainer(processCB->parentProcess);
+    }
+#endif
+    return processCB->parentProcess->processID;
+}
+
+STATIC INLINE UINT32 GetCurrTid(const LosTaskCB *taskCB)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    if (taskCB->pidContainer != OsCurrTaskGet()->pidContainer) {
+        return OsGetVtidFromCurrContainer(taskCB);
+    }
+#endif
+    return taskCB->taskID;
+}
+
+STATIC UINT16 GetProcessStatus(LosProcessCB *processCB)
+{
+    UINT16 status;
+    LosTaskCB *taskCB = NULL;
+
+    if (LOS_ListEmpty(&processCB->threadSiblingList)) {
+        return processCB->processStatus;
+    }
+
+    status = processCB->processStatus;
+    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
+        status |= (taskCB->taskStatus & 0x00FF);
+    }
+    return status;
+}
+
+STATIC VOID GetProcessInfo(ProcessInfo *pcbInfo, const LosProcessCB *processCB)
+{
+    SchedParam param = {0};
+    pcbInfo->pid = OsGetPid(processCB);
+    pcbInfo->ppid = GetCurrParentPid(pcbInfo->pid, processCB);
+    pcbInfo->status = GetProcessStatus((LosProcessCB *)processCB);
+    pcbInfo->mode = processCB->processMode;
+    if (processCB->pgroup != NULL) {
+        pcbInfo->pgroupID = OsGetPid(OS_GET_PGROUP_LEADER(processCB->pgroup));
+    } else {
+        pcbInfo->pgroupID = -1;
+    }
+#ifdef LOSCFG_SECURITY_CAPABILITY
+    if (processCB->user != NULL) {
+        pcbInfo->userID = processCB->user->userID;
+    } else {
+        pcbInfo->userID = -1;
+    }
+#else
+    pcbInfo->userID = 0;
+#endif
+    LosTaskCB *taskCB = processCB->threadGroup;
+    pcbInfo->threadGroupID = taskCB->taskID;
+    taskCB->ops->schedParamGet(taskCB, &param);
+    pcbInfo->policy = LOS_SCHED_RR;
+    pcbInfo->basePrio = param.basePrio;
+    pcbInfo->threadNumber = processCB->threadNumber;
+#ifdef LOSCFG_KERNEL_CPUP
+    (VOID)OsGetProcessAllCpuUsageUnsafe(processCB->processCpup, pcbInfo);
+#endif
+    (VOID)memcpy_s(pcbInfo->name, OS_PCB_NAME_LEN, processCB->processName, OS_PCB_NAME_LEN);
+}
+
+STATIC VOID GetProcessMemInfo(ProcessInfo *pcbInfo, const LosProcessCB *processCB, LosVmSpace *vmSpace)
+{
+    /* Process memory usage statistics, idle task defaults to 0 */
+    if (processCB == &g_processCBArray[0]) {
+        pcbInfo->virtualMem = 0;
+        pcbInfo->shareMem = 0;
+        pcbInfo->physicalMem = 0;
+    } else if (vmSpace == LOS_GetKVmSpace()) {
+        (VOID)OsShellCmdProcessPmUsage(vmSpace, &pcbInfo->shareMem, &pcbInfo->physicalMem);
+        pcbInfo->virtualMem = pcbInfo->physicalMem;
+    } else {
+        pcbInfo->virtualMem = OsShellCmdProcessVmUsage(vmSpace);
+        if (pcbInfo->virtualMem == 0) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            return;
+        }
+        if (OsShellCmdProcessPmUsage(vmSpace, &pcbInfo->shareMem, &pcbInfo->physicalMem) == 0) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+        }
+    }
+}
+
+STATIC VOID GetThreadInfo(ProcessThreadInfo *threadInfo, LosProcessCB *processCB)
+{
+    SchedParam param = {0};
+    LosTaskCB *taskCB = NULL;
+    if (LOS_ListEmpty(&processCB->threadSiblingList)) {
+        threadInfo->threadCount = 0;
+        return;
+    }
+
+    threadInfo->threadCount = 0;
+    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
+        TaskInfo *taskInfo = &threadInfo->taskInfo[threadInfo->threadCount];
+        taskInfo->tid = GetCurrTid(taskCB);
+        taskInfo->pid = OsGetPid(processCB);
+        taskInfo->status = taskCB->taskStatus;
+        taskCB->ops->schedParamGet(taskCB, &param);
+        taskInfo->policy = param.policy;
+        taskInfo->priority = param.priority;
+#ifdef LOSCFG_KERNEL_SMP
+        taskInfo->currCpu = taskCB->currCpu;
+        taskInfo->cpuAffiMask = taskCB->cpuAffiMask;
+#endif
+        taskInfo->stackPoint = (UINTPTR)taskCB->stackPointer;
+        taskInfo->topOfStack = taskCB->topOfStack;
+        taskInfo->stackSize = taskCB->stackSize;
+        taskInfo->waitFlag = taskCB->waitFlag;
+        taskInfo->waitID = taskCB->waitID;
+        taskInfo->taskMux = taskCB->taskMux;
+        (VOID)OsStackWaterLineGet((const UINTPTR *)(taskCB->topOfStack + taskCB->stackSize),
+                                  (const UINTPTR *)taskCB->topOfStack, &taskInfo->waterLine);
+#ifdef LOSCFG_KERNEL_CPUP
+        (VOID)OsGetTaskAllCpuUsageUnsafe(&taskCB->taskCpup, taskInfo);
+#endif
+        (VOID)memcpy_s(taskInfo->name, OS_TCB_NAME_LEN, taskCB->taskName, OS_TCB_NAME_LEN);
+        threadInfo->threadCount++;
+    }
+}
+
+UINT32 OsGetProcessThreadInfo(UINT32 pid, ProcessThreadInfo *threadInfo)
+{
+    UINT32 intSave;
+
+    if (OS_PID_CHECK_INVALID(pid) || (pid == 0) || (threadInfo == NULL)) {
+        return LOS_NOK;
+    }
+
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
+    if (OsProcessIsUnused(processCB)) {
+        return LOS_NOK;
+    }
+
+    GetProcessMemInfo(&threadInfo->processInfo, processCB, processCB->vmSpace);
+
+    SCHEDULER_LOCK(intSave);
+    GetProcessInfo(&threadInfo->processInfo, processCB);
+    GetThreadInfo(threadInfo, processCB);
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC VOID ProcessMemUsageGet(ProcessInfo *pcbArray)
+{
+    UINT32 intSave;
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
+        ProcessVid *processVid = &pidContainer->pidArray[pid];
+        const LosProcessCB *processCB = (LosProcessCB *)processVid->cb;
+#else
+    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
+        const LosProcessCB *processCB = OS_PCB_FROM_RPID(pid);
+#endif
+        ProcessInfo *pcbInfo = pcbArray + pid;
+        SCHEDULER_LOCK(intSave);
+        if (OsProcessIsUnused(processCB)) {
+            SCHEDULER_UNLOCK(intSave);
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            continue;
+        }
+
+        LosVmSpace *vmSpace  = processCB->vmSpace;
+        SCHEDULER_UNLOCK(intSave);
+
+        GetProcessMemInfo(pcbInfo, processCB, vmSpace);
+    }
+}
+
+UINT32 OsGetAllProcessInfo(ProcessInfo *pcbArray)
+{
+    UINT32 intSave;
+    if (pcbArray == NULL) {
+        return LOS_NOK;
+    }
+
+    ProcessMemUsageGet(pcbArray);
+
+    SCHEDULER_LOCK(intSave);
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    for (UINT32 index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        ProcessVid *processVid = &pidContainer->pidArray[index];
+        LosProcessCB *processCB = (LosProcessCB *)processVid->cb;
+#else
+    for (UINT32 index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        LosProcessCB *processCB = OS_PCB_FROM_RPID(index);
+#endif
+        ProcessInfo *pcbInfo = pcbArray + index;
+        if (OsProcessIsUnused(processCB)) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            continue;
+        }
+        GetProcessInfo(pcbInfo, processCB);
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
--- a/kernel/base/core/los_process.c
+++ b/kernel/base/core/los_process.c
--- a/kernel/base/core/los_smp.c
+++ b/kernel/base/core/los_smp.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -45,11 +45,13 @@ STATIC VOID OsSmpSecondaryInit(VOID *arg)
 {
    UNUSED(arg);

+    OsCurrTaskSet(OsGetMainTask());
+
 #ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
    OsSwtmrInit();
 #endif

-    OsIdleTaskCreate();
+    OsIdleTaskCreate((UINTPTR)OsGetIdleProcess());
    OsInitCall(LOS_INIT_LEVEL_KMOD_TASK);

    OsSchedStart();
--- a/kernel/base/core/los_swtmr.c
+++ b/kernel/base/core/los_swtmr.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -320,10 +320,10 @@ BOOL OsIsSwtmrTask(const LosTaskCB *taskCB)
    return FALSE;
 }

-LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINT32 processID)
+LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINTPTR ownerID)
 {
    for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
-        if (g_swtmrCBArray[index].uwOwnerPid == processID) {
+        if (g_swtmrCBArray[index].uwOwnerPid == ownerID) {
            LOS_SwtmrDelete(index);
        }
    }
@@ -524,7 +524,7 @@ STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr)
    /* insert to free list */
    LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
    swtmr->ucState = OS_SWTMR_STATUS_UNUSED;
-    swtmr->uwOwnerPid = 0;
+    swtmr->uwOwnerPid = OS_INVALID_VALUE;

    SwtmrDebugDataClear(swtmr->usTimerID);
 }
@@ -680,7 +680,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
    LOS_ListDelete(LOS_DL_LIST_FIRST(&g_swtmrFreeList));
    SWTMR_UNLOCK(intSave);

-    swtmr->uwOwnerPid = OsCurrProcessGet()->processID;
+    swtmr->uwOwnerPid = (UINTPTR)OsCurrProcessGet();
    swtmr->pfnHandler = handler;
    swtmr->ucMode = mode;
    swtmr->uwOverrun = 0;
--- a/kernel/base/core/los_task.c
+++ b/kernel/base/core/los_task.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -61,6 +61,9 @@
 #ifdef LOSCFG_ENABLE_OOM_LOOP_TASK
 #include "los_oom.h"
 #endif
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif

 #if (LOSCFG_BASE_CORE_TSK_LIMIT <= 0)
 #error "task maxnum cannot be zero"
@@ -81,12 +84,12 @@ STATIC VOID OsConsoleIDSetHook(UINT32 param1,
 /* temp task blocks for booting procedure */
 LITE_OS_SEC_BSS STATIC LosTaskCB                g_mainTask[LOSCFG_KERNEL_CORE_NUM];

-LosTaskCB *OsGetMainTask()
+LosTaskCB *OsGetMainTask(VOID)
 {
    return (LosTaskCB *)(g_mainTask + ArchCurrCpuid());
 }

-VOID OsSetMainTask()
+VOID OsSetMainTask(VOID)
 {
    UINT32 i;
    CHAR *name = "osMain";
@@ -99,7 +102,7 @@ VOID OsSetMainTask()
    for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
        g_mainTask[i].taskStatus = OS_TASK_STATUS_UNUSED;
        g_mainTask[i].taskID = LOSCFG_BASE_CORE_TSK_LIMIT;
-        g_mainTask[i].processID = OS_KERNEL_PROCESS_GROUP;
+        g_mainTask[i].processCB = OS_KERNEL_PROCESS_GROUP;
 #ifdef LOSCFG_KERNEL_SMP_LOCKDEP
        g_mainTask[i].lockDep.lockDepth = 0;
        g_mainTask[i].lockDep.waitLock = NULL;
@@ -110,6 +113,16 @@ VOID OsSetMainTask()
    }
 }

+VOID OsSetMainTaskProcess(UINTPTR processCB)
+{
+    for (UINT32 i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
+        g_mainTask[i].processCB = processCB;
+#ifdef LOSCFG_PID_CONTAINER
+        g_mainTask[i].pidContainer = OS_PID_CONTAINER_FROM_PCB((LosProcessCB *)processCB);
+#endif
+    }
+}
+
 LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
 {
    while (1) {
@@ -168,7 +181,7 @@ LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
    return LOS_EINVAL;
 }

-LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
+LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
 {
    UINT32 index;
    UINT32 size;
@@ -192,9 +205,14 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
    for (index = 0; index < g_taskMaxNum; index++) {
        g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
        g_taskCBArray[index].taskID = index;
+        g_taskCBArray[index].processCB = processCB;
        LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);
    }

+    g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
+    g_taskCBArray[index].taskID = index;
+    g_taskCBArray[index].processCB = processCB;
+
    ret = OsSchedInit();

 EXIT:
@@ -206,10 +224,10 @@ EXIT:

 UINT32 OsGetIdleTaskId(VOID)
 {
-    return OsSchedRunqueueIdleGet();
+    return OsSchedRunqueueIdleGet()->taskID;
 }

-LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
+LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
 {
    UINT32 ret;
    TSK_INIT_PARAM_S taskInitParam;
@@ -221,7 +239,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
    taskInitParam.pcName = "Idle";
    taskInitParam.policy = LOS_SCHED_IDLE;
    taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;
-    taskInitParam.processID = OsGetIdleProcessID();
+    taskInitParam.processID = processID;
 #ifdef LOSCFG_KERNEL_SMP
    taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());
 #endif
@@ -231,7 +249,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
    }
    LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
    idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;
-    OsSchedRunqueueIdleInit(idleTaskID);
+    OsSchedRunqueueIdleInit(idleTask);

    return LOS_TaskResume(idleTaskID);
 }
@@ -250,7 +268,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
    return runTask->taskID;
 }

-STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
+STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
 {
 #ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
    UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);
@@ -310,11 +328,14 @@ STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)

 STATIC INLINE VOID OsInsertTCBToFreeList(LosTaskCB *taskCB)
 {
+#ifdef LOSCFG_PID_CONTAINER
+    OsFreeVtid(taskCB);
+#endif
    UINT32 taskID = taskCB->taskID;
    (VOID)memset_s(taskCB, sizeof(LosTaskCB), 0, sizeof(LosTaskCB));
    taskCB->taskID = taskID;
+    taskCB->processCB = (UINTPTR)OsGetDefaultProcessCB();
    taskCB->taskStatus = OS_TASK_STATUS_UNUSED;
-    taskCB->processID = OS_INVALID_VALUE;
    LOS_ListAdd(&g_losFreeTask, &taskCB->pendList);
 }

@@ -340,12 +361,12 @@ STATIC VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
        taskCB->userArea = 0;
        SCHEDULER_UNLOCK(intSave);

-        LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+        LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
        LOS_ASSERT(!(OsProcessVmSpaceGet(processCB) == NULL));
        UINT32 ret = OsUnMMap(OsProcessVmSpaceGet(processCB), (UINTPTR)mapBase, mapSize);
        if ((ret != LOS_OK) && (mapBase != 0) && !OsProcessIsInit(processCB)) {
            PRINT_ERR("process(%u) unmmap user task(%u) stack failed! mapbase: 0x%x size :0x%x, error: %d\n",
-                      taskCB->processID, taskCB->taskID, mapBase, mapSize, ret);
+                      processCB->processID, taskCB->taskID, mapBase, mapSize, ret);
        }

 #ifdef LOSCFG_KERNEL_LITEIPC
@@ -416,11 +437,9 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
    OsRunningTaskToExit(taskCB, 0);
 }

-LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
-    TSK_INIT_PARAM_S *initParam, VOID **pool)
+STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
    UINT32 poolSize = OS_SYS_MEM_SIZE;
-    *pool = (VOID *)m_aucSysMem1;

    if (taskID == NULL) {
        return LOS_ERRNO_TSK_ID_INVALID;
@@ -430,8 +449,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
        return LOS_ERRNO_TSK_PTR_NULL;
    }

-    LosProcessCB *process = OS_PCB_FROM_PID(initParam->processID);
-    if (!OsProcessIsUserMode(process)) {
+    if (!OsProcessIsUserMode((LosProcessCB *)initParam->processID)) {
        if (initParam->pcName == NULL) {
            return LOS_ERRNO_TSK_NAME_EMPTY;
        }
@@ -461,24 +479,47 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
    return LOS_OK;
 }

-LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID **topStack, UINT32 stackSize, VOID *pool)
+STATIC VOID TaskCBDeInit(LosTaskCB *taskCB)
 {
-    *topStack = (VOID *)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+    UINT32 intSave;
+#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
+    if (taskCB->syncSignal != OS_INVALID_VALUE) {
+        OsTaskSyncDestroy(taskCB->syncSignal);
+        taskCB->syncSignal = OS_INVALID_VALUE;
+    }
+#endif
+
+    if (taskCB->topOfStack != (UINTPTR)NULL) {
+        (VOID)LOS_MemFree(m_aucSysMem1, (VOID *)taskCB->topOfStack);
+        taskCB->topOfStack = (UINTPTR)NULL;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
+    if (processCB != OsGetDefaultProcessCB()) {
+        LOS_ListDelete(&taskCB->threadList);
+        processCB->threadNumber--;
+        processCB->threadCount--;
+    }
+
+    OsInsertTCBToFreeList(taskCB);
+    SCHEDULER_UNLOCK(intSave);
 }

-STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const VOID *stackPtr, const VOID *topStack,
-                           const TSK_INIT_PARAM_S *initParam)
+STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
 {
-    taskCB->stackPointer = (VOID *)stackPtr;
+    taskCB->stackPointer = NULL;
    taskCB->args[0]      = initParam->auwArgs[0]; /* 0~3: just for args array index */
    taskCB->args[1]      = initParam->auwArgs[1];
    taskCB->args[2]      = initParam->auwArgs[2];
    taskCB->args[3]      = initParam->auwArgs[3];
-    taskCB->topOfStack   = (UINTPTR)topStack;
+    taskCB->topOfStack   = (UINTPTR)NULL;
    taskCB->stackSize    = initParam->uwStackSize;
    taskCB->taskEntry    = initParam->pfnTaskEntry;
    taskCB->signal       = SIGNAL_NONE;
-
+#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
+    taskCB->syncSignal   = OS_INVALID_VALUE;
+#endif
 #ifdef LOSCFG_KERNEL_SMP
    taskCB->currCpu      = OS_TASK_INVALID_CPUID;
    taskCB->cpuAffiMask  = (initParam->usCpuAffiMask) ?
@@ -492,29 +533,25 @@ STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const VOID *stackPtr, const VOID *

    LOS_ListInit(&taskCB->lockList);
    SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME);
+#ifdef LOSCFG_KERNEL_VM
+    taskCB->futex.index = OS_INVALID_VALUE;
+#endif
 }

-STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
-                           const VOID *stackPtr, const VOID *topStack)
+STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
 {
    UINT32 ret;
    UINT32 numCount;
    SchedParam schedParam = { 0 };
    UINT16 policy = (initParam->policy == LOS_SCHED_NORMAL) ? LOS_SCHED_RR : initParam->policy;

-    TaskCBBaseInit(taskCB, stackPtr, topStack, initParam);
+    TaskCBBaseInit(taskCB, initParam);

    schedParam.policy = policy;
-    numCount = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam);
-#ifdef LOSCFG_KERNEL_VM
-    taskCB->futex.index = OS_INVALID_VALUE;
-    if (taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) {
-        taskCB->userArea = initParam->userParam.userArea;
-        taskCB->userMapBase = initParam->userParam.userMapBase;
-        taskCB->userMapSize = initParam->userParam.userMapSize;
-        OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP);
+    ret = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam, &numCount);
+    if (ret != LOS_OK) {
+        return ret;
    }
-#endif

    ret = OsSchedParamInit(taskCB, policy, &schedParam, initParam);
    if (ret != LOS_OK) {
@@ -534,7 +571,27 @@ STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
    return LOS_OK;
 }

-LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
+STATIC UINT32 TaskStackInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
+{
+    VOID *topStack = (VOID *)LOS_MemAllocAlign(m_aucSysMem1, initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+    if (topStack == NULL) {
+        return LOS_ERRNO_TSK_NO_MEMORY;
+    }
+
+    taskCB->topOfStack = (UINTPTR)topStack;
+    taskCB->stackPointer = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
+#ifdef LOSCFG_KERNEL_VM
+    if (taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) {
+        taskCB->userArea = initParam->userParam.userArea;
+        taskCB->userMapBase = initParam->userParam.userMapBase;
+        taskCB->userMapSize = initParam->userParam.userMapSize;
+        OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP);
+    }
+#endif
+    return LOS_OK;
+}
+
+STATIC LosTaskCB *GetFreeTaskCB(VOID)
 {
    UINT32 intSave;

@@ -554,37 +611,31 @@ LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)

 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
-    UINT32 intSave, errRet;
-    VOID *topStack = NULL;
-    VOID *pool = NULL;
-
-    errRet = OsTaskCreateParamCheck(taskID, initParam, &pool);
+    UINT32 errRet = TaskCreateParamCheck(taskID, initParam);
    if (errRet != LOS_OK) {
        return errRet;
    }

-    LosTaskCB *taskCB = OsGetFreeTaskCB();
+    LosTaskCB *taskCB = GetFreeTaskCB();
    if (taskCB == NULL) {
-        errRet = LOS_ERRNO_TSK_TCB_UNAVAILABLE;
-        goto LOS_ERREND;
+        return LOS_ERRNO_TSK_TCB_UNAVAILABLE;
    }

-    errRet = OsTaskSyncCreate(taskCB);
+    errRet = TaskCBInit(taskCB, initParam);
    if (errRet != LOS_OK) {
-        goto LOS_ERREND_REWIND_TCB;
+        goto DEINIT_TCB;
    }

-    OsTaskStackAlloc(&topStack, initParam->uwStackSize, pool);
-    if (topStack == NULL) {
-        errRet = LOS_ERRNO_TSK_NO_MEMORY;
-        goto LOS_ERREND_REWIND_SYNC;
-    }
-
-    VOID *stackPtr = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
-    errRet = OsTaskCBInit(taskCB, initParam, stackPtr, topStack);
+    errRet = TaskSyncCreate(taskCB);
    if (errRet != LOS_OK) {
-        goto LOS_ERREND_TCB_INIT;
+        goto DEINIT_TCB;
    }
+
+    errRet = TaskStackInit(taskCB, initParam);
+    if (errRet != LOS_OK) {
+        goto DEINIT_TCB;
+    }
+
    if (OsConsoleIDSetHook != NULL) {
        OsConsoleIDSetHook(taskCB->taskID, OsCurrTaskGet()->taskID);
    }
@@ -593,17 +644,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S
    OsHookCall(LOS_HOOK_TYPE_TASK_CREATE, taskCB);
    return LOS_OK;

-LOS_ERREND_TCB_INIT:
-    (VOID)LOS_MemFree(pool, topStack);
-LOS_ERREND_REWIND_SYNC:
-#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
-    OsTaskSyncDestroy(taskCB->syncSignal);
-#endif
-LOS_ERREND_REWIND_TCB:
-    SCHEDULER_LOCK(intSave);
-    OsInsertTCBToFreeList(taskCB);
-    SCHEDULER_UNLOCK(intSave);
-LOS_ERREND:
+DEINIT_TCB:
+    TaskCBDeInit(taskCB);
    return errRet;
 }

@@ -621,9 +663,9 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
    }

    if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        initParam->processID = OsGetKernelInitProcessID();
+        initParam->processID = (UINTPTR)OsGetKernelInitProcess();
    } else {
-        initParam->processID = OsCurrProcessGet()->processID;
+        initParam->processID = (UINTPTR)OsCurrProcessGet();
    }

    ret = LOS_TaskCreateOnly(taskID, initParam);
@@ -801,7 +843,7 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
 {
    UINT32 intSave;

-    if (OsProcessThreadGroupIDGet(runTask) == runTask->taskID) {
+    if (OsIsProcessThreadGroup(runTask)) {
        OsProcessThreadGroupDestroy();
    }

@@ -812,11 +854,11 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
        SCHEDULER_UNLOCK(intSave);

        OsTaskResourcesToFree(runTask);
-        OsProcessResourcesToFree(OS_PCB_FROM_PID(runTask->processID));
+        OsProcessResourcesToFree(OS_PCB_FROM_TCB(runTask));

        SCHEDULER_LOCK(intSave);

-        OsProcessNaturalExit(OS_PCB_FROM_PID(runTask->processID), status);
+        OsProcessNaturalExit(OS_PCB_FROM_TCB(runTask), status);
        OsTaskReleaseHoldLock(runTask);
        OsTaskStatusUnusedSet(runTask);
    } else if (runTask->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
@@ -881,8 +923,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
    }

    SCHEDULER_LOCK(intSave);
-    if (taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_FLAG_SYSTEM_TASK | OS_TASK_FLAG_NO_DELETE)) {
-        if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
+    if (OsTaskIsNotDelete(taskCB)) {
+        if (OsTaskIsUnused(taskCB)) {
            ret = LOS_ERRNO_TSK_NOT_CREATED;
        } else {
            ret = LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -1252,8 +1294,8 @@ LITE_OS_SEC_TEXT INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL s

    err = LOS_OK;
    /* if thread is main thread, then set processName as taskName */
-    if ((taskCB->taskID == OsProcessThreadGroupIDGet(taskCB)) && (setPName == TRUE)) {
-        err = (INT32)OsSetProcessName(OS_PCB_FROM_PID(taskCB->processID), (const CHAR *)taskCB->taskName);
+    if (OsIsProcessThreadGroup(taskCB) && (setPName == TRUE)) {
+        err = (INT32)OsSetProcessName(OS_PCB_FROM_TCB(taskCB), (const CHAR *)taskCB->taskName);
        if (err != LOS_OK) {
            err = EINVAL;
        }
@@ -1266,16 +1308,16 @@ EXIT:

 INT32 OsUserTaskOperatePermissionsCheck(const LosTaskCB *taskCB)
 {
-    return OsUserProcessOperatePermissionsCheck(taskCB, OsCurrProcessGet()->processID);
+    return OsUserProcessOperatePermissionsCheck(taskCB, (UINTPTR)OsCurrProcessGet());
 }

-INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 processID)
+INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR processCB)
 {
    if (taskCB == NULL) {
        return LOS_EINVAL;
    }

-    if (processID == OS_INVALID_VALUE) {
+    if (processCB == (UINTPTR)OsGetDefaultProcessCB()) {
        return LOS_EINVAL;
    }

@@ -1283,7 +1325,7 @@ INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 proce
        return LOS_EINVAL;
    }

-    if (processID != taskCB->processID) {
+    if (processCB != taskCB->processCB) {
        return LOS_EPERM;
    }

@@ -1318,7 +1360,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID,
    return LOS_OK;
 }

-LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam)
+LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam)
 {
    UINT32 taskID;
    UINT32 ret;
@@ -1335,7 +1377,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S
    if (processID == OS_INVALID_VALUE) {
        SCHEDULER_LOCK(intSave);
        LosProcessCB *processCB = OsCurrProcessGet();
-        initParam->processID = processCB->processID;
+        initParam->processID = (UINTPTR)processCB;
        initParam->consoleID = processCB->consoleID;
        SCHEDULER_UNLOCK(intSave);
    } else {
@@ -1462,7 +1504,7 @@ UINT32 LOS_TaskJoin(UINT32 taskID, UINTPTR *retval)
        return LOS_EINVAL;
    }

-    if (runTask->processID != taskCB->processID) {
+    if (runTask->processCB != taskCB->processCB) {
        SCHEDULER_UNLOCK(intSave);
        return LOS_EPERM;
    }
@@ -1505,7 +1547,7 @@ UINT32 LOS_TaskDetach(UINT32 taskID)
        return LOS_EINVAL;
    }

-    if (runTask->processID != taskCB->processID) {
+    if (runTask->processCB != taskCB->processCB) {
        SCHEDULER_UNLOCK(intSave);
        return LOS_EPERM;
    }
@@ -1525,6 +1567,11 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetSystemTaskMaximum(VOID)
    return g_taskMaxNum;
 }

+LosTaskCB *OsGetDefaultTaskCB(VOID)
+{
+    return &g_taskCBArray[g_taskMaxNum];
+}
+
 LITE_OS_SEC_TEXT VOID OsWriteResourceEvent(UINT32 events)
 {
    (VOID)LOS_EventWrite(&g_resourceEvent, events);
--- a/kernel/base/include/los_container_pri.h
+++ b/kernel/base/include/los_container_pri.h
@@ -0,0 +1,101 @@
+/*
+ * 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_CONTAINER_PRI_H
+#define _LOS_CONTAINER_PRI_H
+
+#include "los_atomic.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#ifdef LOSCFG_PID_CONTAINER
+#include "los_pid_container_pri.h"
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+#include "los_uts_container_pri.h"
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+#include "los_mnt_container_pri.h"
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+#include "los_ipc_container_pri.h"
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+#include "los_time_container_pri.h"
+#endif
+
+typedef enum {
+    CONTAINER = 0,
+    PID_CONTAINER,
+    PID_CHILD_CONTAINER,
+    UTS_CONTAINER,
+    MNT_CONTAINER,
+    IPC_CONTAINER,
+    TIME_CONTAINER,
+    TIME_CHILD_CONTAINER,
+} ContainerType;
+
+typedef struct Container {
+    Atomic   rc;
+#ifdef LOSCFG_PID_CONTAINER
+    struct PidContainer *pidContainer;
+    struct PidContainer *pidForChildContainer;
+#endif
+#ifdef LOSCFG_UTS_CONTAINER
+    struct UtsContainer *utsContainer;
+#endif
+#ifdef LOSCFG_MNT_CONTAINER
+    struct MntContainer *mntContainer;
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+    struct IpcContainer *ipcContainer;
+#endif
+#ifdef LOSCFG_TIME_CONTAINER
+    struct TimeContainer *timeContainer;
+    struct TimeContainer *timeForChildContainer;
+#endif
+} Container;
+
+VOID OsContainerInitSystemProcess(LosProcessCB *processCB);
+
+VOID OsInitRootContainer(VOID);
+
+UINT32 OsCopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID);
+
+VOID OsContainersDestroy(LosProcessCB *processCB);
+
+VOID OsContainerFree(LosProcessCB *processCB);
+
+UINT32 OsAllocContainerID(VOID);
+
+UINT32 OsGetContainerID(Container *container, ContainerType type);
+
+INT32 OsUnshare(UINT32 flags);
+
+#endif
+#endif /* _LOS_CONTAINER_PRI_H */
--- a/kernel/base/include/los_info_pri.h
+++ b/kernel/base/include/los_info_pri.h
@@ -0,0 +1,108 @@
+/*
+ * 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_INFO_PRI_H
+#define _LOS_INFO_PRI_H
+
+#include "los_process_pri.h"
+#include "los_sched_pri.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+    extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+typedef struct TagTaskInfo {
+    UINT32  tid;
+    UINT32  pid;
+    UINT16  status;
+    UINT16  policy;
+    UINT16  priority;
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16  currCpu;
+    UINT16  cpuAffiMask;
+#endif
+    UINT32  stackSize;
+    UINTPTR stackPoint;
+    UINTPTR topOfStack;
+    UINT32  waitFlag;
+    UINT32  waitID;
+    VOID    *taskMux;
+    UINT32  waterLine;
+#ifdef LOSCFG_KERNEL_CPUP
+    UINT32  cpup1sUsage;
+    UINT32  cpup10sUsage;
+    UINT32  cpupAllsUsage;
+#endif
+    CHAR    name[OS_TCB_NAME_LEN];
+} TaskInfo;
+
+typedef struct TagProcessInfo {
+    UINT32 pid;
+    UINT32 ppid;
+    UINT16 status;
+    UINT16 mode;
+    UINT32 pgroupID;
+    UINT32 userID;
+    UINT16 policy;
+    UINT32 basePrio;
+    UINT32 threadGroupID;
+    UINT32 threadNumber;
+#ifdef LOSCFG_KERNEL_VM
+    UINT32 virtualMem;
+    UINT32 shareMem;
+    UINT32 physicalMem;
+#endif
+#ifdef LOSCFG_KERNEL_CPUP
+    UINT32 cpup1sUsage;
+    UINT32 cpup10sUsage;
+    UINT32 cpupAllsUsage;
+#endif
+    CHAR   name[OS_PCB_NAME_LEN];
+} ProcessInfo;
+
+typedef struct TagProcessThreadInfo {
+    ProcessInfo processInfo;
+    UINT32      threadCount;
+    TaskInfo    taskInfo[LOSCFG_BASE_CORE_TSK_LIMIT];
+} ProcessThreadInfo;
+
+UINT32 OsGetAllProcessInfo(ProcessInfo *pcbArray);
+
+UINT32 OsGetProcessThreadInfo(UINT32 pid, ProcessThreadInfo *threadInfo);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif /* _LOS_INFO_PRI_H */
--- a/kernel/base/include/los_ipc_container_pri.h
+++ b/kernel/base/include/los_ipc_container_pri.h
@@ -0,0 +1,94 @@
+/*
+ * 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_IPC_CONTAINER_PRI_H
+#define _LOS_IPC_CONTAINER_PRI_H
+
+#include "los_atomic.h"
+#include "los_list.h"
+#include "mqueue.h"
+#include "fs/file.h"
+
+#ifdef LOSCFG_IPC_CONTAINER
+struct shmIDSource;
+struct Container;
+typedef struct TagQueueCB LosQueueCB;
+typedef struct OsMux LosMux;
+typedef LosMux pthread_mutex_t;
+typedef struct ProcessCB LosProcessCB;
+
+typedef struct IpcContainer {
+    Atomic rc;
+    LosQueueCB *allQueue;
+    LOS_DL_LIST freeQueueList;
+    fd_set queueFdSet;
+    struct mqarray queueTable[LOSCFG_BASE_IPC_QUEUE_LIMIT];
+    pthread_mutex_t mqueueMutex;
+    struct mqpersonal *mqPrivBuf[MAX_MQ_FD];
+    struct shminfo shmInfo;
+    LosMux sysvShmMux;
+    struct shmIDSource *shmSegs;
+    UINT32 shmUsedPageCount;
+    UINT32 containerID;
+} IpcContainer;
+
+UINT32 OsInitRootIpcContainer(IpcContainer **ipcContainer);
+
+UINT32 OsCopyIpcContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent);
+
+UINT32 OsUnshareIpcContainer(UINTPTR flags, LosProcessCB *curr, struct Container *newContainer);
+
+VOID OsIpcContainerDestroy(struct Container *container);
+
+UINT32 OsGetIpcContainerID(IpcContainer *ipcContainer);
+
+IpcContainer *OsGetCurrIpcContainer(VOID);
+
+#define IPC_ALL_QUEUE (OsGetCurrIpcContainer()->allQueue)
+
+#define FREE_QUEUE_LIST (OsGetCurrIpcContainer()->freeQueueList)
+
+#define IPC_QUEUE_FD_SET (OsGetCurrIpcContainer()->queueFdSet)
+
+#define IPC_QUEUE_TABLE (OsGetCurrIpcContainer()->queueTable)
+
+#define IPC_QUEUE_MUTEX (OsGetCurrIpcContainer()->mqueueMutex)
+
+#define IPC_QUEUE_MQ_PRIV_BUF (OsGetCurrIpcContainer()->mqPrivBuf)
+
+#define IPC_SHM_INFO (OsGetCurrIpcContainer()->shmInfo)
+
+#define IPC_SHM_SYS_VSHM_MUTEX (OsGetCurrIpcContainer()->sysvShmMux)
+
+#define IPC_SHM_SEGS (OsGetCurrIpcContainer()->shmSegs)
+
+#define IPC_SHM_USED_PAGE_COUNT (OsGetCurrIpcContainer()->shmUsedPageCount)
+
+#endif
+#endif /* _LOS_IPC_CONTAINER_PRI_H */
--- a/kernel/base/include/los_mnt_container_pri.h
+++ b/kernel/base/include/los_mnt_container_pri.h
@@ -0,0 +1,63 @@
+/*
+ * 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_MNT_CONTAINER_PRI_H
+#define _LOS_MNT_CONTAINER_PRI_H
+
+#include "fs/mount.h"
+#include "sched.h"
+#include "los_atomic.h"
+#include "vnode.h"
+#include "stdlib.h"
+
+#ifdef LOSCFG_MNT_CONTAINER
+typedef struct ProcessCB LosProcessCB;
+struct Container;
+
+typedef struct MntContainer {
+    Atomic rc;
+    UINT32 containerID;
+    LIST_HEAD mountList;
+} MntContainer;
+
+LIST_HEAD *GetContainerMntList(VOID);
+
+UINT32 OsInitRootMntContainer(MntContainer **mntContainer);
+
+UINT32 OsCopyMntContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent);
+
+UINT32 OsUnshareMntContainer(UINTPTR flags, LosProcessCB *curr, struct Container *newContainer);
+
+VOID OsMntContainerDestroy(struct Container *container);
+
+UINT32 OsGetMntContainerID(MntContainer *mntContainer);
+
+#endif
+#endif
--- a/kernel/base/include/los_pid_container_pri.h
+++ b/kernel/base/include/los_pid_container_pri.h
@@ -0,0 +1,102 @@
+/*
+ * 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_PID_CONTAINER_PRI_H
+#define _LOS_PID_CONTAINER_PRI_H
+#include "los_config.h"
+#include "los_atomic.h"
+#include "los_list.h"
+
+typedef struct TagTaskCB LosTaskCB;
+typedef struct ProcessCB LosProcessCB;
+struct ProcessGroup;
+struct Container;
+
+typedef struct {
+    UINT32            vid;  /* Virtual ID */
+    UINT32            vpid; /* Virtual parent ID */
+    UINTPTR           cb;   /* Control block */
+    LOS_DL_LIST       node;
+} ProcessVid;
+
+#define PID_CONTAINER_LEVEL_LIMIT 3
+
+typedef struct PidContainer {
+    Atomic              rc;
+    Atomic              level;
+    Atomic              lock;
+    BOOL                referenced;
+    UINT32              containerID;
+    struct PidContainer *parent;
+    struct ProcessGroup *rootPGroup;
+    LOS_DL_LIST         tidFreeList;
+    ProcessVid          tidArray[LOSCFG_BASE_CORE_TSK_LIMIT];
+    LOS_DL_LIST         pidFreeList;
+    ProcessVid          pidArray[LOSCFG_BASE_CORE_PROCESS_LIMIT];
+} PidContainer;
+
+#define OS_PID_CONTAINER_FROM_PCB(processCB) ((processCB)->container->pidContainer)
+
+#define OS_ROOT_PGRP(processCB) (OS_PID_CONTAINER_FROM_PCB(processCB)->rootPGroup)
+
+#define OS_PROCESS_CONTAINER_CHECK(processCB, currProcessCB) \
+    ((processCB)->container->pidContainer != (currProcessCB)->container->pidContainer)
+
+UINT32 OsAllocSpecifiedVpidUnsafe(UINT32 vpid, LosProcessCB *processCB, LosProcessCB *parent);
+
+VOID OsPidContainerDestroyAllProcess(LosProcessCB *processCB);
+
+VOID OsPidContainerDestroy(LosProcessCB *curr);
+
+UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID);
+
+UINT32 OsUnsharePidContainer(UINTPTR flags, LosProcessCB *curr, struct Container *newContainer);
+
+VOID UnshareDeInitPidContainer(struct Container *container);
+
+UINT32 OsInitRootPidContainer(PidContainer **pidContainer);
+
+LosProcessCB *OsGetPCBFromVpid(UINT32 vpid);
+
+LosTaskCB *OsGetTCBFromVtid(UINT32 vtid);
+
+UINT32 OsGetVpidFromCurrContainer(const LosProcessCB *processCB);
+
+UINT32 OsGetVpidFromRootContainer(const LosProcessCB *processCB);
+
+UINT32 OsGetVtidFromCurrContainer(const LosTaskCB *taskCB);
+
+VOID OsFreeVtid(LosTaskCB *taskCB);
+
+UINT32 OsAllocVtid(LosTaskCB *taskCB, const LosProcessCB *processCB);
+
+UINT32 OsGetPidContainerID(PidContainer *pidContainer);
+
+#endif /* _LOS_PID_CONTAINER_PRI_H */
--- a/kernel/base/include/los_process_pri.h
+++ b/kernel/base/include/los_process_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -33,6 +33,7 @@
 #define _LOS_PROCESS_PRI_H

 #include "los_task_pri.h"
+#include "sched.h"
 #include "los_sem_pri.h"
 #include "los_process.h"
 #include "los_vm_map.h"
@@ -46,6 +47,9 @@
 #include "vid_type.h"
 #endif
 #include "sys/resource.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif

 #ifdef __cplusplus
 #if __cplusplus
@@ -68,11 +72,11 @@ typedef struct {
 } User;
 #endif

-typedef struct {
-    UINT32      groupID;         /**< Process group ID is the PID of the process that created the group */
-    LOS_DL_LIST processList;     /**< List of processes under this process group */
-    LOS_DL_LIST exitProcessList; /**< List of closed processes (zombie processes) under this group */
-    LOS_DL_LIST groupList;       /**< Process group list */
+typedef struct ProcessGroup {
+    UINTPTR      pgroupLeader;    /**< Process group leader is the the process that created the group */
+    LOS_DL_LIST  processList;     /**< List of processes under this process group */
+    LOS_DL_LIST  exitProcessList; /**< List of closed processes (zombie processes) under this group */
+    LOS_DL_LIST  groupList;       /**< Process group list */
 } ProcessGroup;

 typedef struct ProcessCB {
@@ -82,15 +86,15 @@ typedef struct ProcessCB {
                                                            running in the process */
    UINT16               consoleID;                    /**< The console id of task belongs  */
    UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */
-    UINT32               parentProcessID;              /**< Parent process ID */
+    struct ProcessCB     *parentProcess;               /**< Parent process */
    UINT32               exitCode;                     /**< Process exit status */
    LOS_DL_LIST          pendList;                     /**< Block list to which the process belongs */
    LOS_DL_LIST          childrenList;                 /**< Children process list */
    LOS_DL_LIST          exitChildList;                /**< Exit children process list */
    LOS_DL_LIST          siblingList;                  /**< Linkage in parent's children list */
-    ProcessGroup         *group;                       /**< Process group to which a process belongs */
+    ProcessGroup         *pgroup;                      /**< Process group to which a process belongs */
    LOS_DL_LIST          subordinateGroupList;         /**< Linkage in group list */
-    UINT32               threadGroupID;                /**< Which thread group , is the main thread ID of the process */
+    LosTaskCB            *threadGroup;
    LOS_DL_LIST          threadSiblingList;            /**< List of threads under this process */
    volatile UINT32      threadNumber; /**< Number of threads alive under this process */
    UINT32               threadCount;  /**< Total number of threads created under this process */
@@ -126,20 +130,28 @@ typedef struct ProcessCB {
    OsCpupBase           *processCpup; /**< Process cpu usage */
 #endif
    struct rlimit        *resourceLimit;
+#ifdef LOSCFG_KERNEL_CONTAINER
+    Container            *container;
+#endif
+#ifdef LOSCFG_PROC_PROCESS_DIR
+    struct ProcDirEntry *procDir;
+#endif
 } LosProcessCB;

-#define CLONE_VM       0x00000100
-#define CLONE_FS       0x00000200
-#define CLONE_FILES    0x00000400
-#define CLONE_SIGHAND  0x00000800
-#define CLONE_PTRACE   0x00002000
-#define CLONE_VFORK    0x00004000
-#define CLONE_PARENT   0x00008000
-#define CLONE_THREAD   0x00010000
+extern LosProcessCB *g_processCBArray;
+extern UINT32 g_processMaxNum;

-#define OS_PCB_FROM_PID(processID) (((LosProcessCB *)g_processCBArray) + (processID))
-#define OS_PCB_FROM_SIBLIST(ptr)   LOS_DL_LIST_ENTRY((ptr), LosProcessCB, siblingList)
-#define OS_PCB_FROM_PENDLIST(ptr)  LOS_DL_LIST_ENTRY((ptr), LosProcessCB, pendList)
+#define OS_PCB_FROM_RPID(processID)     (((LosProcessCB *)g_processCBArray) + (processID))
+#ifdef LOSCFG_PID_CONTAINER
+#define OS_PCB_FROM_PID(processID)      OsGetPCBFromVpid(processID)
+#else
+#define OS_PCB_FROM_PID(processID)      OS_PCB_FROM_RPID(processID)
+#endif
+#define OS_PCB_FROM_TCB(taskCB)         ((LosProcessCB *)((taskCB)->processCB))
+#define OS_PCB_FROM_TID(taskID)         ((LosProcessCB *)(OS_TCB_FROM_TID(taskID)->processCB))
+#define OS_GET_PGROUP_LEADER(pgroup)    ((LosProcessCB *)((pgroup)->pgroupLeader))
+#define OS_PCB_FROM_SIBLIST(ptr)        LOS_DL_LIST_ENTRY((ptr), LosProcessCB, siblingList)
+#define OS_PCB_FROM_PENDLIST(ptr)       LOS_DL_LIST_ENTRY((ptr), LosProcessCB, pendList)

 /**
 * @ingroup los_process
@@ -246,12 +258,17 @@ STATIC INLINE BOOL OsProcessIsInactive(const LosProcessCB *processCB)
 */
 STATIC INLINE BOOL OsProcessIsDead(const LosProcessCB *processCB)
 {
-    return ((processCB->processStatus & (OS_PROCESS_FLAG_UNUSED | OS_PROCESS_STATUS_ZOMBIES)) != 0);
+    return ((processCB->processStatus & OS_PROCESS_STATUS_ZOMBIES) != 0);
 }

 STATIC INLINE BOOL OsProcessIsInit(const LosProcessCB *processCB)
 {
-    return (processCB->processStatus & OS_PROCESS_STATUS_INIT);
+    return ((processCB->processStatus & OS_PROCESS_STATUS_INIT) != 0);
+}
+
+STATIC INLINE BOOL OsProcessIsPGroupLeader(const LosProcessCB *processCB)
+{
+    return ((processCB->processStatus & OS_PROCESS_FLAG_GROUP_LEADER) != 0);
 }

 /**
@@ -284,6 +301,24 @@ STATIC INLINE BOOL OsProcessIsInit(const LosProcessCB *processCB)
 */
 #define OS_PROCESS_USERINIT_PRIORITY     28

+/**
+ * @ingroup los_process
+ * ID of the kernel idle process
+ */
+#define OS_KERNEL_IDLE_PROCESS_ID       0U
+
+/**
+ * @ingroup los_process
+ * ID of the user root process
+ */
+#define OS_USER_ROOT_PROCESS_ID         1U
+
+/**
+ * @ingroup los_process
+ * ID of the kernel root process
+ */
+#define OS_KERNEL_ROOT_PROCESS_ID       2U
+
 #define OS_TASK_DEFAULT_STACK_SIZE      0x2000
 #define OS_USER_TASK_SYSCALL_STACK_SIZE 0x3000
 #define OS_USER_TASK_STACK_SIZE         0x100000
@@ -299,8 +334,8 @@ STATIC INLINE BOOL OsProcessIsUserMode(const LosProcessCB *processCB)
 #define LOS_PRIO_PGRP     1U
 #define LOS_PRIO_USER     2U

-#define OS_USER_PRIVILEGE_PROCESS_GROUP 1U
-#define OS_KERNEL_PROCESS_GROUP         2U
+#define OS_USER_PRIVILEGE_PROCESS_GROUP ((UINTPTR)OsGetUserInitProcess())
+#define OS_KERNEL_PROCESS_GROUP         ((UINTPTR)OsGetKernelInitProcess())

 /*
 * Process exit code
@@ -334,9 +369,6 @@ STATIC INLINE VOID OsProcessExitCodeSet(LosProcessCB *processCB, UINT32 code)
    processCB->exitCode |= ((code & 0x000000FFU) << 8U) & 0x0000FF00U; /* 8: Move 8 bits to the left, exitCode */
 }

-extern LosProcessCB *g_processCBArray;
-extern UINT32 g_processMaxNum;
-
 #define OS_PID_CHECK_INVALID(pid) (((UINT32)(pid)) >= g_processMaxNum)

 STATIC INLINE BOOL OsProcessIDUserCheckInvalid(UINT32 pid)
@@ -349,7 +381,7 @@ STATIC INLINE LosProcessCB *OsCurrProcessGet(VOID)
    UINT32 intSave;

    intSave = LOS_IntLock();
-    LosProcessCB *runProcess = OS_PCB_FROM_PID(OsCurrTaskGet()->processID);
+    LosProcessCB *runProcess = OS_PCB_FROM_TCB(OsCurrTaskGet());
    LOS_IntRestore(intSave);
    return runProcess;
 }
@@ -371,7 +403,7 @@ STATIC INLINE UINT32 OsProcessUserIDGet(const LosTaskCB *taskCB)
    UINT32 intSave = LOS_IntLock();
    UINT32 uid = OS_INVALID;

-    LosProcessCB *process = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *process = OS_PCB_FROM_TCB(taskCB);
    if (process->user != NULL) {
        uid = process->user->userID;
    }
@@ -380,14 +412,14 @@ STATIC INLINE UINT32 OsProcessUserIDGet(const LosTaskCB *taskCB)
 }
 #endif

-STATIC INLINE UINT32 OsProcessThreadGroupIDGet(const LosTaskCB *taskCB)
+STATIC INLINE BOOL OsIsProcessThreadGroup(const LosTaskCB *taskCB)
 {
-    return OS_PCB_FROM_PID(taskCB->processID)->threadGroupID;
+    return (OS_PCB_FROM_TCB(taskCB)->threadGroup == taskCB);
 }

 STATIC INLINE UINT32 OsProcessThreadNumberGet(const LosTaskCB *taskCB)
 {
-    return OS_PCB_FROM_PID(taskCB->processID)->threadNumber;
+    return OS_PCB_FROM_TCB(taskCB)->threadNumber;
 }

 #ifdef LOSCFG_KERNEL_VM
@@ -403,6 +435,26 @@ STATIC INLINE struct Vnode *OsProcessExecVnodeGet(const LosProcessCB *processCB)
    return processCB->execVnode;
 }
 #endif
+
+STATIC INLINE UINT32 OsGetPid(const LosProcessCB *processCB)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    if (OS_PROCESS_CONTAINER_CHECK(processCB, OsCurrProcessGet())) {
+        return OsGetVpidFromCurrContainer(processCB);
+    }
+#endif
+    return processCB->processID;
+}
+
+STATIC INLINE UINT32 OsGetRootPid(const LosProcessCB *processCB)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    return OsGetVpidFromRootContainer(processCB);
+#else
+    return processCB->processID;
+#endif
+}
+
 /*
 * return immediately if no child has exited.
 */
@@ -460,6 +512,7 @@ extern UINTPTR __user_init_entry;
 extern UINTPTR __user_init_bss;
 extern UINTPTR __user_init_end;
 extern UINTPTR __user_init_load_addr;
+extern UINT32 OsProcessInit(VOID);
 extern UINT32 OsSystemProcessCreate(VOID);
 extern VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status);
 extern VOID OsProcessCBRecycleToFree(VOID);
@@ -473,20 +526,21 @@ extern UINT32 OsExecStart(const TSK_ENTRY_FUNC entry, UINTPTR sp, UINTPTR mapBas
 extern UINT32 OsSetProcessName(LosProcessCB *processCB, const CHAR *name);
 extern INT32 OsSetProcessScheduler(INT32 which, INT32 pid, UINT16 prio, UINT16 policy);
 extern INT32 OsGetProcessPriority(INT32 which, INT32 pid);
-extern UINT32 OsGetUserInitProcessID(VOID);
-extern UINT32 OsGetIdleProcessID(VOID);
+extern LosProcessCB *OsGetUserInitProcess(VOID);
+extern LosProcessCB *OsGetIdleProcess(VOID);
 extern INT32 OsSetProcessGroupID(UINT32 pid, UINT32 gid);
 extern INT32 OsSetCurrProcessGroupID(UINT32 gid);
-extern UINT32 OsGetKernelInitProcessID(VOID);
+extern LosProcessCB *OsGetKernelInitProcess(VOID);
 extern VOID OsSetSigHandler(UINTPTR addr);
 extern UINTPTR OsGetSigHandler(VOID);
 extern VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID);
 extern INT32 OsSendSignalToProcessGroup(INT32 pid, siginfo_t *info, INT32 permission);
 extern INT32 OsSendSignalToAllProcess(siginfo_t *info, INT32 permission);
-extern UINT32 OsProcessAddNewTask(UINT32 pid, LosTaskCB *taskCB, SchedParam *param);
+extern UINT32 OsProcessAddNewTask(UINTPTR processID, LosTaskCB *taskCB, SchedParam *param, UINT32 *numCount);
 extern VOID OsDeleteTaskFromProcess(LosTaskCB *taskCB);
 extern VOID OsProcessThreadGroupDestroy(VOID);
-
+extern UINT32 OsGetProcessGroupCB(UINT32 pid, UINTPTR *ppgroupLeader);
+extern LosProcessCB *OsGetDefaultProcessCB(VOID);
 #ifdef __cplusplus
 #if __cplusplus
 }
--- a/kernel/base/include/los_queue_pri.h
+++ b/kernel/base/include/los_queue_pri.h
@@ -65,7 +65,7 @@ typedef enum {
 * @ingroup los_queue
 * Queue information block structure
 */
-typedef struct {
+typedef struct TagQueueCB {
    UINT8 *queueHandle; /**< Pointer to a queue handle */
    UINT16 queueState; /**< Queue state */
    UINT16 queueLen; /**< Queue length */
@@ -108,6 +108,9 @@ typedef struct {
 *  Queue information control block
 */
 extern LosQueueCB *g_allQueue;
+#ifndef LOSCFG_IPC_CONTAINER
+#define IPC_ALL_QUEUE g_allQueue
+#endif

 /**
 * @ingroup los_queue
@@ -137,7 +140,7 @@ extern LosQueueCB *g_allQueue;
 * Obtain a handle of the queue that has a specified ID.
 *
 */
-#define GET_QUEUE_HANDLE(queueID)       (((LosQueueCB *)g_allQueue) + GET_QUEUE_INDEX(queueID))
+#define GET_QUEUE_HANDLE(queueID)       (((LosQueueCB *)IPC_ALL_QUEUE) + GET_QUEUE_INDEX(queueID))

 /**
 * @ingroup los_queue
@@ -196,6 +199,8 @@ extern VOID *OsQueueMailAlloc(UINT32 queueID, VOID *mailPool, UINT32 timeout);
 */
 extern UINT32 OsQueueMailFree(UINT32 queueID, VOID *mailPool, VOID *mailMem);

+extern LosQueueCB *OsAllQueueCBInit(LOS_DL_LIST *freeQueueList);
+
 extern UINT32 OsQueueInit(VOID);

 #ifdef __cplusplus
--- a/kernel/base/include/los_sched_pri.h
+++ b/kernel/base/include/los_sched_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -52,6 +52,9 @@
 #include "hm_liteipc.h"
 #endif
 #include "los_mp.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif

 #ifdef __cplusplus
 #if __cplusplus
@@ -100,7 +103,7 @@ typedef struct {
    HPFRunqueue       *hpfRunqueue;
    UINT64            responseTime; /* Response time for current CPU tick interrupts */
    UINT32            responseID;   /* The response ID of the current CPU tick interrupt */
-    UINT32            idleTaskID;   /* idle task id */
+    LosTaskCB         *idleTask;   /* idle task id */
    UINT32            taskLockCnt;  /* task lock flag */
    UINT32            schedFlag;    /* pending scheduler flag */
 } SchedRunqueue;
@@ -199,9 +202,9 @@ STATIC INLINE BOOL OsPreemptableInSched(VOID)
    return preemptible;
 }

-STATIC INLINE UINT32 OsSchedRunqueueIdleGet(VOID)
+STATIC INLINE LosTaskCB *OsSchedRunqueueIdleGet(VOID)
 {
-    return OsSchedRunqueue()->idleTaskID;
+    return OsSchedRunqueue()->idleTask;
 }

 STATIC INLINE VOID OsSchedRunqueuePendingSet(VOID)
@@ -409,7 +412,7 @@ typedef struct TagTaskCB {
    UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
    FutexNode       futex;
 #endif
-    UINT32          processID;          /**< Which belong process */
+    UINTPTR         processCB;          /**< Which belong process */
    LOS_DL_LIST     joinList;           /**< join list */
    LOS_DL_LIST     lockList;           /**< Hold the lock list */
    UINTPTR         waitID;             /**< Wait for the PID or GID of the child process */
@@ -422,6 +425,12 @@ typedef struct TagTaskCB {
    UINTPTR         pc;
    UINTPTR         fp;
 #endif
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer    *pidContainer;
+#endif
+#ifdef LOSCFG_IPC_CONTAINER
+   BOOL             cloneIpc;
+#endif
 } LosTaskCB;

 STATIC INLINE BOOL OsTaskIsRunning(const LosTaskCB *taskCB)
@@ -660,7 +669,7 @@ VOID OsSchedTick(VOID);
 UINT32 OsSchedInit(VOID);
 VOID OsSchedStart(VOID);

-VOID OsSchedRunqueueIdleInit(UINT32 idleTaskID);
+VOID OsSchedRunqueueIdleInit(LosTaskCB *idleTask);
 VOID OsSchedRunqueueInit(VOID);

 /*
--- a/kernel/base/include/los_signal.h
+++ b/kernel/base/include/los_signal.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -151,6 +151,8 @@ typedef struct {
    unsigned int count;
 } sig_cb;

+typedef struct ProcessCB LosProcessCB;
+
 #define SIGEV_THREAD_ID 4

 int sys_sigqueue(pid_t, int, const union sigval);
@@ -165,6 +167,7 @@ int OsSigEmptySet(sigset_t *);
 int OsSigAddSet(sigset_t *, int);
 int OsSigIsMember(const sigset_t *, int);
 int OsKill(pid_t pid, int sig, int permission);
+int OsSendSigToProcess(LosProcessCB *spcb, int sig, int permission);
 int OsDispatch(pid_t pid, siginfo_t *info, int permission);
 int OsSigTimedWait(sigset_t *set, siginfo_t *info, unsigned int timeout);
 int OsPause(void);
--- a/kernel/base/include/los_swtmr_pri.h
+++ b/kernel/base/include/los_swtmr_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -108,7 +108,7 @@ extern UINT32 OsSwtmrGetNextTimeout(VOID);
 extern BOOL OsIsSwtmrTask(const LosTaskCB *taskCB);
 extern VOID OsSwtmrResponseTimeReset(UINT64 startTime);
 extern UINT32 OsSwtmrInit(VOID);
-extern VOID OsSwtmrRecycle(UINT32 processID);
+extern VOID OsSwtmrRecycle(UINTPTR ownerID);
 extern BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 extern SPIN_LOCK_S g_swtmrSpin;
 extern UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid);
--- a/kernel/base/include/los_task_pri.h
+++ b/kernel/base/include/los_task_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -192,7 +192,12 @@ extern SPIN_LOCK_S g_taskSpin;
 * <ul><li>los_task_pri.h: the header file that contains the API declaration.</li></ul>
 * @see
 */
-#define OS_TCB_FROM_TID(taskID) (((LosTaskCB *)g_taskCBArray) + (taskID))
+#define OS_TCB_FROM_RTID(taskID) (((LosTaskCB *)g_taskCBArray) + (taskID))
+#ifdef LOSCFG_PID_CONTAINER
+#define OS_TCB_FROM_TID(taskID) OsGetTCBFromVtid(taskID)
+#else
+#define OS_TCB_FROM_TID(taskID) OS_TCB_FROM_RTID(taskID)
+#endif

 #ifndef LOSCFG_STACK_POINT_ALIGN_SIZE
 #define LOSCFG_STACK_POINT_ALIGN_SIZE                       (sizeof(UINTPTR) * 2)
@@ -255,7 +260,12 @@ STATIC INLINE BOOL OsTaskIsUnused(const LosTaskCB *taskCB)

 STATIC INLINE BOOL OsTaskIsKilled(const LosTaskCB *taskCB)
 {
-    return ((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
+    return((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsNotDelete(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_FLAG_SYSTEM_TASK | OS_TASK_FLAG_NO_DELETE)) != 0);
 }

 STATIC INLINE BOOL OsTaskIsUserMode(const LosTaskCB *taskCB)
@@ -302,8 +312,8 @@ extern BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16
 extern VOID OsTaskSchedule(LosTaskCB *, LosTaskCB *);
 extern VOID OsTaskContextLoad(LosTaskCB *newTask);
 extern VOID OsIdleTask(VOID);
-extern UINT32 OsIdleTaskCreate(VOID);
-extern UINT32 OsTaskInit(VOID);
+extern UINT32 OsIdleTaskCreate(UINTPTR processID);
+extern UINT32 OsTaskInit(UINTPTR processCB);
 extern UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv);
 extern UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqfile, UINT16 flag);
 extern LosTaskCB *OsGetMainTask(VOID);
@@ -311,18 +321,20 @@ extern VOID OsSetMainTask(VOID);
 extern UINT32 OsGetIdleTaskId(VOID);
 extern VOID OsTaskEntry(UINT32 taskID);
 extern VOID OsTaskProcSignal(VOID);
-extern UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam);
+extern UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam);
 extern INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL setPName);
 extern VOID OsTaskCBRecycleToFree(VOID);
 extern VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status);
 extern INT32 OsUserTaskOperatePermissionsCheck(const LosTaskCB *taskCB);
-extern INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 processID);
+extern INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR processCB);
 extern INT32 OsTcbDispatch(LosTaskCB *stcb, siginfo_t *info);
 extern VOID OsWriteResourceEvent(UINT32 events);
 extern VOID OsWriteResourceEventUnsafe(UINT32 events);
 extern UINT32 OsResourceFreeTaskCreate(VOID);
 extern VOID OsTaskInsertToRecycleList(LosTaskCB *taskCB);
 extern VOID OsInactiveTaskDelete(LosTaskCB *taskCB);
+extern VOID OsSetMainTaskProcess(UINTPTR processCB);
+extern LosTaskCB *OsGetDefaultTaskCB(VOID);

 #ifdef __cplusplus
 #if __cplusplus
--- a/kernel/base/include/los_time_container_pri.h
+++ b/kernel/base/include/los_time_container_pri.h
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+#ifndef _LOS_TIME_CONTAINER_PRI_H
+#define _LOS_TIME_CONTAINER_PRI_H
+#include "time.h"
+#include "los_atomic.h"
+
+#ifdef LOSCFG_TIME_CONTAINER
+typedef struct ProcessCB LosProcessCB;
+struct Container;
+
+typedef struct TimeContainer {
+    Atomic            rc;
+    BOOL              frozenOffsets;
+    struct timespec64 monotonic;
+    UINT32            containerID;
+} TimeContainer;
+
+UINT32 OsInitRootTimeContainer(TimeContainer **timeContainer);
+
+UINT32 OsCopyTimeContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent);
+
+UINT32 OsUnshareTimeContainer(UINTPTR flags, LosProcessCB *curr, struct Container *newContainer);
+
+VOID UnshareDeInitTimeContainer(struct Container *container);
+
+VOID OsTimeContainerDestroy(LosProcessCB *curr);
+
+UINT32 OsGetTimeContainerID(TimeContainer *timeContainer);
+
+TimeContainer *OsGetCurrTimeContainer(VOID);
+
+UINT32 OsGetTimeContainerMonotonic(LosProcessCB *processCB, struct timespec64 *offsets);
+
+UINT32 OsSetTimeContainerMonotonic(LosProcessCB *processCB, struct timespec64 *offsets);
+
+#define CLOCK_MONOTONIC_TIME_BASE (OsGetCurrTimeContainer()->monotonic)
+
+#endif
+#endif /* _LOS_TIME_CONTAINER_PRI_H */
--- a/kernel/base/include/los_uts_container_pri.h
+++ b/kernel/base/include/los_uts_container_pri.h
@@ -0,0 +1,61 @@
+/*
+ * 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;
+struct Container;
+
+typedef struct UtsContainer {
+    Atomic  rc;
+    UINT32  containerID;
+    struct  utsname utsName;
+} UtsContainer;
+
+UINT32 OsInitRootUtsContainer(UtsContainer **utsContainer);
+
+UINT32 OsCopyUtsContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent);
+
+UINT32 OsUnshareUtsContainer(UINTPTR flags, LosProcessCB *curr, struct Container *newContainer);
+
+VOID OsUtsContainerDestroy(struct Container *container);
+
+struct utsname *OsGetCurrUtsName(VOID);
+
+UINT32 OsGetUtsContainerID(UtsContainer *utsContainer);
+#endif
+#endif /* _LOS_UTS_CONTAINER_PRI_H */
--- a/kernel/base/include/los_vm_map.h
+++ b/kernel/base/include/los_vm_map.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -290,7 +290,7 @@ STATUS_T LOS_VmSpaceFree(LosVmSpace *space);
 STATUS_T LOS_VaddrToPaddrMmap(LosVmSpace *space, VADDR_T vaddr, PADDR_T paddr, size_t len, UINT32 flags);
 BOOL OsUserVmSpaceInit(LosVmSpace *vmSpace, VADDR_T *virtTtb);
 LosVmSpace *OsCreateUserVmSpace(VOID);
-STATUS_T LOS_VmSpaceClone(LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace);
+STATUS_T LOS_VmSpaceClone(UINT32 cloneFlags, LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace);
 LosMux *OsGVmSpaceMuxGet(VOID);
 STATUS_T OsUnMMap(LosVmSpace *space, VADDR_T addr, size_t size);
 STATUS_T OsVmSpaceRegionFree(LosVmSpace *space);
--- a/kernel/base/include/los_vm_shm_pri.h
+++ b/kernel/base/include/los_vm_shm_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -34,17 +34,35 @@

 #include "los_typedef.h"
 #include "los_vm_map.h"
-
+#include "los_process_pri.h"
+
 #ifdef __cplusplus
 #if __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */

+/* The upper limit size of total shared memory is default 16M */
+#define SHM_MAX_PAGES 4096
+#define SHM_MAX (SHM_MAX_PAGES * PAGE_SIZE)
+#define SHM_MIN 1
+#define SHM_MNI 192
+#define SHM_SEG 128
+#define SHM_ALL (SHM_MAX_PAGES)
+
+struct shmIDSource {
+    struct shmid_ds ds;
+    UINT32 status;
+    LOS_DL_LIST node;
+#ifdef LOSCFG_SHELL
+    CHAR ownerName[OS_PCB_NAME_LEN];
+#endif
+};
+
 VOID OsShmFork(LosVmSpace *space, LosVmMapRegion *oldRegion, LosVmMapRegion *newRegion);
 VOID OsShmRegionFree(LosVmSpace *space, LosVmMapRegion *region);
 BOOL OsIsShmRegion(LosVmMapRegion *region);
-
+struct shmIDSource *OsShmCBInit(LosMux *sysvShmMux, struct shminfo *shmInfo, UINT32 *shmUsedPageCount);
 #ifdef __cplusplus
 #if __cplusplus
 }
--- a/kernel/base/ipc/los_queue.c
+++ b/kernel/base/ipc/los_queue.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -37,14 +37,51 @@
 #include "los_mp.h"
 #include "los_percpu_pri.h"
 #include "los_hook.h"
+#ifdef LOSCFG_IPC_CONTAINER
+#include "los_ipc_container_pri.h"
+#endif

 #ifdef LOSCFG_BASE_IPC_QUEUE
 #if (LOSCFG_BASE_IPC_QUEUE_LIMIT <= 0)
 #error "queue maxnum cannot be zero"
 #endif /* LOSCFG_BASE_IPC_QUEUE_LIMIT <= 0 */

+#ifndef LOSCFG_IPC_CONTAINER
 LITE_OS_SEC_BSS LosQueueCB *g_allQueue = NULL;
 LITE_OS_SEC_BSS STATIC LOS_DL_LIST g_freeQueueList;
+#define FREE_QUEUE_LIST g_freeQueueList
+#endif
+
+LITE_OS_SEC_TEXT_INIT LosQueueCB *OsAllQueueCBInit(LOS_DL_LIST *freeQueueList)
+{
+    UINT32 index;
+
+    if (freeQueueList == NULL) {
+        return NULL;
+    }
+
+    UINT32 size = LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(LosQueueCB);
+    /* system resident memory, don't free */
+    LosQueueCB *allQueue = (LosQueueCB *)LOS_MemAlloc(m_aucSysMem0, size);
+    if (allQueue == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(allQueue, size, 0, size);
+    LOS_ListInit(freeQueueList);
+    for (index = 0; index < LOSCFG_BASE_IPC_QUEUE_LIMIT; index++) {
+        LosQueueCB *queueNode = ((LosQueueCB *)allQueue) + index;
+        queueNode->queueID = index;
+        LOS_ListTailInsert(freeQueueList, &queueNode->readWriteList[OS_QUEUE_WRITE]);
+    }
+
+#ifndef LOSCFG_IPC_CONTAINER
+    if (OsQueueDbgInitHook() != LOS_OK) {
+        (VOID)LOS_MemFree(m_aucSysMem0, allQueue);
+        return NULL;
+    }
+#endif
+    return allQueue;
+}

 /*
 * Description : queue initial
@@ -52,27 +89,12 @@ LITE_OS_SEC_BSS STATIC LOS_DL_LIST g_freeQueueList;
 */
 LITE_OS_SEC_TEXT_INIT UINT32 OsQueueInit(VOID)
 {
-    LosQueueCB *queueNode = NULL;
-    UINT32 index;
-    UINT32 size;
-
-    size = LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(LosQueueCB);
-    /* system resident memory, don't free */
-    g_allQueue = (LosQueueCB *)LOS_MemAlloc(m_aucSysMem0, size);
+#ifndef LOSCFG_IPC_CONTAINER
+    g_allQueue = OsAllQueueCBInit(&g_freeQueueList);
    if (g_allQueue == NULL) {
        return LOS_ERRNO_QUEUE_NO_MEMORY;
    }
-    (VOID)memset_s(g_allQueue, size, 0, size);
-    LOS_ListInit(&g_freeQueueList);
-    for (index = 0; index < LOSCFG_BASE_IPC_QUEUE_LIMIT; index++) {
-        queueNode = ((LosQueueCB *)g_allQueue) + index;
-        queueNode->queueID = index;
-        LOS_ListTailInsert(&g_freeQueueList, &queueNode->readWriteList[OS_QUEUE_WRITE]);
-    }
-
-    if (OsQueueDbgInitHook() != LOS_OK) {
-        return LOS_ERRNO_QUEUE_NO_MEMORY;
-    }
+#endif
    return LOS_OK;
 }

@@ -111,14 +133,14 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreate(CHAR *queueName, UINT16 len, UINT32
    }

    SCHEDULER_LOCK(intSave);
-    if (LOS_ListEmpty(&g_freeQueueList)) {
+    if (LOS_ListEmpty(&FREE_QUEUE_LIST)) {
        SCHEDULER_UNLOCK(intSave);
        OsQueueCheckHook();
        (VOID)LOS_MemFree(m_aucSysMem1, queue);
        return LOS_ERRNO_QUEUE_CB_UNAVAILABLE;
    }

-    unusedQueue = LOS_DL_LIST_FIRST(&g_freeQueueList);
+    unusedQueue = LOS_DL_LIST_FIRST(&FREE_QUEUE_LIST);
    LOS_ListDelete(unusedQueue);
    queueCB = GET_QUEUE_LIST(unusedQueue);
    queueCB->queueLen = len;
@@ -433,7 +455,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueDelete(UINT32 queueID)
    queueCB->queueID = SET_QUEUE_ID(GET_QUEUE_COUNT(queueCB->queueID) + 1, GET_QUEUE_INDEX(queueCB->queueID));
    OsQueueDbgUpdateHook(queueCB->queueID, NULL);

-    LOS_ListTailInsert(&g_freeQueueList, &queueCB->readWriteList[OS_QUEUE_WRITE]);
+    LOS_ListTailInsert(&FREE_QUEUE_LIST, &queueCB->readWriteList[OS_QUEUE_WRITE]);
    SCHEDULER_UNLOCK(intSave);
    OsHookCall(LOS_HOOK_TYPE_QUEUE_DELETE, queueCB);
    ret = LOS_MemFree(m_aucSysMem1, (VOID *)queue);
--- a/kernel/base/ipc/los_signal.c
+++ b/kernel/base/ipc/los_signal.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -135,7 +135,7 @@ STATIC INLINE VOID OsSigWaitTaskWake(LosTaskCB *taskCB, INT32 signo)

 STATIC UINT32 OsPendingTaskWake(LosTaskCB *taskCB, INT32 signo)
 {
-    if (!OsTaskIsPending(taskCB) || !OsProcessIsUserMode(OS_PCB_FROM_PID(taskCB->processID))) {
+    if (!OsTaskIsPending(taskCB) || !OsProcessIsUserMode(OS_PCB_FROM_TCB(taskCB))) {
        return 0;
    }

@@ -381,8 +381,7 @@ int OsSigEmptySet(sigset_t *set)
 /* Privilege process can't send to kernel and privilege process */
 static int OsSignalPermissionToCheck(const LosProcessCB *spcb)
 {
-    UINT32 gid = spcb->group->groupID;
-
+    UINTPTR gid = (UINTPTR)OS_GET_PGROUP_LEADER(spcb->pgroup);
    if (gid == OS_KERNEL_PROCESS_GROUP) {
        return -EPERM;
    } else if (gid == OS_USER_PRIVILEGE_PROCESS_GROUP) {
@@ -392,22 +391,16 @@ static int OsSignalPermissionToCheck(const LosProcessCB *spcb)
    return 0;
 }

-int OsDispatch(pid_t pid, siginfo_t *info, int permission)
+STATIC int SendSigPermissionCheck(LosProcessCB *spcb, int permission)
 {
-    if (OsProcessIDUserCheckInvalid(pid) || pid < 0) {
+    if (spcb == NULL) {
        return -ESRCH;
    }

-    LosProcessCB *spcb = OS_PCB_FROM_PID(pid);
    if (OsProcessIsUnused(spcb)) {
        return -ESRCH;
    }

-    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
-    if (OsProcessIsInactive(spcb)) {
-        return LOS_OK;
-    }
-
 #ifdef LOSCFG_SECURITY_CAPABILITY
    LosProcessCB *current = OsCurrProcessGet();
    /* Kernel process always has kill permission and user process should check permission */
@@ -420,6 +413,50 @@ int OsDispatch(pid_t pid, siginfo_t *info, int permission)
    if ((permission == OS_USER_KILL_PERMISSION) && (OsSignalPermissionToCheck(spcb) < 0)) {
        return -EPERM;
    }
+    return LOS_OK;
+}
+
+int OsSendSigToProcess(LosProcessCB *spcb, int sig, int permission)
+{
+    siginfo_t info;
+    int ret = SendSigPermissionCheck(spcb, permission);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
+    if (OsProcessIsInactive(spcb)) {
+        return LOS_OK;
+    }
+
+    if (!GOOD_SIGNO(sig)) {
+        return -EINVAL;
+    }
+
+    info.si_signo = sig;
+    info.si_code = SI_USER;
+    info.si_value.sival_ptr = NULL;
+
+    return OsSigProcessSend(spcb, &info);
+}
+
+int OsDispatch(pid_t pid, siginfo_t *info, int permission)
+{
+    if (OsProcessIDUserCheckInvalid(pid) || pid < 0) {
+        return -ESRCH;
+    }
+
+    LosProcessCB *spcb = OS_PCB_FROM_PID(pid);
+    int ret = SendSigPermissionCheck(spcb, permission);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
+    if (OsProcessIsInactive(spcb)) {
+        return LOS_OK;
+    }
+
    return OsSigProcessSend(spcb, info);
 }

@@ -706,7 +743,7 @@ VOID *OsSaveSignalContext(VOID *sp, VOID *newSp)
            sigcb->sigFlag = 0;
            process->sigShare = 0;
            SCHEDULER_UNLOCK(intSave);
-            PRINT_ERR("The signal processing function for the current process pid =%d is NULL!\n", task->processID);
+            PRINT_ERR("The signal processing function for the current process pid =%d is NULL!\n", process->processID);
            return sp;
        }
        /* One pthread do the share signal */
--- a/kernel/base/mem/tlsf/los_memory.c
+++ b/kernel/base/mem/tlsf/los_memory.c
@@ -837,6 +837,9 @@ STATIC UINT32 OsMemPoolInit(VOID *pool, UINT32 size)
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *newNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
+
+    (VOID)memset_s(poolHead, sizeof(struct OsMemPoolHead), 0, sizeof(struct OsMemPoolHead));
+
 #ifdef LOSCFG_KERNEL_LMS
    UINT32 resize = 0;
    if (g_lms != NULL) {
@@ -848,7 +851,6 @@ STATIC UINT32 OsMemPoolInit(VOID *pool, UINT32 size)
        size = (resize == 0) ? size : resize;
    }
 #endif
-    (VOID)memset(poolHead, 0, sizeof(struct OsMemPoolHead));

    LOS_SpinInit(&poolHead->spinlock);
    poolHead->info.pool = pool;
@@ -885,9 +887,14 @@ STATIC UINT32 OsMemPoolInit(VOID *pool, UINT32 size)
 }

 #ifdef LOSCFG_MEM_MUL_POOL
-STATIC VOID OsMemPoolDeinit(VOID *pool)
+STATIC VOID OsMemPoolDeinit(const VOID *pool, UINT32 size)
 {
-    (VOID)memset(pool, 0, sizeof(struct OsMemPoolHead));
+#ifdef LOSCFG_KERNEL_LMS
+    if (g_lms != NULL) {
+        g_lms->deInit(pool);
+    }
+#endif
+    (VOID)memset_s(pool, size, 0, sizeof(struct OsMemPoolHead));
 }

 STATIC UINT32 OsMemPoolAdd(VOID *pool, UINT32 size)
@@ -961,7 +968,7 @@ UINT32 LOS_MemInit(VOID *pool, UINT32 size)

 #ifdef LOSCFG_MEM_MUL_POOL
    if (OsMemPoolAdd(pool, size)) {
-        (VOID)OsMemPoolDeinit(pool);
+        (VOID)OsMemPoolDeInit(pool, size);
        return OS_ERROR;
    }
 #endif
@@ -973,17 +980,21 @@ UINT32 LOS_MemInit(VOID *pool, UINT32 size)
 #ifdef LOSCFG_MEM_MUL_POOL
 UINT32 LOS_MemDeInit(VOID *pool)
 {
-    if (pool == NULL) {
+    struct OsMemPoolHead *tmpPool = (struct OsMemPoolHead *)pool;
+
+    if ((tmpPool == NULL) ||
+        (tmpPool->info.pool != pool) ||
+        (tmpPool->info.totalSize <= OS_MEM_MIN_POOL_SIZE)) {
        return OS_ERROR;
    }

-    if (OsMemPoolDelete(pool)) {
+    if (OsMemPoolDelete(tmpPool)) {
        return OS_ERROR;
    }

-    OsMemPoolDeinit(pool);
+    OsMemPoolDeInit(tmpPool, tmpPool->info.totalSize);

-    OsHookCall(LOS_HOOK_TYPE_MEM_DEINIT, pool);
+    OsHookCall(LOS_HOOK_TYPE_MEM_DEINIT, tmpPool);
    return LOS_OK;
 }

@@ -1896,7 +1907,7 @@ UINT32 LOS_MemInfoGet(VOID *pool, LOS_MEM_POOL_STATUS *poolStatus)
        return LOS_NOK;
    }

-    (VOID)memset(poolStatus, 0, sizeof(LOS_MEM_POOL_STATUS));
+    (VOID)memset_s(poolStatus, sizeof(LOS_MEM_POOL_STATUS), 0, sizeof(LOS_MEM_POOL_STATUS));

    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
@@ -2070,5 +2081,3 @@ BOOL OsMemIsHeapNode(const VOID *ptr)
 #endif
    return FALSE;
 }
-
-
--- a/kernel/base/misc/sysinfo_shellcmd.c
+++ b/kernel/base/misc/sysinfo_shellcmd.c
@@ -35,6 +35,9 @@
 #include "los_queue_pri.h"
 #include "los_swtmr_pri.h"
 #include "los_task_pri.h"
+#ifdef LOSCFG_IPC_CONTAINER
+#include "los_ipc_container_pri.h"
+#endif

 #ifdef LOSCFG_SHELL
 #include "shcmd.h"
@@ -88,7 +91,7 @@ UINT32 OsShellCmdQueueCntGet(VOID)
    LosQueueCB *queueCB = NULL;

    intSave = LOS_IntLock();
-    queueCB = g_allQueue;
+    queueCB = IPC_ALL_QUEUE;
    for (loop = 0; loop < LOSCFG_BASE_IPC_QUEUE_LIMIT; loop++, queueCB++) {
        if (queueCB->queueState == OS_QUEUE_INUSED) {
            queueCnt++;
--- a/kernel/base/misc/task_shellcmd.c
+++ b/kernel/base/misc/task_shellcmd.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -47,36 +47,14 @@
 #include "los_excinfo_pri.h"
 #endif
 #include "los_process_pri.h"
-#include "los_vm_dump.h"
 #ifdef LOSCFG_FS_VFS
 #include "fs/file.h"
 #endif
 #include "los_sched_pri.h"
 #include "los_swtmr_pri.h"
+#include "los_info_pri.h"

 #define OS_PROCESS_MEM_INFO 0x2U
-#define OS_PROCESS_INFO_LEN          (g_processMaxNum * (sizeof(LosProcessCB)))
-#define OS_PROCESS_GROUP_INFO_LEN    (g_processMaxNum * sizeof(UINT32))
-#define OS_PROCESS_UID_INFO_LEN      (g_processMaxNum * sizeof(UINT32))
-#define OS_PROCESS_MEM_ALL_INFO_LEN  (g_processMaxNum * PROCESS_MEMINFO_LEN)
-#ifdef LOSCFG_KERNEL_CPUP
-#define OS_PROCESS_CPUP_LEN           (g_processMaxNum * sizeof(CPUP_INFO_S))
-#define OS_PROCESS_AND_TASK_CPUP_LEN  ((g_processMaxNum + g_taskMaxNum) * sizeof(CPUP_INFO_S))
-#define OS_PROCESS_CPUP_ALLINFO_LEN   (OS_PROCESS_AND_TASK_CPUP_LEN * 3)
-STATIC VOID TaskCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPUP_INFO_S **, const CPUP_INFO_S **);
-STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPUP_INFO_S **, const CPUP_INFO_S **);
-#else
-#define OS_PROCESS_CPUP_ALLINFO_LEN 0
-#endif
-#define OS_PROCESS_ALL_INFO_LEN (g_processMaxNum * (sizeof(LosProcessCB) + sizeof(UINT32)) + \
-    OS_PROCESS_CPUP_ALLINFO_LEN + OS_PROCESS_UID_INFO_LEN)
-
-#define OS_INVALID_SEM_ID         0xFFFFFFFF
-#define OS_TASK_WATER_LINE_SIZE   (g_taskMaxNum * sizeof(UINT32))
-#define OS_TASK_INFO_LEN          (g_taskMaxNum * sizeof(LosTaskCB))
-#define OS_TASK_SCHED_INFO_LEN    (g_taskMaxNum * sizeof(SchedParam))
-#define OS_TASK_ALL_INFO_LEN      (g_taskMaxNum * (sizeof(LosTaskCB) + sizeof(UINT32) + sizeof(SchedParam)))
-
 #undef SHOW
 #ifdef LOSCFG_FS_VFS
 #if defined(LOSCFG_BLACKBOX) && defined(LOSCFG_SAVE_EXCINFO)
@@ -96,9 +74,6 @@ STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPU
 #define SHOW(arg...) PRINTK(arg)
 #endif

-#define VM_INDEX  PROCESS_VM_INDEX
-#define SM_INDEX  PROCESS_SM_INDEX
-#define PM_INDEX  PROCESS_PM_INDEX
 #define CPUP_MULT LOS_CPUP_PRECISION_MULT

 STATIC UINT8 *ConvertProcessModeToString(UINT16 mode)
@@ -143,9 +118,11 @@ STATIC VOID ProcessInfoTitle(VOID *seqBuf, UINT16 flag)
 {
    SHOW("\r\n  PID  PPID PGID   UID   Mode  Status Policy Priority MTID TTotal");
    if (flag & OS_PROCESS_INFO_ALL) {
+#ifdef LOSCFG_KERNEL_VM
        if (flag & OS_PROCESS_MEM_INFO) {
            SHOW(" VirtualMem ShareMem PhysicalMem");
        }
+#endif
 #ifdef LOSCFG_KERNEL_CPUP
        SHOW(" CPUUSE CPUUSE10s CPUUSE1s");
 #endif /* LOSCFG_KERNEL_CPUP */
@@ -157,157 +134,56 @@ STATIC VOID ProcessInfoTitle(VOID *seqBuf, UINT16 flag)
    SHOW(" PName\n");
 }

-STATIC VOID AllProcessDataShow(const LosProcessCB *pcbArray, const SchedParam *param,
-                               UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID ProcessDataShow(const ProcessInfo *processInfo, VOID *seqBuf, UINT16 flag)
 {
-    const INT32 *group = (const INT32 *)((UINTPTR)pcbArray + OS_PROCESS_INFO_LEN);
-    const INT32 *user = (const INT32 *)((UINTPTR)group + OS_PROCESS_GROUP_INFO_LEN);
-    const UINT32 *memArray = (const UINT32 *)((UINTPTR)pcbArray + OS_PROCESS_ALL_INFO_LEN);
-#ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    ProcessCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-#else
-    (VOID)cpupInfo;
-#endif
-
-    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = pcbArray + pid;
-        if (OsProcessIsUnused(processCB)) {
-            continue;
-        }
-
-        SHOW("%5u%6d%5d%6d%7s%8s%7s%9u%5u%7u", pid, (INT32)processCB->parentProcessID, group[pid], user[pid],
-             ConvertProcessModeToString(processCB->processMode), ConvertProcessStatusToString(processCB->processStatus),
-             ConvertSchedPolicyToString(LOS_SCHED_RR), param[processCB->threadGroupID].basePrio,
-             processCB->threadGroupID, processCB->threadNumber);
-
-        if (flag & OS_PROCESS_INFO_ALL) {
-            if (flag & OS_PROCESS_MEM_INFO) {
-                const UINT32 *memUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
-                SHOW("%#11x%#9x%#12x", memUsage[VM_INDEX], memUsage[SM_INDEX], memUsage[PM_INDEX]);
-            }
-#ifdef LOSCFG_KERNEL_CPUP
-            SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", cpupAll[pid].usage / CPUP_MULT, cpupAll[pid].usage % CPUP_MULT,
-                 cpup10s[pid].usage / CPUP_MULT, cpup10s[pid].usage % CPUP_MULT,
-                 cpup1s[pid].usage / CPUP_MULT, cpup1s[pid].usage % CPUP_MULT);
-#endif /* LOSCFG_KERNEL_CPUP */
-        } else {
-#ifdef LOSCFG_KERNEL_CPUP
-            SHOW("%7u.%-2u ", cpup10s[pid].usage / CPUP_MULT, cpup10s[pid].usage % CPUP_MULT);
-#endif /* LOSCFG_KERNEL_CPUP */
-        }
-        SHOW("%-32s\n", processCB->processName);
-    }
-}
+    SHOW("%5u%6u%5d%6d%7s%8s%7s%9u%5u%7u", processInfo->pid, processInfo->ppid, processInfo->pgroupID,
+         processInfo->userID, ConvertProcessModeToString(processInfo->mode),
+         ConvertProcessStatusToString(processInfo->status),
+         ConvertSchedPolicyToString(processInfo->policy), processInfo->basePrio,
+         processInfo->threadGroupID, processInfo->threadNumber);

+    if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_VM
-STATIC VOID ProcessMemUsageGet(LosProcessCB *pcbArray)
-{
-    UINT32 intSave, memUsed;
-    UINT32 *memArray = (UINT32 *)((UINTPTR)pcbArray + OS_PROCESS_ALL_INFO_LEN);
-
-    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = g_processCBArray + pid;
-        UINT32 *proMemUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
-
-        SCHEDULER_LOCK(intSave);
-        if (OsProcessIsUnused(processCB)) {
-            SCHEDULER_UNLOCK(intSave);
-            pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-            continue;
-        }
-
-        LosVmSpace *vmSpace  = processCB->vmSpace;
-        SCHEDULER_UNLOCK(intSave);
-
-        /* Process memory usage statistics, idle task defaults to 0 */
-        if (pid == OsGetIdleProcessID()) {
-            proMemUsage[VM_INDEX] = 0;
-            proMemUsage[SM_INDEX] = 0;
-            proMemUsage[PM_INDEX] = 0;
-        } else if (vmSpace == LOS_GetKVmSpace()) {
-            (VOID)OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[SM_INDEX], &proMemUsage[PM_INDEX]);
-            proMemUsage[VM_INDEX] = proMemUsage[PM_INDEX];
-        } else {
-            memUsed = OsShellCmdProcessVmUsage(vmSpace);
-            if (memUsed == 0) {
-                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-                continue;
-            }
-            proMemUsage[VM_INDEX] = memUsed;
-            memUsed = OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[SM_INDEX], &proMemUsage[PM_INDEX]);
-            if (memUsed == 0) {
-                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-            }
+        if (flag & OS_PROCESS_MEM_INFO) {
+            SHOW("%#11x%#9x%#12x", processInfo->virtualMem, processInfo->shareMem, processInfo->physicalMem);
        }
+#endif
+#ifdef LOSCFG_KERNEL_CPUP
+        SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ",
+             processInfo->cpupAllsUsage / CPUP_MULT, processInfo->cpupAllsUsage % CPUP_MULT,
+             processInfo->cpup10sUsage / CPUP_MULT, processInfo->cpup10sUsage % CPUP_MULT,
+             processInfo->cpup1sUsage / CPUP_MULT, processInfo->cpup1sUsage % CPUP_MULT);
+#endif /* LOSCFG_KERNEL_CPUP */
+    } else {
+#ifdef LOSCFG_KERNEL_CPUP
+        SHOW("%7u.%-2u ", processInfo->cpup10sUsage / CPUP_MULT, processInfo->cpup10sUsage % CPUP_MULT);
+#endif /* LOSCFG_KERNEL_CPUP */
    }
+    SHOW("%-32s\n", processInfo->name);
 }
-#endif

-#define OS_TASK_STATUS_MASK 0x00FF
-STATIC VOID ProcessInfoGet(LosProcessCB **pcbArray, LosTaskCB **tcbArray, SchedParam **schedParam)
+STATIC VOID AllProcessDataShow(const ProcessInfo *pcbArray, VOID *seqBuf, UINT16 flag)
 {
-    INT32 *group = (INT32 *)((UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN);
-    INT32 *user = (INT32 *)((UINTPTR)group + OS_PROCESS_GROUP_INFO_LEN);
-    SchedParam *param = (SchedParam *)((UINTPTR)*tcbArray + OS_TASK_INFO_LEN);
-    *schedParam = param;
-
-    for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
-        const LosTaskCB *taskCB = *tcbArray + tid;
-        if (OsTaskIsUnused(taskCB)) {
+    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
+        const ProcessInfo *processInfo = pcbArray + pid;
+        if (processInfo->status & OS_PROCESS_FLAG_UNUSED) {
            continue;
        }
-
-        LosProcessCB *processCB = *pcbArray + taskCB->processID;
-        if (!OsProcessIsDead(processCB) && !OsProcessIsInit(processCB)) {
-            processCB->processStatus |= (taskCB->taskStatus & OS_TASK_STATUS_MASK);
-        }
-        taskCB->ops->schedParamGet(taskCB, &param[tid]);
-    }
-
-    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = *pcbArray + pid;
-        if (OsProcessIsUnused(processCB)) {
-            continue;
-        }
-
-        if (processCB->group != NULL) {
-            group[processCB->processID] = processCB->group->groupID;
-        } else {
-            group[processCB->processID] = -1;
-        }
-
-#ifdef LOSCFG_SECURITY_CAPABILITY
-        if (processCB->user != NULL) {
-            user[processCB->processID] = processCB->user->userID;
-        } else {
-            user[processCB->processID] = -1;
-        }
-#else
-        user[processCB->processID] = 0;
-#endif
+        ProcessDataShow(processInfo, seqBuf, flag);
    }
 }

-STATIC VOID ProcessInfoShow(const LosProcessCB *pcbArray, const SchedParam *param,
-                            UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID ProcessInfoShow(const ProcessInfo *pcbArray, VOID *seqBuf, UINT16 flag)
 {
 #ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    ProcessCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-    UINT32 pid = OsGetIdleProcessID();
-    UINT32 sysUsage = LOS_CPUP_PRECISION - cpupAll[pid].usage;
-
+    UINT32 pid = OS_KERNEL_IDLE_PROCESS_ID;
+    UINT32 sysUsage = LOS_CPUP_PRECISION - pcbArray[pid].cpup10sUsage;
    SHOW("\n  allCpu(%%): %4u.%02u sys, %4u.%02u idle\n", sysUsage / CPUP_MULT, sysUsage % CPUP_MULT,
-         cpupAll[pid].usage / CPUP_MULT, cpupAll[pid].usage % CPUP_MULT);
+         pcbArray[pid].cpup10sUsage / CPUP_MULT, pcbArray[pid].cpup10sUsage % CPUP_MULT);
 #endif

    ProcessInfoTitle(seqBuf, flag);
-    AllProcessDataShow(pcbArray, param, cpupInfo, seqBuf, flag);
+    AllProcessDataShow(pcbArray, seqBuf, flag);
 }

 STATIC UINT8 *ConvertTaskStatusToString(UINT16 taskStatus)
@@ -337,33 +213,13 @@ STATIC UINT8 *ConvertTaskStatusToString(UINT16 taskStatus)
    return (UINT8 *)"Invalid";
 }

-STATIC VOID TaskWaterLineGet(UINTPTR waterLineBase, LosTaskCB *tcbArray)
-{
-    UINT32 intSave;
-    UINT32 *taskWaterLine = (UINT32 *)waterLineBase;
-
-    for (UINT32 tid = 0; tid < g_taskMaxNum; ++tid) {
-        const LosTaskCB *taskCB = g_taskCBArray + tid;
-        SCHEDULER_LOCK(intSave);
-        if (OsTaskIsUnused(taskCB)) {
-            SCHEDULER_UNLOCK(intSave);
-            tcbArray[tid].taskStatus = OS_TASK_STATUS_UNUSED;
-            continue;
-        }
-
-        (VOID)OsStackWaterLineGet((const UINTPTR *)((UINTPTR)taskCB->topOfStack + taskCB->stackSize),
-                                  (const UINTPTR *)taskCB->topOfStack, &taskWaterLine[taskCB->taskID]);
-        SCHEDULER_UNLOCK(intSave);
-    }
-}
-
 #ifdef LOSCFG_SHELL_CMD_DEBUG
 #define OS_PEND_REASON_MAX_LEN 20

-STATIC CHAR *CheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
+STATIC CHAR *CheckTaskWaitFlag(const TaskInfo *taskInfo, UINTPTR *lockID)
 {
-    *lockID = taskCB->waitID;
-    switch (taskCB->waitFlag) {
+    *lockID = taskInfo->waitID;
+    switch (taskInfo->waitFlag) {
        case OS_TASK_WAIT_PROCESS:
            return "Child";
        case OS_TASK_WAIT_GID:
@@ -395,23 +251,23 @@ STATIC CHAR *CheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
    return NULL;
 }

-STATIC VOID TaskPendingReasonInfoGet(const LosTaskCB *taskCB, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
+STATIC VOID TaskPendingReasonInfoGet(const TaskInfo *taskInfo, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
 {
    CHAR *reason = NULL;

-    if (!(taskCB->taskStatus & OS_TASK_STATUS_PENDING)) {
-        reason = (CHAR *)ConvertTaskStatusToString(taskCB->taskStatus);
+    if (!(taskInfo->status & OS_TASK_STATUS_PENDING)) {
+        reason = (CHAR *)ConvertTaskStatusToString(taskInfo->status);
        goto EXIT;
    }

-    reason = CheckTaskWaitFlag(taskCB, lockID);
+    reason = CheckTaskWaitFlag(taskInfo, lockID);
    if (reason == NULL) {
        reason = "Others";
    }

-    if (taskCB->taskMux != NULL) {
-        *lockID = (UINTPTR)taskCB->taskMux;
-        LosTaskCB *owner = ((LosMux *)taskCB->taskMux)->owner;
+    if (taskInfo->taskMux != NULL) {
+        *lockID = (UINTPTR)taskInfo->taskMux;
+        LosTaskCB *owner = ((LosMux *)taskInfo->taskMux)->owner;
        if (owner != NULL) {
            if (snprintf_s(pendReason, maxLen, maxLen - 1, "Mutex-%u", owner->taskID) == EOK) {
                return;
@@ -448,210 +304,133 @@ STATIC VOID TaskInfoTitle(VOID *seqBuf, UINT16 flag)
    SHOW("  TaskName\n");
 }

-STATIC VOID AllTaskInfoDataShow(const LosTaskCB *allTaskArray, UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID TaskInfoDataShow(const TaskInfo *taskInfo, VOID *seqBuf, UINT16 flag)
 {
-    const SchedParam *param = (const SchedParam *)((UINTPTR)allTaskArray + OS_TASK_INFO_LEN);
-    const UINT32 *waterLine = (const UINT32 *)((UINTPTR)allTaskArray + OS_TASK_INFO_LEN + OS_TASK_SCHED_INFO_LEN);
-#ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    TaskCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-#else
-    (VOID)cpupInfo;
-#endif
-    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
-        for (UINT32 tid = 0; tid < g_taskMaxNum; ++tid) {
-            const LosTaskCB *taskCB = allTaskArray + tid;
-            if (OsTaskIsUnused(taskCB) || (taskCB->processID != pid)) {
-                continue;
-            }
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-            UINTPTR lockID = 0;
-            CHAR pendReason[OS_PEND_REASON_MAX_LEN] = { 0 };
+    UINTPTR lockID = 0;
+    CHAR pendReason[OS_PEND_REASON_MAX_LEN] = { 0 };
 #endif
-            SHOW(" %4u%5u", tid, taskCB->processID);
+    SHOW(" %4u%5u", taskInfo->tid, taskInfo->pid);

 #ifdef LOSCFG_KERNEL_SMP
-            SHOW("%#5x%4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu));
+    SHOW("%#5x%4d ", taskInfo->cpuAffiMask, (INT16)(taskInfo->currCpu));
 #endif
-            SHOW("%9s%7s%9u%#10x%#10x", ConvertTaskStatusToString(taskCB->taskStatus),
-                 ConvertSchedPolicyToString(param[tid].policy), param[tid].priority, taskCB->stackSize, waterLine[tid]);
-            if (flag & OS_PROCESS_INFO_ALL) {
+    SHOW("%9s%7s%9u%#10x%#10x", ConvertTaskStatusToString(taskInfo->status),
+         ConvertSchedPolicyToString(taskInfo->policy), taskInfo->priority, taskInfo->stackSize, taskInfo->waterLine);
+    if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
-                SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", cpupAll[tid].usage / CPUP_MULT, cpupAll[tid].usage % CPUP_MULT,
-                     cpup10s[tid].usage / CPUP_MULT, cpup10s[tid].usage % CPUP_MULT,
-                     cpup1s[tid].usage / CPUP_MULT, cpup1s[tid].usage % CPUP_MULT);
+        SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", taskInfo->cpupAllsUsage / CPUP_MULT, taskInfo->cpupAllsUsage % CPUP_MULT,
+             taskInfo->cpup10sUsage / CPUP_MULT, taskInfo->cpup10sUsage % CPUP_MULT,
+             taskInfo->cpup1sUsage / CPUP_MULT, taskInfo->cpup1sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-                TaskPendingReasonInfoGet(taskCB, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
-                SHOW("%#12x%#12x%11s%#11x", taskCB->stackPointer, taskCB->topOfStack, pendReason, lockID);
+        TaskPendingReasonInfoGet(taskInfo, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
+        SHOW("%#12x%#12x%11s%#11x", taskInfo->stackPoint, taskInfo->topOfStack, pendReason, lockID);
 #endif
-            } else {
+    } else {
 #ifdef LOSCFG_KERNEL_CPUP
-                SHOW("%8u.%-2u ", cpup10s[tid].usage / CPUP_MULT, cpup10s[tid].usage % CPUP_MULT);
+        SHOW("%8u.%-2u ", taskInfo->cpup10sUsage / CPUP_MULT, taskInfo->cpup10sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
-            }
-            SHOW("  %-32s\n", taskCB->taskName);
-        }
+    }
+    SHOW("  %-32s\n", taskInfo->name);
+}
+
+STATIC VOID ProcessTaskInfoDataShow(const ProcessThreadInfo *allTaskInfo, VOID *seqBuf, UINT16 flag)
+{
+    for (UINT32 index = 0; index < allTaskInfo->threadCount; index++) {
+        const TaskInfo *taskInfo = &allTaskInfo->taskInfo[index];
+        TaskInfoDataShow(taskInfo, seqBuf, flag);
    }
 }

-STATIC VOID TaskInfoData(const LosTaskCB *allTaskArray, UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID TaskInfoData(const ProcessThreadInfo *allTaskInfo, VOID *seqBuf, UINT16 flag)
 {
+    ProcessInfoTitle(seqBuf, flag);
+    ProcessDataShow(&allTaskInfo->processInfo, seqBuf, flag);
    TaskInfoTitle(seqBuf, flag);
-    AllTaskInfoDataShow(allTaskArray, cpupInfo, seqBuf, flag);
+    ProcessTaskInfoDataShow(allTaskInfo, seqBuf, flag);
 }

-#ifdef LOSCFG_KERNEL_CPUP
-STATIC VOID TaskCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **cpupAll,
-                                const CPUP_INFO_S **cpup10s, const CPUP_INFO_S **cpup1s)
-{
-    UINTPTR processCpupAll = base + OS_PROCESS_UID_INFO_LEN;
-    *cpupAll = (CPUP_INFO_S *)(processCpupAll + OS_PROCESS_CPUP_LEN);
-    UINTPTR processCpup10s = processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN;
-    *cpup10s = (CPUP_INFO_S *)(processCpup10s + OS_PROCESS_CPUP_LEN);
-    UINTPTR processCpup1s = processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN;
-    *cpup1s = (CPUP_INFO_S *)(processCpup1s + OS_PROCESS_CPUP_LEN);
-}
-
-STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **cpupAll,
-                                   const CPUP_INFO_S **cpup10s, const CPUP_INFO_S **cpup1s)
-{
-    *cpupAll = (CPUP_INFO_S *)(base + OS_PROCESS_UID_INFO_LEN);
-    *cpup10s = (CPUP_INFO_S *)((UINTPTR)*cpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
-    *cpup1s = (CPUP_INFO_S *)((UINTPTR)*cpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
-}
-
-STATIC VOID TaskCpupInfoGet(UINTPTR base)
-{
-    UINT32 intSave;
-
-    CPUP_INFO_S *processCpupAll = (CPUP_INFO_S *)(base + OS_PROCESS_UID_INFO_LEN);
-    CPUP_INFO_S *processCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
-    CPUP_INFO_S *processCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_ALL_TIME, processCpupAll, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_TEN_SECONDS, processCpup10s, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_ONE_SECONDS, processCpup1s, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
-}
-#endif
-
-/*
- * | pcb | group | user | task and process cpup | process mem | tcb | sched param | task water line |
- */
-STATIC VOID ProcessAndTaskInfoGet(LosProcessCB **pcbArray, LosTaskCB **tcbArray,
-                                  SchedParam **schedParam, UINTPTR *cpupInfo, UINT16 flag)
-{
-    UINT32 intSave;
-    UINT32 processInfoLen = OS_PROCESS_ALL_INFO_LEN;
-
-#ifdef LOSCFG_KERNEL_VM
-    if (flag & OS_PROCESS_MEM_INFO) {
-        processInfoLen += OS_PROCESS_MEM_ALL_INFO_LEN;
-    }
-#endif
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)memcpy_s(*pcbArray, OS_PROCESS_INFO_LEN, g_processCBArray, OS_PROCESS_INFO_LEN);
-    *tcbArray = (LosTaskCB *)((UINTPTR)*pcbArray + processInfoLen);
-    (VOID)memcpy_s(*tcbArray, OS_TASK_INFO_LEN, g_taskCBArray, OS_TASK_INFO_LEN);
-
-    ProcessInfoGet(pcbArray, tcbArray, schedParam);
-    SCHEDULER_UNLOCK(intSave);
-
-#ifdef LOSCFG_KERNEL_CPUP
-    *cpupInfo = (UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN + OS_PROCESS_GROUP_INFO_LEN;
-    TaskCpupInfoGet(*cpupInfo);
-#endif
-
-#ifdef LOSCFG_KERNEL_VM
-    if (flag & OS_PROCESS_MEM_INFO) {
-        ProcessMemUsageGet(*pcbArray);
-    }
-#endif
-
-    TaskWaterLineGet((UINTPTR)*tcbArray + OS_TASK_INFO_LEN + OS_TASK_SCHED_INFO_LEN, *tcbArray);
-}
-
-LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqBuf, UINT16 flag)
+LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 processID, VOID *seqBuf, UINT16 flag)
 {
    UINT32 size;
-    LosProcessCB *pcbArray = NULL;
-    LosTaskCB *tcbArray = NULL;
-    SchedParam *schedParam = NULL;
-    UINTPTR cpupInfo = 0;

-    if (taskID == OS_ALL_TASK_MASK) {
-        if (flag & OS_PROCESS_MEM_INFO) {
-            size = OS_PROCESS_ALL_INFO_LEN + OS_PROCESS_MEM_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
-        } else {
-            size = OS_PROCESS_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
-        }
-        pcbArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (processID == OS_ALL_TASK_MASK) {
+        size = sizeof(ProcessInfo) * g_processMaxNum;
+        ProcessInfo *pcbArray = (ProcessInfo *)LOS_MemAlloc(m_aucSysMem1, size);
        if (pcbArray == NULL) {
            PRINT_ERR("Memory is not enough to save task info!\n");
            return LOS_NOK;
        }
        (VOID)memset_s(pcbArray, size, 0, size);
-        ProcessAndTaskInfoGet(&pcbArray, &tcbArray, &schedParam, &cpupInfo, flag);
-        ProcessInfoShow(pcbArray, schedParam, cpupInfo, seqBuf, flag);
-        TaskInfoData(tcbArray, cpupInfo, seqBuf, flag);
-
+        OsGetAllProcessInfo(pcbArray);
+        ProcessInfoShow((const ProcessInfo *)pcbArray, seqBuf, flag);
        (VOID)LOS_MemFree(m_aucSysMem1, pcbArray);
+        return LOS_OK;
    }

+    ProcessThreadInfo *threadInfo = (ProcessThreadInfo *)LOS_MemAlloc(m_aucSysMem1, sizeof(ProcessThreadInfo));
+    if (threadInfo == NULL) {
+        return LOS_NOK;
+    }
+    (VOID)memset_s(threadInfo, sizeof(ProcessThreadInfo), 0, sizeof(ProcessThreadInfo));
+
+    if (OsGetProcessThreadInfo(processID, threadInfo) != LOS_OK) {
+        return LOS_NOK;
+    }
+
+    TaskInfoData(threadInfo, seqBuf, flag);
+    (VOID)LOS_MemFree(m_aucSysMem1, threadInfo);
    return LOS_OK;
 }

 LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv)
 {
+    INT32 processID = OS_ALL_TASK_MASK;
    UINT32 flag = 0;
 #ifdef LOSCFG_KERNEL_VM
    flag |= OS_PROCESS_MEM_INFO;
 #endif

-    if (argc >= 2) { /* 2: The task shell name restricts the parameters */
+    if (argc == 0) {
+        return OsShellCmdTskInfoGet((UINT32)processID, NULL, flag);
+    }
+
+    if (argc >= 3) { /* 3: The task shell name restricts the parameters */
        goto TASK_HELP;
    }

-    if (argc == 1) {
-        if (strcmp("-a", argv[0]) == 0) {
-            flag |= OS_PROCESS_INFO_ALL;
+    if ((argc == 1) && (strcmp("-a", argv[0]) == 0)) {
+        flag |= OS_PROCESS_INFO_ALL;
+    } else if ((argc == 2) && (strcmp("-p", argv[0]) == 0)) { /* 2: Two parameters */
+        flag |= OS_PROCESS_INFO_ALL;
+        processID = atoi(argv[1]);
 #ifdef LOSCFG_SCHED_DEBUG
 #ifdef LOSCFG_SCHED_TICK_DEBUG
-        } else if (strcmp("-i", argv[0]) == 0) {
-            if (!OsShellShowTickResponse()) {
-                return LOS_OK;
-            }
-            goto TASK_HELP;
-#endif
-        } else if (strcmp("-t", argv[0]) == 0) {
-            if (!OsShellShowSchedStatistics()) {
-                return LOS_OK;
-            }
-            goto TASK_HELP;
-#endif
-        } else {
-            goto TASK_HELP;
+    } else if (strcmp("-i", argv[0]) == 0) {
+        if (!OsShellShowTickResponse()) {
+            return LOS_OK;
        }
+        goto TASK_HELP;
+#endif
+    } else if (strcmp("-t", argv[0]) == 0) {
+        if (!OsShellShowSchedStatistics()) {
+            return LOS_OK;
+        }
+        goto TASK_HELP;
+#endif
+    } else {
+        goto TASK_HELP;
    }

-    return OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, flag);
+    return OsShellCmdTskInfoGet((UINT32)processID, NULL, flag);

 TASK_HELP:
    PRINTK("Unknown option: %s\n", argv[0]);
    PRINTK("Usage:\n");
-    PRINTK(" task    --- Basic information about all created processes.\n");
-    PRINTK(" task -a --- Complete information about all created processes.\n");
+    PRINTK(" task          --- Basic information about all created processes.\n");
+    PRINTK(" task -a       --- Complete information about all created processes.\n");
+    PRINTK(" task -p [pid] --- Complete information about specifies processes and its task.\n");
    return LOS_NOK;
 }

--- a/kernel/base/sched/los_priority.c
+++ b/kernel/base/sched/los_priority.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2022-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:
@@ -340,7 +340,7 @@ STATIC VOID HPFWake(LosTaskCB *resumedTask)

 STATIC BOOL BasePriorityModify(SchedRunqueue *rq, LosTaskCB *taskCB, UINT16 priority)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
    BOOL needSched = FALSE;

    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
--- a/kernel/base/sched/los_sched.c
+++ b/kernel/base/sched/los_sched.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -204,10 +204,10 @@ VOID OsSchedRunqueueInit(VOID)
    }
 }

-VOID OsSchedRunqueueIdleInit(UINT32 idleTaskID)
+VOID OsSchedRunqueueIdleInit(LosTaskCB *idleTask)
 {
    SchedRunqueue *rq = OsSchedRunqueue();
-    rq->idleTaskID = idleTaskID;
+    rq->idleTask = idleTask;
 }

 UINT32 OsSchedInit(VOID)
@@ -284,7 +284,7 @@ STATIC LosTaskCB *TopTaskGet(SchedRunqueue *rq)
    LosTaskCB *newTask = HPFRunqueueTopTaskGet(rq->hpfRunqueue);

    if (newTask == NULL) {
-        newTask = OS_TCB_FROM_TID(rq->idleTaskID);
+        newTask = rq->idleTask;
    }

    newTask->ops->start(rq, newTask);
@@ -384,7 +384,7 @@ STATIC VOID SchedTaskSwitch(SchedRunqueue *rq, LosTaskCB *runTask, LosTaskCB *ne
 #endif

 #ifdef LOSCFG_KERNEL_CPUP
-    OsCpupCycleEndStart(runTask->taskID, newTask->taskID);
+    OsCpupCycleEndStart(runTask, newTask);
 #endif

 #ifdef LOSCFG_SCHED_DEBUG
--- a/kernel/base/sched/los_statistics.c
+++ b/kernel/base/sched/los_statistics.c
@@ -145,7 +145,7 @@ UINT32 OsShellShowSchedStatistics(VOID)
    for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
        LosTaskCB *taskCB = g_taskCBArray + tid;
        SCHEDULER_LOCK(intSave);
-        if (OsTaskIsUnused(taskCB) || (taskCB->processID == OsGetIdleProcessID())) {
+        if (OsTaskIsUnused(taskCB) || (taskCB->processCB == (UINTPTR)OsGetIdleProcess())) {
            SCHEDULER_UNLOCK(intSave);
            continue;
        }
--- a/kernel/base/vm/los_vm_dump.c
+++ b/kernel/base/vm/los_vm_dump.c
@@ -146,7 +146,6 @@ UINT32 OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
    LosVmSpace *space = NULL;
    LOS_DL_LIST *spaceList = NULL;
    UINT32 UProcessUsed = 0;
-    UINT32 pmTmp;

    if (actualPm == NULL) {
        return 0;
@@ -167,8 +166,7 @@ UINT32 OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
        if (space == LOS_GetKVmSpace()) {
            continue;
        }
-        (VOID)OsUProcessPmUsage(space, NULL, &pmTmp);
-        UProcessUsed += pmTmp;
+        UProcessUsed += OsUProcessPmUsage(space, NULL, NULL);
    }
    (VOID)LOS_MuxRelease(vmSpaceListMux);

--- a/kernel/base/vm/los_vm_map.c
+++ b/kernel/base/vm/los_vm_map.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -241,20 +241,15 @@ STATIC BOOL OsVmSpaceParamCheck(const LosVmSpace *vmSpace)
    return TRUE;
 }

-STATUS_T LOS_VmSpaceClone(LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace)
+STATUS_T LOS_VmSpaceClone(UINT32 cloneFlags, LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace)
 {
-    LosVmMapRegion *oldRegion = NULL;
-    LosVmMapRegion *newRegion = NULL;
    LosRbNode *pstRbNode = NULL;
    LosRbNode *pstRbNodeNext = NULL;
    STATUS_T ret = LOS_OK;
-    UINT32 numPages;
    PADDR_T paddr;
    VADDR_T vaddr;
-    UINT32 intSave;
    LosVmPage *page = NULL;
-    UINT32 flags;
-    UINT32 i;
+    UINT32 flags, i, intSave, numPages;

    if ((OsVmSpaceParamCheck(oldVmSpace) == FALSE) || (OsVmSpaceParamCheck(newVmSpace) == FALSE)) {
        return LOS_ERRNO_VM_INVALID_ARGS;
@@ -270,8 +265,13 @@ STATUS_T LOS_VmSpaceClone(LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace)
    newVmSpace->heapNow = oldVmSpace->heapNow;
    (VOID)LOS_MuxAcquire(&oldVmSpace->regionMux);
    RB_SCAN_SAFE(&oldVmSpace->regionRbTree, pstRbNode, pstRbNodeNext)
-        oldRegion = (LosVmMapRegion *)pstRbNode;
-        newRegion = OsVmRegionDup(newVmSpace, oldRegion, oldRegion->range.base, oldRegion->range.size);
+        LosVmMapRegion *oldRegion = (LosVmMapRegion *)pstRbNode;
+#if defined(LOSCFG_KERNEL_SHM) && defined(LOSCFG_IPC_CONTAINER)
+        if ((oldRegion->regionFlags & VM_MAP_REGION_FLAG_SHM) && (cloneFlags & CLONE_NEWIPC)) {
+            continue;
+        }
+#endif
+        LosVmMapRegion *newRegion = OsVmRegionDup(newVmSpace, oldRegion, oldRegion->range.base, oldRegion->range.size);
        if (newRegion == NULL) {
            VM_ERR("dup new region failed");
            ret = LOS_ERRNO_VM_NO_MEMORY;
--- a/kernel/base/vm/shm.c
+++ b/kernel/base/vm/shm.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -33,7 +33,6 @@
 #include "string.h"
 #include "time.h"
 #include "sys/types.h"
-#include "sys/shm.h"
 #include "sys/stat.h"
 #include "los_config.h"
 #include "los_init.h"
@@ -46,6 +45,8 @@
 #include "los_process.h"
 #include "los_process_pri.h"
 #include "user_copy.h"
+#include "los_vm_shm_pri.h"
+#include "sys/shm.h"
 #ifdef LOSCFG_SHELL
 #include "shcmd.h"
 #include "shell.h"
@@ -54,20 +55,6 @@

 #ifdef LOSCFG_KERNEL_SHM

-STATIC LosMux g_sysvShmMux;
-
-/* private macro */
-#define SYSV_SHM_LOCK()     (VOID)LOS_MuxLock(&g_sysvShmMux, LOS_WAIT_FOREVER)
-#define SYSV_SHM_UNLOCK()   (VOID)LOS_MuxUnlock(&g_sysvShmMux)
-
-/* The upper limit size of total shared memory is default 16M */
-#define SHM_MAX_PAGES 4096
-#define SHM_MAX (SHM_MAX_PAGES * PAGE_SIZE)
-#define SHM_MIN 1
-#define SHM_MNI 192
-#define SHM_SEG 128
-#define SHM_ALL (SHM_MAX_PAGES)
-
 #define SHM_SEG_FREE    0x2000
 #define SHM_SEG_USED    0x4000
 #define SHM_SEG_REMOVE  0x8000
@@ -91,57 +78,75 @@ STATIC LosMux g_sysvShmMux;
 #define SHM_GROUPE_TO_USER  3
 #define SHM_OTHER_TO_USER   6

-struct shmIDSource {
-    struct shmid_ds ds;
-    UINT32 status;
-    LOS_DL_LIST node;
-#ifdef LOSCFG_SHELL
-    CHAR ownerName[OS_PCB_NAME_LEN];
-#endif
-};
+#ifndef LOSCFG_IPC_CONTAINER
+STATIC LosMux g_sysvShmMux;

 /* private data */
-STATIC struct shminfo g_shmInfo = {
-    .shmmax = SHM_MAX,
-    .shmmin = SHM_MIN,
-    .shmmni = SHM_MNI,
-    .shmseg = SHM_SEG,
-    .shmall = SHM_ALL,
-};
-
+STATIC struct shminfo g_shmInfo;
 STATIC struct shmIDSource *g_shmSegs = NULL;
 STATIC UINT32 g_shmUsedPageCount;

-UINT32 ShmInit(VOID)
+#define IPC_SHM_INFO            g_shmInfo
+#define IPC_SHM_SYS_VSHM_MUTEX  g_sysvShmMux
+#define IPC_SHM_SEGS            g_shmSegs
+#define IPC_SHM_USED_PAGE_COUNT g_shmUsedPageCount
+#endif
+
+/* private macro */
+#define SYSV_SHM_LOCK()     (VOID)LOS_MuxLock(&IPC_SHM_SYS_VSHM_MUTEX, LOS_WAIT_FOREVER)
+#define SYSV_SHM_UNLOCK()   (VOID)LOS_MuxUnlock(&IPC_SHM_SYS_VSHM_MUTEX)
+
+struct shmIDSource *OsShmCBInit(LosMux *sysvShmMux, struct shminfo *shmInfo, UINT32 *shmUsedPageCount)
 {
    UINT32 ret;
    UINT32 i;

-    ret = LOS_MuxInit(&g_sysvShmMux, NULL);
+    if ((sysvShmMux == NULL) || (shmInfo == NULL) || (shmUsedPageCount == NULL)) {
+        return NULL;
+    }
+
+    ret = LOS_MuxInit(sysvShmMux, NULL);
    if (ret != LOS_OK) {
        goto ERROR;
    }

-    g_shmSegs = LOS_MemAlloc((VOID *)OS_SYS_MEM_ADDR, sizeof(struct shmIDSource) * g_shmInfo.shmmni);
-    if (g_shmSegs == NULL) {
-        (VOID)LOS_MuxDestroy(&g_sysvShmMux);
+    shmInfo->shmmax = SHM_MAX;
+    shmInfo->shmmin = SHM_MIN;
+    shmInfo->shmmni = SHM_MNI;
+    shmInfo->shmseg = SHM_SEG;
+    shmInfo->shmall = SHM_ALL;
+
+    struct shmIDSource *shmSegs = LOS_MemAlloc((VOID *)OS_SYS_MEM_ADDR, sizeof(struct shmIDSource) * shmInfo->shmmni);
+    if (shmSegs == NULL) {
+        (VOID)LOS_MuxDestroy(sysvShmMux);
        goto ERROR;
    }
-    (VOID)memset_s(g_shmSegs, (sizeof(struct shmIDSource) * g_shmInfo.shmmni),
-                   0, (sizeof(struct shmIDSource) * g_shmInfo.shmmni));
+    (VOID)memset_s(shmSegs, (sizeof(struct shmIDSource) * shmInfo->shmmni),
+                   0, (sizeof(struct shmIDSource) * shmInfo->shmmni));

-    for (i = 0; i < g_shmInfo.shmmni; i++) {
-        g_shmSegs[i].status = SHM_SEG_FREE;
-        g_shmSegs[i].ds.shm_perm.seq = i + 1;
-        LOS_ListInit(&g_shmSegs[i].node);
+    for (i = 0; i < shmInfo->shmmni; i++) {
+        shmSegs[i].status = SHM_SEG_FREE;
+        shmSegs[i].ds.shm_perm.seq = i + 1;
+        LOS_ListInit(&shmSegs[i].node);
    }
-    g_shmUsedPageCount = 0;
+    *shmUsedPageCount = 0;

-    return LOS_OK;
+    return shmSegs;

 ERROR:
    VM_ERR("ShmInit fail\n");
-    return LOS_NOK;
+    return NULL;
+}
+
+UINT32 ShmInit(VOID)
+{
+#ifndef LOSCFG_IPC_CONTAINER
+    g_shmSegs = OsShmCBInit(&IPC_SHM_SYS_VSHM_MUTEX, &IPC_SHM_INFO, &IPC_SHM_USED_PAGE_COUNT);
+    if (g_shmSegs == NULL) {
+        return LOS_NOK;
+    }
+#endif
+    return LOS_OK;
 }

 LOS_MODULE_INIT(ShmInit, LOS_INIT_LEVEL_VM_COMPLETE);
@@ -150,10 +155,10 @@ UINT32 ShmDeinit(VOID)
 {
    UINT32 ret;

-    (VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, g_shmSegs);
-    g_shmSegs = NULL;
+    (VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, IPC_SHM_SEGS);
+    IPC_SHM_SEGS = NULL;

-    ret = LOS_MuxDestroy(&g_sysvShmMux);
+    ret = LOS_MuxDestroy(&IPC_SHM_SYS_VSHM_MUTEX);
    if (ret != LOS_OK) {
        return -1;
    }
@@ -195,18 +200,18 @@ STATIC INT32 ShmAllocSeg(key_t key, size_t size, INT32 shmflg)
    struct shmIDSource *seg = NULL;
    size_t count;

-    if ((size == 0) || (size < g_shmInfo.shmmin) ||
-        (size > g_shmInfo.shmmax)) {
+    if ((size == 0) || (size < IPC_SHM_INFO.shmmin) ||
+        (size > IPC_SHM_INFO.shmmax)) {
        return -EINVAL;
    }
    size = LOS_Align(size, PAGE_SIZE);
-    if ((g_shmUsedPageCount + (size >> PAGE_SHIFT)) > g_shmInfo.shmall) {
+    if ((IPC_SHM_USED_PAGE_COUNT + (size >> PAGE_SHIFT)) > IPC_SHM_INFO.shmall) {
        return -ENOMEM;
    }

-    for (i = 0; i < g_shmInfo.shmmni; i++) {
-        if (g_shmSegs[i].status & SHM_SEG_FREE) {
-            g_shmSegs[i].status &= ~SHM_SEG_FREE;
+    for (i = 0; i < IPC_SHM_INFO.shmmni; i++) {
+        if (IPC_SHM_SEGS[i].status & SHM_SEG_FREE) {
+            IPC_SHM_SEGS[i].status &= ~SHM_SEG_FREE;
            segNum = i;
            break;
        }
@@ -216,7 +221,7 @@ STATIC INT32 ShmAllocSeg(key_t key, size_t size, INT32 shmflg)
        return -ENOSPC;
    }

-    seg = &g_shmSegs[segNum];
+    seg = &IPC_SHM_SEGS[segNum];
    count = LOS_PhysPagesAlloc(size >> PAGE_SHIFT, &seg->node);
    if (count != (size >> PAGE_SHIFT)) {
        (VOID)LOS_PhysPagesFree(&seg->node);
@@ -224,7 +229,7 @@ STATIC INT32 ShmAllocSeg(key_t key, size_t size, INT32 shmflg)
        return -ENOMEM;
    }
    ShmSetSharedFlag(seg);
-    g_shmUsedPageCount += size >> PAGE_SHIFT;
+    IPC_SHM_USED_PAGE_COUNT += size >> PAGE_SHIFT;

    seg->status |= SHM_SEG_USED;
    seg->ds.shm_perm.mode = (UINT32)shmflg & ACCESSPERMS;
@@ -257,7 +262,7 @@ STATIC INLINE VOID ShmFreeSeg(struct shmIDSource *seg)
        VM_ERR("free physical pages failed, count = %d, size = %d", count, seg->ds.shm_segsz >> PAGE_SHIFT);
        return;
    }
-    g_shmUsedPageCount -= seg->ds.shm_segsz >> PAGE_SHIFT;
+    IPC_SHM_USED_PAGE_COUNT -= seg->ds.shm_segsz >> PAGE_SHIFT;
    seg->status = SHM_SEG_FREE;
    LOS_ListInit(&seg->node);
 }
@@ -267,8 +272,8 @@ STATIC INT32 ShmFindSegByKey(key_t key)
    INT32 i;
    struct shmIDSource *seg = NULL;

-    for (i = 0; i < g_shmInfo.shmmni; i++) {
-        seg = &g_shmSegs[i];
+    for (i = 0; i < IPC_SHM_INFO.shmmni; i++) {
+        seg = &IPC_SHM_SEGS[i];
        if ((seg->status & SHM_SEG_USED) &&
            (seg->ds.shm_perm.key == key)) {
            return i;
@@ -280,7 +285,7 @@ STATIC INT32 ShmFindSegByKey(key_t key)

 STATIC INT32 ShmSegValidCheck(INT32 segNum, size_t size, INT32 shmFlg)
 {
-    struct shmIDSource *seg = &g_shmSegs[segNum];
+    struct shmIDSource *seg = &IPC_SHM_SEGS[segNum];

    if (size > seg->ds.shm_segsz) {
        return -EINVAL;
@@ -298,12 +303,12 @@ STATIC struct shmIDSource *ShmFindSeg(int shmid)
 {
    struct shmIDSource *seg = NULL;

-    if ((shmid < 0) || (shmid >= g_shmInfo.shmmni)) {
+    if ((shmid < 0) || (shmid >= IPC_SHM_INFO.shmmni)) {
        set_errno(EINVAL);
        return NULL;
    }

-    seg = &g_shmSegs[shmid];
+    seg = &IPC_SHM_SEGS[shmid];
    if ((seg->status & SHM_SEG_FREE) || ((seg->ds.shm_nattch == 0) && (seg->status & SHM_SEG_REMOVE))) {
        set_errno(EIDRM);
        return NULL;
@@ -383,8 +388,8 @@ STATIC INT32 ShmSegUsedCount(VOID)
    INT32 count = 0;
    struct shmIDSource *seg = NULL;

-    for (i = 0; i < g_shmInfo.shmmni; i++) {
-        seg = &g_shmSegs[i];
+    for (i = 0; i < IPC_SHM_INFO.shmmni; i++) {
+        seg = &IPC_SHM_SEGS[i];
        if (seg->status & SHM_SEG_USED) {
            count++;
        }
@@ -604,7 +609,7 @@ INT32 ShmCtl(INT32 shmid, INT32 cmd, struct shmid_ds *buf)
 {
    struct shmIDSource *seg = NULL;
    INT32 ret = 0;
-    struct shm_info shmInfo;
+    struct shm_info shmInfo = { 0 };
    struct ipc_perm shm_perm;

    cmd = ((UINT32)cmd & ~IPC_64);
@@ -676,12 +681,12 @@ INT32 ShmCtl(INT32 shmid, INT32 cmd, struct shmid_ds *buf)
            }
            break;
        case IPC_INFO:
-            ret = LOS_ArchCopyToUser(buf, &g_shmInfo, sizeof(struct shminfo));
+            ret = LOS_ArchCopyToUser(buf, &IPC_SHM_INFO, sizeof(struct shminfo));
            if (ret != 0) {
                ret = EFAULT;
                goto ERROR;
            }
-            ret = g_shmInfo.shmmni;
+            ret = IPC_SHM_INFO.shmmni;
            break;
        case SHM_INFO:
            shmInfo.shm_rss = 0;
@@ -695,7 +700,7 @@ INT32 ShmCtl(INT32 shmid, INT32 cmd, struct shmid_ds *buf)
                ret = EFAULT;
                goto ERROR;
            }
-            ret = g_shmInfo.shmmni;
+            ret = IPC_SHM_INFO.shmmni;
            break;
        default:
            VM_ERR("the cmd(%d) is not supported!", cmd);
@@ -784,8 +789,8 @@ STATIC VOID OsShmInfoCmd(VOID)
    PRINTK("\r\n------- Shared Memory Segments -------\n");
    PRINTK("key      shmid    perms      bytes      nattch     status     owner\n");
    SYSV_SHM_LOCK();
-    for (i = 0; i < g_shmInfo.shmmni; i++) {
-        seg = &g_shmSegs[i];
+    for (i = 0; i < IPC_SHM_INFO.shmmni; i++) {
+        seg = &IPC_SHM_SEGS[i];
        if (!(seg->status & SHM_SEG_USED)) {
            continue;
        }
@@ -801,7 +806,7 @@ STATIC VOID OsShmDeleteCmd(INT32 shmid)
 {
    struct shmIDSource *seg = NULL;

-    if ((shmid < 0) || (shmid >= g_shmInfo.shmmni)) {
+    if ((shmid < 0) || (shmid >= IPC_SHM_INFO.shmmni)) {
        PRINT_ERR("shmid is invalid: %d\n", shmid);
        return;
    }
--- a/kernel/common/console.c
+++ b/kernel/common/console.c
@@ -1420,7 +1420,7 @@ INT32 ConsoleTaskReg(INT32 consoleID, UINT32 taskID)
    if (!IsShellEntryRunning(g_console[consoleID - 1]->shellEntryId)) {
        g_console[consoleID - 1]->shellEntryId = taskID;
        LOS_SpinUnlockRestore(&g_consoleSpin, intSave);
-        (VOID)OsSetCurrProcessGroupID(OsGetUserInitProcessID());
+        (VOID)OsSetCurrProcessGroupID(OS_USER_ROOT_PROCESS_ID);
        return LOS_OK;
    }
    LOS_SpinUnlockRestore(&g_consoleSpin, intSave);
--- a/kernel/common/los_config.c
+++ b/kernel/common/los_config.c
@@ -217,7 +217,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsMain(VOID)
    startNsec = LOS_CurrNanosec();
 #endif

-    ret = OsTaskInit();
+    ret = OsProcessInit();
    if (ret != LOS_OK) {
        return ret;
    }
--- a/kernel/common/los_config.h
+++ b/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)

--- a/kernel/extended/cpup/cpup_shellcmd.c
+++ b/kernel/extended/cpup/cpup_shellcmd.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -120,7 +120,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdCpup(INT32 argc, const CHAR **argv)
        return LOS_OK;
    }

-    if (OsProcessIsDead(OS_PCB_FROM_PID(pid))) {
+    if (OsProcessIsUnused(OS_PCB_FROM_PID(pid)) || OsProcessIsDead(OS_PCB_FROM_PID(pid))) {
        PRINTK("\nUnknown pid: %u\n", pid);
        return LOS_OK;
    }
--- a/kernel/extended/cpup/los_cpup.c
+++ b/kernel/extended/cpup/los_cpup.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -33,6 +33,7 @@
 #include "los_base.h"
 #include "los_init.h"
 #include "los_process_pri.h"
+#include "los_info_pri.h"
 #include "los_swtmr.h"


@@ -44,7 +45,7 @@ LITE_OS_SEC_BSS OsIrqCpupCB *g_irqCpup = NULL;
 LITE_OS_SEC_BSS STATIC UINT32 cpupMaxNum;
 LITE_OS_SEC_BSS STATIC UINT16 cpupHisPos = 0; /* current Sampling point of historyTime */
 LITE_OS_SEC_BSS STATIC UINT64 cpuHistoryTime[OS_CPUP_HISTORY_RECORD_NUM + 1];
-LITE_OS_SEC_BSS STATIC UINT32 runningTasks[LOSCFG_KERNEL_CORE_NUM];
+LITE_OS_SEC_BSS STATIC LosTaskCB *runningTasks[LOSCFG_KERNEL_CORE_NUM];
 LITE_OS_SEC_BSS STATIC UINT64 cpupStartCycles = 0;
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
 LITE_OS_SEC_BSS UINT64 timeInIrqSwitch[LOSCFG_KERNEL_CORE_NUM];
@@ -85,10 +86,8 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
 {
    UINT16 prevPos;
    UINT32 loop;
-    UINT32 runTaskID;
    UINT32 intSave;
    UINT64 cycle, cycleIncrement;
-    LosTaskCB *taskCB = NULL;
    LosProcessCB *processCB = NULL;

    SCHEDULER_LOCK(intSave);
@@ -108,7 +107,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
 #endif

    for (loop = 0; loop < g_processMaxNum; loop++) {
-        processCB = OS_PCB_FROM_PID(loop);
+        processCB = OS_PCB_FROM_RPID(loop);
        if (processCB->processCpup == NULL) {
            continue;
        }
@@ -116,26 +115,27 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
    }

    for (loop = 0; loop < g_taskMaxNum; loop++) {
-        taskCB = OS_TCB_FROM_TID(loop);
+        LosTaskCB *taskCB = OS_TCB_FROM_RTID(loop);
        taskCB->taskCpup.historyTime[prevPos] = taskCB->taskCpup.allTime;
    }

    for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
-        runTaskID = runningTasks[loop];
-        if (runTaskID == INVALID_ID) {
+        LosTaskCB *runTask = runningTasks[loop];
+        if (runTask == NULL) {
            continue;
        }
-        taskCB = OS_TCB_FROM_TID(runTaskID);

        /* reacquire the cycle to prevent flip */
        cycle = OsGetCpuCycle();
-        cycleIncrement = cycle - taskCB->taskCpup.startTime;
+        cycleIncrement = cycle - runTask->taskCpup.startTime;
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
        cycleIncrement -= timeInIrqSwitch[loop];
 #endif
-        taskCB->taskCpup.historyTime[prevPos] += cycleIncrement;
-        processCB = OS_PCB_FROM_PID(taskCB->processID);
-        processCB->processCpup->historyTime[prevPos] += cycleIncrement;
+        runTask->taskCpup.historyTime[prevPos] += cycleIncrement;
+        processCB = OS_PCB_FROM_TCB(runTask);
+        if (processCB->processCpup != NULL) {
+            processCB->processCpup->historyTime[prevPos] += cycleIncrement;
+        }
    }

    SCHEDULER_UNLOCK(intSave);
@@ -177,7 +177,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit(VOID)
 #endif

    for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
-        runningTasks[loop] = INVALID_ID;
+        runningTasks[loop] = NULL;
    }
    cpupInitFlg = 1;
    return LOS_OK;
@@ -246,13 +246,12 @@ LITE_OS_SEC_TEXT_INIT VOID LOS_CpupReset(VOID)
    return;
 }

-VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
+VOID OsCpupCycleEndStart(LosTaskCB *runTask, LosTaskCB *newTask)
 {
    /* OsCurrTaskGet and OsCurrProcessGet are not allowed to be called. */
-    LosTaskCB *runTask = OS_TCB_FROM_TID(runTaskID);
    OsCpupBase *runTaskCpup = &runTask->taskCpup;
-    OsCpupBase *newTaskCpup = (OsCpupBase *)&(OS_TCB_FROM_TID(newTaskID)->taskCpup);
-    OsCpupBase *processCpup = OS_PCB_FROM_PID(runTask->processID)->processCpup;
+    OsCpupBase *newTaskCpup = &newTask->taskCpup;
+    OsCpupBase *processCpup = OS_PCB_FROM_TCB(runTask)->processCpup;
    UINT64 cpuCycle, cycleIncrement;
    UINT16 cpuid = ArchCurrCpuid();

@@ -275,7 +274,7 @@ VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
    }

    newTaskCpup->startTime = cpuCycle;
-    runningTasks[cpuid] = newTaskID;
+    runningTasks[cpuid] = newTask;
 }

 LITE_OS_SEC_TEXT_MINOR STATIC VOID OsCpupGetPos(UINT16 mode, UINT16 *curPosPointer, UINT16 *prePosPointer)
@@ -327,7 +326,6 @@ STATIC UINT32 OsHistorySysCpuUsageUnsafe(UINT16 mode)
    UINT64 cpuAllCycle;
    UINT16 pos;
    UINT16 prePos;
-    UINT32 idleProcessID;
    OsCpupBase *processCpup = NULL;

    if (cpupInitFlg == 0) {
@@ -337,8 +335,7 @@ STATIC UINT32 OsHistorySysCpuUsageUnsafe(UINT16 mode)
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];

-    idleProcessID = OsGetIdleProcessID();
-    processCpup = OS_PCB_FROM_PID(idleProcessID)->processCpup;
+    processCpup = OS_PCB_FROM_PID(OS_KERNEL_IDLE_PROCESS_ID)->processCpup;
    return (LOS_CPUP_PRECISION - OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle));
 }

@@ -444,7 +441,7 @@ STATIC UINT32 OsCpupUsageParamCheckAndReset(CPUP_INFO_S *cpupInfo, UINT32 len, U
    return LOS_OK;
 }

-LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
+STATIC UINT32 GetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
 {
    LosProcessCB *processCB = NULL;
    UINT64 cpuAllCycle;
@@ -479,47 +476,52 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_GetAllProcessCpuUsage(UINT16 mode, CPUP_INFO_S
    UINT32 ret;

    SCHEDULER_LOCK(intSave);
-    ret = OsGetAllProcessCpuUsageUnsafe(mode, cpupInfo, len);
+    ret = GetAllProcessCpuUsageUnsafe(mode, cpupInfo, len);
    SCHEDULER_UNLOCK(intSave);
    return ret;
 }

-LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
+UINT32 OsGetProcessAllCpuUsageUnsafe(OsCpupBase *processCpup, ProcessInfo *processInfo)
 {
    UINT64 cpuAllCycle;
    UINT16 pos, prePos;
-    UINT32 taskID;
-    UINT32 ret;
-    LosTaskCB *taskCB = NULL;
-    OsCpupBase *processCpupBase = NULL;
-    CPUP_INFO_S *processCpup = cpupInfo;
-    CPUP_INFO_S *taskCpup = (CPUP_INFO_S *)((UINTPTR)cpupInfo + sizeof(CPUP_INFO_S) * g_processMaxNum);
-
-    ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_taskMaxNum + g_processMaxNum);
-    if (ret != LOS_OK) {
-        return ret;
+    if ((processCpup == NULL) || (processInfo == NULL)) {
+        return LOS_ERRNO_CPUP_PTR_ERR;
    }

-    OsCpupGetPos(mode, &pos, &prePos);
+    OsCpupGetPos(CPUP_LAST_ONE_SECONDS, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpup1sUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);

-    for (taskID = 0; taskID < g_taskMaxNum; taskID++) {
-        taskCB = OS_TCB_FROM_TID(taskID);
-        if (OsTaskIsUnused(taskCB)) {
-            continue;
-        }
+    OsCpupGetPos(CPUP_LAST_TEN_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpup10sUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);

-        taskCpup[taskID].usage = OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
-        taskCpup[taskID].status = OS_CPUP_USED;
-        if (processCpup[taskCB->processID].status == OS_CPUP_UNUSED) {
-            processCpupBase = OS_PCB_FROM_PID(taskCB->processID)->processCpup;
-            if (processCpupBase != NULL) {
-                processCpup[taskCB->processID].usage = OsCalculateCpupUsage(processCpupBase, pos, prePos, cpuAllCycle);
-                processCpup[taskCB->processID].status = OS_CPUP_USED;
-            }
-        }
+    OsCpupGetPos(CPUP_ALL_TIME, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpupAllsUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);
+    return LOS_OK;
+}
+
+UINT32 OsGetTaskAllCpuUsageUnsafe(OsCpupBase *taskCpup, TaskInfo *taskInfo)
+{
+    UINT64 cpuAllCycle;
+    UINT16 pos, prePos;
+    if ((taskCpup == NULL) || (taskInfo == NULL)) {
+        return LOS_ERRNO_CPUP_PTR_ERR;
    }

+    OsCpupGetPos(CPUP_LAST_ONE_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpup1sUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
+
+    OsCpupGetPos(CPUP_LAST_TEN_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpup10sUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
+
+    OsCpupGetPos(CPUP_ALL_TIME, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpupAllsUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
    return LOS_OK;
 }

--- a/kernel/extended/cpup/los_cpup_pri.h
+++ b/kernel/extended/cpup/los_cpup_pri.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -65,12 +65,15 @@ typedef struct {
    OsCpupBase cpup;   /**< irq cpup base */
 } OsIrqCpupCB;

+typedef struct TagTaskCB LosTaskCB;
+typedef struct TagTaskInfo TaskInfo;
+typedef struct TagProcessInfo ProcessInfo;
+
 extern UINT32 OsCpupInit(VOID);
 extern UINT32 OsCpupGuardCreator(VOID);
-extern VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID);
-extern UINT32 OsGetAllTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
-extern UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
-extern UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
+extern VOID OsCpupCycleEndStart(LosTaskCB *runTask, LosTaskCB *newTask);
+extern UINT32 OsGetProcessAllCpuUsageUnsafe(OsCpupBase *processCpup, ProcessInfo *processInfo);
+extern UINT32 OsGetTaskAllCpuUsageUnsafe(OsCpupBase *taskCpup, TaskInfo *taskInfo);
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
 extern UINT32 OsGetAllIrqCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
 extern VOID OsCpupIrqStart(UINT16);
--- a/kernel/extended/hilog/los_hilog.c
+++ b/kernel/extended/hilog/los_hilog.c
@@ -233,14 +233,8 @@ static int HiLogWriteRingBuffer(unsigned char *buffer, size_t bufLen)

 static void HiLogHeadInit(struct HiLogEntry *header, size_t len)
 {
-    struct timespec now;
-    int ret;
-
-    ret = clock_gettime(CLOCK_REALTIME, &now);
-    if (ret != 0) {
-        PRINTK("In %s line %d,clock_gettime fail\n", __FUNCTION__, __LINE__);
-        return;
-    }
+    struct timespec now = {0};
+    (void)clock_gettime(CLOCK_REALTIME, &now);

    header->len = len;
    header->pid = LOS_GetCurrProcessID();
--- a/kernel/extended/liteipc/hm_liteipc.c
+++ b/kernel/extended/liteipc/hm_liteipc.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -316,7 +316,6 @@ STATIC VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
 LITE_OS_SEC_TEXT UINT32 LiteIpcPoolDestroy(UINT32 processID)
 {
    LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
-
    if (pcb->ipcInfo == NULL) {
        return LOS_NOK;
    }
@@ -340,10 +339,10 @@ LITE_OS_SEC_TEXT_INIT STATIC IpcTaskInfo *LiteIpcTaskInit(VOID)
 }

 /* Only when kernenl no longer access ipc node content, can user free the ipc node */
-LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(UINT32 processID, VOID *buf)
+LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(LosProcessCB *pcb, VOID *buf)
 {
    UINT32 intSave;
-    ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
+    ProcIpcInfo *ipcInfo = pcb->ipcInfo;
    IpcUsedNode *node = (IpcUsedNode *)malloc(sizeof(IpcUsedNode));
    if (node != NULL) {
        node->ptr = buf;
@@ -353,26 +352,26 @@ LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(UINT32 processID, VOID *buf
    }
 }

-LITE_OS_SEC_TEXT STATIC VOID *LiteIpcNodeAlloc(UINT32 processID, UINT32 size)
+LITE_OS_SEC_TEXT STATIC VOID *LiteIpcNodeAlloc(LosProcessCB *pcb, UINT32 size)
 {
-    VOID *ptr = LOS_MemAlloc(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, size);
+    VOID *ptr = LOS_MemAlloc(pcb->ipcInfo->pool.kvaddr, size);
    PRINT_INFO("LiteIpcNodeAlloc pid:%d, pool:%x buf:%x size:%d\n",
-               processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, ptr, size);
+               pcb->processID, pcb->ipcInfo->pool.kvaddr, ptr, size);
    return ptr;
 }

-LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcNodeFree(UINT32 processID, VOID *buf)
+LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcNodeFree(LosProcessCB *pcb, VOID *buf)
 {
    PRINT_INFO("LiteIpcNodeFree pid:%d, pool:%x buf:%x\n",
-               processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
-    return LOS_MemFree(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
+               pcb->processID, pcb->ipcInfo->pool.kvaddr, buf);
+    return LOS_MemFree(pcb->ipcInfo->pool.kvaddr, buf);
 }

-LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
+LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(LosProcessCB *pcb, const VOID *buf)
 {
    IpcUsedNode *node = NULL;
    UINT32 intSave;
-    ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
+    ProcIpcInfo *ipcInfo = pcb->ipcInfo;
    IPC_LOCK(intSave);
    LOS_DL_LIST_FOR_EACH_ENTRY(node, &ipcInfo->ipcUsedNodelist, IpcUsedNode, list) {
        if (node->ptr == buf) {
@@ -386,16 +385,16 @@ LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
    return FALSE;
 }

-LITE_OS_SEC_TEXT STATIC INTPTR GetIpcUserAddr(UINT32 processID, INTPTR kernelAddr)
+LITE_OS_SEC_TEXT STATIC INTPTR GetIpcUserAddr(const LosProcessCB *pcb, INTPTR kernelAddr)
 {
-    IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
+    IpcPool pool = pcb->ipcInfo->pool;
    INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
    return kernelAddr + offset;
 }

-LITE_OS_SEC_TEXT STATIC INTPTR GetIpcKernelAddr(UINT32 processID, INTPTR userAddr)
+LITE_OS_SEC_TEXT STATIC INTPTR GetIpcKernelAddr(const LosProcessCB *pcb, INTPTR userAddr)
 {
-    IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
+    IpcPool pool = pcb->ipcInfo->pool;
    INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
    return userAddr - offset;
 }
@@ -409,8 +408,8 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckUsedBuffer(const VOID *node, IpcListNode **o
        ((INTPTR)node > (INTPTR)(pool.uvaddr) + pool.poolSize)) {
        return -EINVAL;
    }
-    ptr = (VOID *)GetIpcKernelAddr(pcb->processID, (INTPTR)(node));
-    if (IsIpcNode(pcb->processID, ptr) != TRUE) {
+    ptr = (VOID *)GetIpcKernelAddr(pcb, (INTPTR)(node));
+    if (IsIpcNode(pcb, ptr) != TRUE) {
        return -EFAULT;
    }
    *outPtr = (IpcListNode *)ptr;
@@ -485,13 +484,12 @@ LITE_OS_SEC_TEXT STATIC UINT32 AddServiceAccess(UINT32 taskID, UINT32 serviceHan
    }

    LosTaskCB *tcb = OS_TCB_FROM_TID(serviceTid);
-    UINT32 processID = OS_TCB_FROM_TID(taskID)->processID;
-    LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
+    LosProcessCB *pcb = OS_PCB_FROM_TID(taskID);
    if ((tcb->ipcTaskInfo == NULL) || (pcb->ipcInfo == NULL)) {
-        PRINT_ERR("Liteipc AddServiceAccess ipc not create! pid %u tid %u\n", processID, tcb->taskID);
+        PRINT_ERR("Liteipc AddServiceAccess ipc not create! pid %u tid %u\n", pcb->processID, tcb->taskID);
        return -EINVAL;
    }
-    tcb->ipcTaskInfo->accessMap[processID] = TRUE;
+    tcb->ipcTaskInfo->accessMap[pcb->processID] = TRUE;
    pcb->ipcInfo->access[serviceTid] = TRUE;
    return LOS_OK;
 }
@@ -499,7 +497,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 AddServiceAccess(UINT32 taskID, UINT32 serviceHan
 LITE_OS_SEC_TEXT STATIC BOOL HasServiceAccess(UINT32 serviceHandle)
 {
    UINT32 serviceTid = 0;
-    UINT32 curProcessID = LOS_GetCurrProcessID();
+    LosProcessCB *curr = OsCurrProcessGet();
    UINT32 ret;
    if (serviceHandle >= MAX_SERVICE_NUM) {
        return FALSE;
@@ -512,15 +510,16 @@ LITE_OS_SEC_TEXT STATIC BOOL HasServiceAccess(UINT32 serviceHandle)
        PRINT_ERR("Liteipc HasServiceAccess GetTid failed\n");
        return FALSE;
    }
-    if (OS_TCB_FROM_TID(serviceTid)->processID == curProcessID) {
+    LosTaskCB *taskCB = OS_TCB_FROM_TID(serviceTid);
+    if (taskCB->processCB == (UINTPTR)curr) {
        return TRUE;
    }

-    if (OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo == NULL) {
+    if (taskCB->ipcTaskInfo == NULL) {
        return FALSE;
    }

-    return OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo->accessMap[curProcessID];
+    return taskCB->ipcTaskInfo->accessMap[curr->processID];
 }

 LITE_OS_SEC_TEXT STATIC UINT32 SetIpcTask(VOID)
@@ -541,12 +540,12 @@ LITE_OS_SEC_TEXT BOOL IsIpcTaskSet(VOID)
    return TRUE;
 }

-LITE_OS_SEC_TEXT STATIC UINT32 GetIpcTaskID(UINT32 processID, UINT32 *ipcTaskID)
+LITE_OS_SEC_TEXT STATIC UINT32 GetIpcTaskID(LosProcessCB *pcb, UINT32 *ipcTaskID)
 {
-    if (OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID == INVAILD_ID) {
+    if (pcb->ipcInfo->ipcTaskID == INVAILD_ID) {
        return LOS_NOK;
    }
-    *ipcTaskID = OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID;
+    *ipcTaskID = pcb->ipcInfo->ipcTaskID;
    return LOS_OK;
 }

@@ -564,7 +563,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 SendDeathMsg(UINT32 processID, UINT32 serviceHand

    pcb->ipcInfo->access[serviceHandle] = FALSE;

-    ret = GetIpcTaskID(processID, &ipcTaskID);
+    ret = GetIpcTaskID(pcb, &ipcTaskID);
    if (ret != LOS_OK) {
        return -EINVAL;
    }
@@ -593,7 +592,7 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
    LOS_DL_LIST *listHead = NULL;
    LOS_DL_LIST *listNode = NULL;
    IpcListNode *node = NULL;
-    UINT32 processID = taskCB->processID;
+    LosProcessCB *pcb = OS_PCB_FROM_TCB(taskCB);

    listHead = &(ipcTaskInfo->msgListHead);
    do {
@@ -607,12 +606,12 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
            node = LOS_DL_LIST_ENTRY(listNode, IpcListNode, listNode);
            SCHEDULER_UNLOCK(intSave);
            (VOID)HandleSpecialObjects(taskCB->taskID, node, TRUE);
-            (VOID)LiteIpcNodeFree(processID, (VOID *)node);
+            (VOID)LiteIpcNodeFree(pcb, (VOID *)node);
        }
    } while (1);

-    ipcTaskInfo->accessMap[processID] = FALSE;
-    for (j = 0; j < MAX_SERVICE_NUM; j++) {
+    ipcTaskInfo->accessMap[pcb->processID] = FALSE;
+    for (j = 0; j < LOSCFG_BASE_CORE_PROCESS_LIMIT; j++) {
        if (ipcTaskInfo->accessMap[j] == TRUE) {
            ipcTaskInfo->accessMap[j] = FALSE;
            (VOID)SendDeathMsg(j, taskCB->taskID);
@@ -630,7 +629,7 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
    (VOID)LOS_MuxUnlock(&g_serviceHandleMapMux);
    /* run deathHandler */
    if (i < MAX_SERVICE_NUM) {
-        for (j = 0; j < MAX_SERVICE_NUM; j++) {
+        for (j = 0; j < LOSCFG_BASE_CORE_PROCESS_LIMIT; j++) {
            if (ipcTaskInfo->accessMap[j] == TRUE) {
                (VOID)SendDeathMsg(j, i);
            }
@@ -686,10 +685,10 @@ LITE_OS_SEC_TEXT STATIC BOOL IsCmsTask(UINT32 taskID)
    BOOL ret;
    (VOID)LOS_MuxLock(&g_serviceHandleMapMux, LOS_WAIT_FOREVER);
 #if (USE_TASKID_AS_HANDLE == 1)
-    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processID == OS_TCB_FROM_TID(g_cmsTask.taskID)->processID) : FALSE;
+    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processCB == OS_TCB_FROM_TID(g_cmsTask.taskID)->processCB) : FALSE;
 #else
-    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processID ==
-        OS_TCB_FROM_TID(g_serviceHandleMap[0].taskID)->processID) : FALSE;
+    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processCB ==
+        OS_TCB_FROM_TID(g_serviceHandleMap[0].taskID)->processCB) : FALSE;
 #endif
    (VOID)LOS_MuxUnlock(&g_serviceHandleMapMux);
    return ret;
@@ -702,29 +701,29 @@ LITE_OS_SEC_TEXT STATIC BOOL IsTaskAlive(UINT32 taskID)
        return FALSE;
    }
    tcb = OS_TCB_FROM_TID(taskID);
-    if (!OsTaskIsUserMode(tcb)) {
-        return FALSE;
-    }
    if (OsTaskIsUnused(tcb)) {
        return FALSE;
    }
    if (OsTaskIsInactive(tcb)) {
        return FALSE;
    }
+    if (!OsTaskIsUserMode(tcb)) {
+        return FALSE;
+    }
    return TRUE;
 }

-LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(UINT32 processID, SpecialObj *obj, BOOL isRollback)
+LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(const LosProcessCB *pcb, SpecialObj *obj, BOOL isRollback)
 {
    int ret;
    if (isRollback == FALSE) {
-        ret = CopyFdToProc(obj->content.fd, processID);
+        ret = CopyFdToProc(obj->content.fd, pcb->processID);
        if (ret < 0) {
            return ret;
        }
        obj->content.fd = ret;
    } else {
-        ret = CloseProcFd(obj->content.fd, processID);
+        ret = CloseProcFd(obj->content.fd, pcb->processID);
        if (ret < 0) {
            return ret;
        }
@@ -733,7 +732,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(UINT32 processID, SpecialObj *obj, BOOL
    return LOS_OK;
 }

-LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(UINT32 processID, SpecialObj *obj, BOOL isRollback)
+LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(LosProcessCB *pcb, SpecialObj *obj, BOOL isRollback)
 {
    VOID *buf = NULL;
    UINT32 ret;
@@ -745,20 +744,20 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(UINT32 processID, SpecialObj *obj, BOOL
            PRINT_ERR("Liteipc Bad ptr address\n");
            return -EINVAL;
        }
-        buf = LiteIpcNodeAlloc(processID, obj->content.ptr.buffSz);
+        buf = LiteIpcNodeAlloc(pcb, obj->content.ptr.buffSz);
        if (buf == NULL) {
            PRINT_ERR("Liteipc DealPtr alloc mem failed\n");
            return -EINVAL;
        }
        ret = copy_from_user(buf, obj->content.ptr.buff, obj->content.ptr.buffSz);
        if (ret != LOS_OK) {
-            LiteIpcNodeFree(processID, buf);
+            LiteIpcNodeFree(pcb, buf);
            return ret;
        }
-        obj->content.ptr.buff = (VOID *)GetIpcUserAddr(processID, (INTPTR)buf);
-        EnableIpcNodeFreeByUser(processID, (VOID *)buf);
+        obj->content.ptr.buff = (VOID *)GetIpcUserAddr(pcb, (INTPTR)buf);
+        EnableIpcNodeFreeByUser(pcb, (VOID *)buf);
    } else {
-        (VOID)LiteIpcNodeFree(processID, (VOID *)GetIpcKernelAddr(processID, (INTPTR)obj->content.ptr.buff));
+        (VOID)LiteIpcNodeFree(pcb, (VOID *)GetIpcKernelAddr(pcb, (INTPTR)obj->content.ptr.buff));
    }
    return LOS_OK;
 }
@@ -810,13 +809,13 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleSvc(UINT32 dstTid, SpecialObj *obj, BOOL is
 LITE_OS_SEC_TEXT STATIC UINT32 HandleObj(UINT32 dstTid, SpecialObj *obj, BOOL isRollback)
 {
    UINT32 ret;
-    UINT32 processID = OS_TCB_FROM_TID(dstTid)->processID;
+    LosProcessCB *pcb = OS_PCB_FROM_TID(dstTid);
    switch (obj->type) {
        case OBJ_FD:
-            ret = HandleFd(processID, obj, isRollback);
+            ret = HandleFd(pcb, obj, isRollback);
            break;
        case OBJ_PTR:
-            ret = HandlePtr(processID, obj, isRollback);
+            ret = HandlePtr(pcb, obj, isRollback);
            break;
        case OBJ_SVC:
            ret = HandleSvc(dstTid, (SpecialObj *)obj, isRollback);
@@ -948,8 +947,8 @@ LITE_OS_SEC_TEXT STATIC UINT32 CopyDataFromUser(IpcListNode *node, UINT32 bufSz,

 LITE_OS_SEC_TEXT STATIC BOOL IsValidReply(const IpcContent *content)
 {
-    UINT32 curProcessID = LOS_GetCurrProcessID();
-    IpcListNode *node = (IpcListNode *)GetIpcKernelAddr(curProcessID, (INTPTR)(content->buffToFree));
+    LosProcessCB *curr = OsCurrProcessGet();
+    IpcListNode *node = (IpcListNode *)GetIpcKernelAddr(curr, (INTPTR)(content->buffToFree));
    IpcMsg *requestMsg = &node->msg;
    IpcMsg *replyMsg = content->outMsg;
    UINT32 reqDstTid = 0;
@@ -959,7 +958,7 @@ LITE_OS_SEC_TEXT STATIC BOOL IsValidReply(const IpcContent *content)
        (replyMsg->timestamp != requestMsg->timestamp) ||
        (replyMsg->target.handle != requestMsg->taskID) ||
        (GetTid(requestMsg->target.handle, &reqDstTid) != 0) ||
-        (OS_TCB_FROM_TID(reqDstTid)->processID != curProcessID)) {
+        (OS_TCB_FROM_TID(reqDstTid)->processCB != (UINTPTR)curr)) {
        return FALSE;
    }
    return TRUE;
@@ -1012,7 +1011,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckPara(IpcContent *content, UINT32 *dstTid)
                }
 #endif
                OsHookCall(LOS_HOOK_TYPE_IPC_WRITE_DROP, msg, *dstTid,
-                            (*dstTid == INVAILD_ID) ? INVAILD_ID : OS_TCB_FROM_TID(*dstTid)->processID, 0);
+                           (*dstTid == INVAILD_ID) ? INVAILD_ID : OS_PCB_FROM_TID(*dstTid)->processID, 0);
                PRINT_ERR("Liteipc A timeout reply, request timestamp:%lld, now:%lld\n", msg->timestamp, now);
                return -ETIME;
            }
@@ -1049,14 +1048,14 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
    }

    LosTaskCB *tcb = OS_TCB_FROM_TID(dstTid);
-    LosProcessCB *pcb = OS_PCB_FROM_PID(tcb->processID);
+    LosProcessCB *pcb = OS_PCB_FROM_TCB(tcb);
    if (pcb->ipcInfo == NULL) {
-        PRINT_ERR("pid %u Liteipc not create\n", tcb->processID);
+        PRINT_ERR("pid %u Liteipc not create\n", pcb->processID);
        return -EINVAL;
    }

    UINT32 bufSz = sizeof(IpcListNode) + msg->dataSz + msg->spObjNum * sizeof(UINT32);
-    IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(tcb->processID, bufSz);
+    IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(pcb, bufSz);
    if (buf == NULL) {
        PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
        return -ENOMEM;
@@ -1079,7 +1078,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
    /* add data to list and wake up dest task */
    SCHEDULER_LOCK(intSave);
    LOS_ListTailInsert(&(tcb->ipcTaskInfo->msgListHead), &(buf->listNode));
-    OsHookCall(LOS_HOOK_TYPE_IPC_WRITE, &buf->msg, dstTid, tcb->processID, tcb->waitFlag);
+    OsHookCall(LOS_HOOK_TYPE_IPC_WRITE, &buf->msg, dstTid, pcb->processID, tcb->waitFlag);
    if (tcb->waitFlag == OS_TASK_WAIT_LITEIPC) {
        OsTaskWakeClearPendMask(tcb);
        tcb->ops->wake(tcb);
@@ -1091,7 +1090,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
    }
    return LOS_OK;
 ERROR_COPY:
-    LiteIpcNodeFree(OS_TCB_FROM_TID(dstTid)->processID, buf);
+    LiteIpcNodeFree(pcb, buf);
    return ret;
 }

@@ -1138,7 +1137,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckRecievedMsg(IpcListNode *node, IpcContent *c
    if (ret != LOS_OK) {
        OsHookCall(LOS_HOOK_TYPE_IPC_READ_DROP, &node->msg, tcb->waitFlag);
        (VOID)HandleSpecialObjects(LOS_CurTaskIDGet(), node, TRUE);
-        (VOID)LiteIpcNodeFree(LOS_GetCurrProcessID(), (VOID *)node);
+        (VOID)LiteIpcNodeFree(OsCurrProcessGet(), (VOID *)node);
    } else {
        OsHookCall(LOS_HOOK_TYPE_IPC_READ, &node->msg, tcb->waitFlag);
    }
@@ -1194,10 +1193,10 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcRead(IpcContent *content)
            }
        }
    } while (1);
-    node->msg.data = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(node->msg.data));
-    node->msg.offsets = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(node->msg.offsets));
-    content->inMsg = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(&(node->msg)));
-    EnableIpcNodeFreeByUser(LOS_GetCurrProcessID(), (VOID *)node);
+    node->msg.data = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(node->msg.data));
+    node->msg.offsets = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(node->msg.offsets));
+    content->inMsg = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(&(node->msg)));
+    EnableIpcNodeFreeByUser(OsCurrProcessGet(), (VOID *)node);
    return LOS_OK;
 }

@@ -1248,7 +1247,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcMsgHandle(IpcContent *con)
    }
 BUFFER_FREE:
    if (nodeNeedFree != NULL) {
-        UINT32 freeRet = LiteIpcNodeFree(LOS_GetCurrProcessID(), nodeNeedFree);
+        UINT32 freeRet = LiteIpcNodeFree(OsCurrProcessGet(), nodeNeedFree);
        ret = (freeRet == LOS_OK) ? ret : freeRet;
    }
    if (ret != LOS_OK) {
--- a/kernel/extended/liteipc/hm_liteipc.h
+++ b/kernel/extended/liteipc/hm_liteipc.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -75,7 +75,7 @@ typedef struct {

 typedef struct {
    LOS_DL_LIST     msgListHead;
-    BOOL            accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];
+    BOOL            accessMap[LOSCFG_BASE_CORE_PROCESS_LIMIT];
 } IpcTaskInfo;

 typedef enum {
--- a/kernel/extended/lms/los_lms.c
+++ b/kernel/extended/lms/los_lms.c
@@ -80,20 +80,25 @@ EXIT:
 STATIC LmsMemListNode *OsLmsGetPoolNodeFromAddr(UINTPTR addr)
 {
    LmsMemListNode *current = NULL;
+    LmsMemListNode *previous = NULL;
    LOS_DL_LIST *listHead = &g_lmsCheckPoolList;

    if (LOS_ListEmpty(&g_lmsCheckPoolList)) {
-        goto EXIT;
+        return NULL;
    }

    LOS_DL_LIST_FOR_EACH_ENTRY(current, listHead, LmsMemListNode, node) {
-        if ((addr >= current->poolAddr) && (addr < current->poolAddr + current->poolSize)) {
-            return current;
+        if ((addr < current->poolAddr) || (addr >= (current->poolAddr + current->poolSize))) {
+            continue;
+        }
+        if ((previous == NULL) ||
+            ((previous->poolAddr <= current->poolAddr) &&
+            ((current->poolAddr + current->poolSize) <= (previous->poolAddr + previous->poolSize)))) {
+            previous = current;
        }
    }

-EXIT:
-    return NULL;
+    return previous;
 }

 STATIC LmsMemListNode *OsLmsCheckPoolCreate(VOID)
@@ -123,18 +128,12 @@ UINT32 LOS_LmsCheckPoolAdd(const VOID *pool, UINT32 size)

    LMS_LOCK(intSave);

-    lmsPoolNode = OsLmsGetPoolNodeFromAddr((UINTPTR)pool);
-    if (lmsPoolNode != NULL) { /* if pool range already on checklist */
-        if (lmsPoolNode->poolAddr != (UINTPTR)pool) { /* pool is a subset of lmsPoolNode->poolAddr */
-            /* do not add it again, just return */
-            PRINT_DEBUG("[LMS]pool %p already on lms checklist !\n", pool);
-            LMS_UNLOCK(intSave);
-            return size; /* return size indicate the shadow memory init successful */
-        } else { /* Re-initialize the same pool, maybe with different size */
-            /* delete the old node, then add a new one */
-            lmsPoolNode->used = LMS_POOL_UNUSED;
-            LOS_ListDelete(&(lmsPoolNode->node));
-        }
+    lmsPoolNode = OsLmsGetPoolNode(pool);
+    if (lmsPoolNode != NULL) { /* if pool already on checklist */
+        /* Re-initialize the same pool, maybe with different size */
+        /* delete the old node, then add a new one */
+        lmsPoolNode->used = LMS_POOL_UNUSED;
+        LOS_ListDelete(&(lmsPoolNode->node));
    }

    lmsPoolNode = OsLmsCheckPoolCreate();
@@ -150,7 +149,8 @@ UINT32 LOS_LmsCheckPoolAdd(const VOID *pool, UINT32 size)
    lmsPoolNode->shadowStart = (UINTPTR)poolAddr + realSize;
    lmsPoolNode->shadowSize = poolAddr + size - lmsPoolNode->shadowStart;
    /* init shadow value */
-    (VOID)memset((VOID *)lmsPoolNode->shadowStart, LMS_SHADOW_AFTERFREE_U8, lmsPoolNode->shadowSize);
+    (VOID)memset_s((VOID *)lmsPoolNode->shadowStart, lmsPoolNode->shadowSize,
+                   LMS_SHADOW_AFTERFREE_U8, lmsPoolNode->shadowSize);

    LOS_ListAdd(&g_lmsCheckPoolList, &(lmsPoolNode->node));

@@ -179,10 +179,11 @@ Release:

 STATIC UINT32 OsLmsInit(VOID)
 {
-    (VOID)memset(g_lmsCheckPoolArray, 0, sizeof(g_lmsCheckPoolArray));
+    (VOID)memset_s(g_lmsCheckPoolArray, sizeof(g_lmsCheckPoolArray), 0, sizeof(g_lmsCheckPoolArray));
    LOS_ListInit(&g_lmsCheckPoolList);
    static LmsHook hook = {
        .init = LOS_LmsCheckPoolAdd,
+        .deInit = LOS_LmsCheckPoolDel,
        .mallocMark = OsLmsLosMallocMark,
        .freeMark = OsLmsLosFreeMark,
        .simpleMark = OsLmsSimpleMark,
@@ -595,7 +596,7 @@ VOID OsLmsReportError(UINTPTR p, UINT32 size, UINT32 errMod)

    (VOID)LOS_AtomicAdd(&g_checkDepth, 1);
    LMS_LOCK(intSave);
-    (VOID)memset(&info, 0, sizeof(LmsAddrInfo));
+    (VOID)memset_s(&info, sizeof(LmsAddrInfo), 0, sizeof(LmsAddrInfo));

    PRINT_ERR("*****  Kernel Address Sanitizer Error Detected Start *****\n");

@@ -766,4 +767,4 @@ VOID __asan_handle_no_return(VOID)
    return;
 }

-LOS_MODULE_INIT(OsLmsInit, LOS_INIT_LEVEL_KMOD_PREVM);
+LOS_MODULE_INIT(OsLmsInit, LOS_INIT_LEVEL_KMOD_PREVM);
--- a/kernel/extended/lms/los_lms_pri.h
+++ b/kernel/extended/lms/los_lms_pri.h
@@ -95,6 +95,7 @@ typedef struct {

 typedef struct {
    UINT32 (*init)(const VOID *pool, UINT32 size);
+    VOID (*deInit)(const VOID *pool);
    VOID (*mallocMark)(const VOID *curNodeStart, const VOID *nextNodeStart, UINT32 nodeHeadSize);
    VOID (*freeMark)(const VOID *curNodeStart, const VOID *nextNodeStart, UINT32 nodeHeadSize);
    VOID (*simpleMark)(UINTPTR startAddr, UINTPTR endAddr, UINT32 value);
@@ -132,4 +133,4 @@ extern SANITIZER_INTERFACE_ATTRIBUTE VOID __asan_handle_no_return(VOID);
 #endif /* __cplusplus */
 #endif /* __cplusplus */

-#endif /* _LOS_LMS_PRI_H */
+#endif /* _LOS_LMS_PRI_H */
--- a/kernel/include/los_swtmr.h
+++ b/kernel/include/los_swtmr.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -275,7 +275,7 @@ typedef struct tagSwTmrCtrl {
    UINTPTR uwArg;      /**< Parameter passed in when the callback function
                             that handles software timer timeout is called */
    SWTMR_PROC_FUNC pfnHandler; /**< Callback function that handles software timer timeout */
-    UINT32          uwOwnerPid; /** Owner of this software timer */
+    UINTPTR uwOwnerPid; /** Owner of this software timer */
    UINT64 startTime;  /**< Software timer start time */
 } SWTMR_CTRL_S;

--- a/kernel/include/los_task.h
+++ b/kernel/include/los_task.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-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:
@@ -512,7 +512,7 @@ typedef struct tagTskInitParam {
    UINT32          uwResved;      /**< It is automatically deleted if set to LOS_TASK_STATUS_DETACHED.
                                        It is unable to be deleted if set to 0. */
    UINT16          consoleID;     /**< The console id of task belongs  */
-    UINT32          processID;
+    UINTPTR         processID;
    UserTaskParam   userParam;
 } TSK_INIT_PARAM_S;

--- a/lib/libc/musl/src/arch/arm/memset.S
+++ b/lib/libc/musl/src/arch/arm/memset.S
@@ -131,6 +131,10 @@ Lreturn:
    pop     {r4}
    bx      lr
 Lfunc_end:
+#if defined(LOSCFG_KERNEL_LMS)
+    .size __memset, Lfunc_end - __memset
+#else
    .size memset, Lfunc_end - memset
+#endif
    .cantunwind
    .fnend                      @ -- End function
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
openharmony_ci	be50721826	!1108 feat: 支持pid容器内访问进程挂载目录 Merge pull request !1108 from zhushengle/proc_pid_dir	2023-02-07 04:07:53 +00:00
zhushengle	4e7d2edbe1	feat: 支持pid容器内访问进程挂载目录 Close #I6DCM8 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: Ie1002ca48f9a73429e767136c1f11b1a8b137b48	2023-02-07 11:42:44 +08:00
openharmony_ci	58610ea87c	!1104 Fix : 修复使用无符号数接收sprintf_s的结果 Merge pull request !1104 from yinjiaming/fix	2023-02-06 12:08:27 +00:00
openharmony_ci	c6ff38edd2	!1107 支持proc/self目录 Merge pull request !1107 from zhushengle/proc_self	2023-02-06 10:41:45 +00:00
zhushengle	1c18c48b1e	feat: 支持proc/self目录 BREAKING CHANGE: 支持proc/self目录对外变更: 1.支持/proc/self挂载目录，用于获取进程信息 Close #I6CZ72 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I465278785bd9e27ddbf4d34ee7b5457e39f98b5b	2023-02-06 14:45:59 +08:00
openharmony_ci	bea394a75e	!1103 fuzz测试用例 Merge pull request !1103 from 权飞燕/fuzz-master	2023-02-06 03:19:54 +00:00
gaorui	272c490618	增加fuzz测试用例 Change-Id: Ib07c89fe4fb840f2be4eec40a379a8f13e5ef2b6 Signed-off-by: gaorui <gaorui23@huawei.com>	2023-02-03 19:12:17 +08:00
openharmony_ci	dd041bef5a	!1106 fix: 修复容器相关问题 Merge pull request !1106 from zhushengle/mem_free	2023-02-03 05:54:19 +00:00
zhushengle	fd925a8163	fix: 修复容器内存泄露问题 1.修复内存泄露 2.修复获取内核信息单位、描述错误 Close #I6CD5C Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I875bec616064517b21af8e69ef8d6e177ec01ce1	2023-02-03 12:21:26 +08:00
openharmony_ci	e8e21fcc3e	!1091 LMS特性安全合规整改 Merge pull request !1091 from JerryH/lms	2023-02-02 01:42:15 +00:00
huangjieliang	c592fe73ec	feat:LMS模块及堆内存模块非安全函数安全合规整改 Close #I68LEO Signed-off-by: huangjieliang <huangjieliang@huawei.com> Change-Id: I6f1a8e647220170b00f771117bb018e5f82997ed	2023-02-01 16:50:11 +08:00
yinjiaming	4174654bdd	fix:修复使用无符号数接收sprintf_s的结果的问题 sprintf_s的返回值是有符号数，应使用有符号数来接收返回值 Signed-off-by: yinjiaming <yinjiaming@huawei.com> Change-Id: Icb1248e0a75a77c1258f64dfa25eef0a7f5dd14e	2023-02-01 10:45:20 +08:00
openharmony_ci	f3a7a9c602	!1102 fix: 修复proc静态问题 Merge pull request !1102 from zhushengle/proc_fix	2023-01-31 02:13:26 +00:00
zhushengle	c8dbdaeb12	fix: 修复proc静态问题 1.proc存在静态问题 2.删除proc节点后，vnode未同步删除，导致系统崩溃 Close #I6BT1F Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I91deecfe1d055a4ad1c2d2cda65acf04e4c53d4c	2023-01-30 19:36:51 +08:00
openharmony_ci	1f05c6a24d	!1101 feat: 支持unshare Merge pull request !1101 from zhushengle/unshare	2023-01-30 08:41:37 +00:00
zhushengle	325b4a49e4	feta: 支持unshare接口 BREAKING CHANGE: 支持unshare接口对外变更 1.支持unshare接口，flags支持：CLONE_NEWPID, CLONE_NEWTIME, CLONE_NEWUTS Close #I6BE5A Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: Ib61abad2fa03a7100bf808e93830f2094fa1c5a6	2023-01-30 10:30:54 +08:00
openharmony_ci	1d1f1b06c3	!1100 支持time容器 Merge pull request !1100 from zhushengle/time_container	2023-01-19 07:48:27 +00:00
zhushengle	16ed05e844	feat: 支持time容器 BREAKING CHANGE: 支持ipc容器及增强对外变更: 1.clone 支持CLONE_NEWTIME 2.增加”/proc/[pid]/container/time" 用于查询容器信息 3.增加”/proc/[pid]/container/time_for_children" 用于查询容器信息 4.增加”/proc/[pid]/container/pid_for_children" 用于查询容器信息 5.增加”/proc/[pid]/time_offsets" 用于查询和配置time容器信息 Close #I6B0A3 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I54d79937ca608a10a4384f61e11c88757f833edf	2023-01-19 15:03:18 +08:00
openharmony_ci	7e0dfb79f7	!1099 feat: 支持IPC容器 Merge pull request !1099 from zhushengle/ipc_container	2023-01-18 06:58:09 +00:00
zhushengle	34814c58a3	feat: 支持IPC容器 BREAKING CHANGE: 支持ipc容器及增强对外变更: 1.clone 支持CLONE_NEWIPC 2.增加”/proc/[pid]/container/ipc" 用于查询容器信息 Close #I6AVMY Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I6a3c248d2d66a5342994c6e0b0aecddea8e32c72	2023-01-18 10:59:25 +08:00
openharmony_ci	c0c9bbdfb4	!1098 支持mnt容器及增强能力 Merge pull request !1098 from zhushengle/mnt_container	2023-01-17 06:20:48 +00:00
zhushengle	e2d903b663	feat: 支持mnt容器及增强能力 BREAKING CHANGE: 支持mnt容器及增强对外变更: 1.clone 支持CLONE_NEWNS 2.增加”/proc/[pid]/container/mnt" 用于查询容器信息 3.新增chroot接口 Close #I6APW2 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I5e8843a0f59bb5b0e6a66a6810dc552e8184a03e	2023-01-16 21:00:17 +08:00
openharmony_ci	d4794ebc38	!1097 feat: 支持系统、进程信息获取 Merge pull request !1097 from zhushengle/info	2023-01-16 06:26:14 +00:00
zhushengle	3be7409a28	feat: 支持系统、进程信息获取 BREAKING CHANGE: 支持系统、进程信息获取对外变更： 1.添加"/proc/meminfo" 获取系统内存使用情况 2.添加"/proc/filesystems" 获取文件系统信息 3.添加"/proc/[pid]/meminfo" 获取进程的内存占用信息 4.添加"/proc/[pid]/cpup" 获取进程的CPUP信息 Close #I6AMVG Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I8c1cab0bf956ced0cf16401907d869058d98cfa6	2023-01-16 09:41:57 +08:00
openharmony_ci	0c7dd0f911	!1096 feat: 支持进程挂载目录和进程命名空间增强 Merge pull request !1096 from zhushengle/process_proc	2023-01-14 09:02:35 +00:00
zhushengle	41619f004d	feat: 支持进程挂载目录和进程命名空间增强 BREAKING CHANGE: 支持进程挂载目录和进程命名空间增强对外变更: 1.支持进程挂载目录，在/proc下可以看到进程挂载目录 2.支持pid容器和uts容器信息查询 Close #I6AEVV Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I6777889552d77e49da81249063f9f3db0af96f34	2023-01-14 15:36:11 +08:00
openharmony_ci	be9cee4c21	!1095 支持uts容器 Merge pull request !1095 from zhushengle/uts_container	2023-01-13 06:50:27 +00:00
zhushengle	6c8735cb9e	feat: 支持uts容器 BREAKING CHANGE: 支持uts容器对外变更: 支持sethostname Close #I6A7C8 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I2504f77c37bb4149861673c81688bd112563c24b	2023-01-12 16:42:11 +08:00
openharmony_ci	8701e73c9f	!1094 feat: 添加pid容器测试用例 Merge pull request !1094 from zhushengle/pid_container_test	2023-01-12 03:06:10 +00:00
zhushengle	c403fdf8ed	feat: 添加pid容器测试用例 Close #I69Z22 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: If2d737766f4cecef70a57be9574cf3785b6900a8	2023-01-11 17:33:21 +08:00
openharmony_ci	251abede16	!1090 支持pid容器 Merge pull request !1090 from zhushengle/pid_container	2023-01-11 09:08:44 +00:00
zhushengle	20782299ce	feat: 支持pid容器 BREAKING CHANGE: 支持pid容器对外变更描述: 1.支持pid容器，使用clone(CLONE_NEWPID)创建 2.shell命令 task -a 不再显示线程信息，只显示系统所有进程信息 3.task命令新增参数-p, task -p pid 可查看改进程下的所有线程信息 4.使用LOS_TaskCreateOnly创建任务时， TSK_INIT_PARAM_S中的processID由原来的记录进程ID修改为记录进程控制块PCB Close #I68LVW Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I0895da9099cb285b3195af5e383d0fdeaf5c0087 Change-Id: I46a7642eeee73a4531c241e3ba6290dd302600a7	2023-01-11 11:13:34 +08:00
openharmony_ci	0b141e052b	!1079 Fix : 将测试用例移植过程中的修改同步回A核 Merge pull request !1079 from yinjiaming/test	2023-01-10 07:02:38 +00:00
openharmony_ci	46cc84331a	!1089 Fix : 内核告警清理 Merge pull request !1089 from yinjiaming/fix	2023-01-06 03:51:23 +00:00
yinjiaming	e816896dc4	Fix: 将测试用例移植过程中的修改同步回A核 Change-Id: I021e11f3e36bd71358a7cc674ec83dd5d98bc97e Signed-off-by: yinjiaming <yinjiaming@huawei.com>	2023-01-05 17:21:02 +08:00
yinjiaming	ebc3f30524	fix:修复codecheck扫描出的告警给宏定义中的参数加上了括号,删除了多余的函数声明 Signed-off-by: yinjiaming <yinjiaming@huawei.com> Change-Id: I8853f6a9717ede96578cd674b83b716c8e63f0d8	2023-01-04 15:17:45 +08:00
openharmony_ci	3119d83a6a	!1087 feat: README添加内核编码规范指导 Merge pull request !1087 from zhushengle/README	2022-12-05 12:57:14 +00:00
zhushengle	8482c9d7be	feat: README新增内核编码规范 Close #I644XN Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I733a65111f7557e155b0bb7be87944aaa377e928	2022-12-01 16:08:38 +08:00
openharmony_ci	248e9f7089	!1082 fix: 修复README失效链接 Merge pull request !1082 from zhushengle/README	2022-11-29 11:43:57 +00:00
zhushengle	f2a35262bd	fix: 修复README失效链接 Close #I63RAH Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: Iebff2bacd5d85ad126cf6039d4f9be1dab64815f	2022-11-29 17:42:07 +08:00
openharmony_ci	794cdae65f	!1080 feat: 更新PR模板, 添加对外变确认项 Merge pull request !1080 from zhushengle/pr	2022-11-29 01:53:25 +00:00
zhushengle	7975f5c8ef	feat: 更新PR模板, 添加对外变确认项 1.更新PR模板, 添加对外变确认项 2.添加历史版本的CHANGELOG Close #I63L3D Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I22f64cd0bc5ad083806edd4ff00d955cb81bef0e	2022-11-28 22:24:16 +08:00
openharmony_ci	fc4c694235	!1078 fix: codecheck问题清零 Merge pull request !1078 from zhushengle/codecheck	2022-11-28 13:36:55 +00:00
openharmony_ci	ead4da80ba	!1071 fix：增强对LOS_ArchCopyToUser接口的安全防护 Merge pull request !1071 from zhangdengyu/fix_kernelStack_1115	2022-11-28 09:07:57 +00:00
zhushengle	8d980ded54	fix: codecheck问题清零 1.shell初始化异常流程double free 2.los_disk_init中冗余初始化 3.OsKProcessPmUsage 中OsUProcessPmUsage异常退出时，存在使用未初始化的变量 4.HiLogHeadInit异常推出后，存在使用未初始化的变量 5.api_shell.c 中存在冗余初始化 fix #I63H5G Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: If17d8ed1e6f2276e20fbce24b32de169bfd22e54	2022-11-28 16:09:10 +08:00
zhangdengyu	07e3feb456	fix: 增强对LOS_ArchCopyToUser接口的安全防护 Close: #I61CLY Signed-off-by: zhangdengyu <zhangdengyu2@huawei.com> Change-Id: I0faf8e5849c24b108f290e483124f3edaf70ef50	2022-11-25 11:47:56 +08:00
openharmony_ci	b5ce4d34df	!1058 更新liteos_a 内核架构图 Merge pull request !1058 from zhushengle/Arch	2022-11-25 01:52:49 +00:00
zhushengle	99c81c4ffa	feat: 更新liteos_a内核架构图 fix #I61OYY Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I038f1cae44f0138ef924bf4905f3a5b0dc24841e	2022-11-24 12:34:08 +08:00
openharmony_ci	4d1fd22b1c	!1060 LTS 补丁升级适配 Merge pull request !1060 from gaochao/master	2022-11-14 09:16:06 +00:00
openharmony_ci	efa336ab26	!1061 time相关系统调用内核栈信息泄露排查 Merge pull request !1061 from zhushengle/time	2022-11-11 06:44:21 +00:00
zhushengle	0b05a46691	task: time相关系统调用内核栈信息泄露排查解决方案: 在涉及从内核拷贝数据到用户态的场景时，先将内核的数据进行清零操作，再填充内核数据 Close #I60M1P Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: Ia61d4e39b9e190accea477ff5b361e41d0eed2af	2022-11-11 14:24:07 +08:00
gaochao	177f32283f	LTS 补丁升级适配 Signed-off-by: gaochao <gaochao49@huawei.com>	2022-11-10 16:32:48 +08:00
openharmony_ci	6888193e3f	!1052 LTS 5.10 补丁升级适配 Merge pull request !1052 from gaochao/master	2022-11-04 07:23:25 +00:00
gc1202	6c352a7b10	LTS 补丁升级适配 Signed-off-by: gc1202 <gaochao49@huawei.com>	2022-11-02 14:23:47 +08:00
openharmony_ci	73a9587f02	!1046 Fix : 内核告警清理 Merge pull request !1046 from yinjiaming/fix	2022-10-27 12:50:29 +00:00
openharmony_ci	cbd03bd7e0	!913 删除PLATFORM_QEMU_ARM_VIRT_CA7侵入内核的所有代码 Merge pull request !913 from laokz/jffs2fat	2022-10-26 03:52:16 +00:00
yinjiaming	8d55bb1d8c	fix: 内核告警清理【背景】内核告警清理【修改方案】删去了多余的空格，更改了魔数字【影响】对现有的产品编译不会有影响。 Signed-off-by: yinjiaming <yinjiaming@huawei.com> Change-Id: Iba21be6cb23027dfb369576847d7d21e85f936b4	2022-10-26 10:57:08 +08:00
laokz	059c1c22b1	fix(PLATFORM_QEMU_ARM_VIRT_CA7): remove all invasive code arm-virt emulation rootfs change to vfat from jffs2, root device change to eMMC from CFI flash Signed-off-by: laokz <laokz@foxmail.com> Change-Id: If284809b989918cf10f5d32803df42c8c57830b2	2022-06-25 18:25:39 +08:00