!1065 【挑单】time相关系统调用内核栈信息泄露排查

Merge pull request !1065 from zhushengle/cherry-pick-1668148610

.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md

@@ -10,12 +10,6 @@
 ### 测试用例（新增、改动、可能影响的功能）
 
 
-### 是否涉及对外变更（典型的如：对外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]替换[ ]即可勾选对应选项）:

BUILD.gn

@@ -35,7 +35,6 @@ declare_args() {
   tee_enable = false
   liteos_name = "OHOS_Image"
   liteos_skip_make = false
-  liteos_is_mini = false
 }
 
 tee = ""
@@ -129,9 +128,7 @@ config("stdinc_config") {
     "-isystem",
     std_include,
   ]
-  if (!defined(LOSCFG_LIBC_NEWLIB)) {
-    cflags += [ "-nostdinc" ]
-  }
+  cflags += [ "-nostdinc" ]
   asmflags = cflags
 }
 
@@ -292,7 +289,6 @@ group("modules") {
     "security",
     "shell",
     "syscall",
-    "testsuites/kernel:kernel_test",
   ]
 
   deps += [
@@ -318,17 +314,13 @@ group("kernel") {
 }
 
 group("liteos_a") {
-  deps = [ ":kernel" ]
-  if (!liteos_is_mini) {
-    deps += [
-      ":apps",
-      ":tests",
-      "//third_party/musl/scripts/build_lite:strip",
-    ]
-    if (liteos_skip_make == false) {
-      deps += [ ":make" ]
-    }
-  }
+  deps = [
+    ":apps",
+    ":kernel",
+    ":make",
+    ":tests",
+    "//prebuilts/lite/sysroot/build:strip",
+  ]
 }
 
 executable("liteos") {
@@ -344,17 +336,6 @@ executable("liteos") {
     "-Wl,--no-eh-frame-hdr",
   ]
 
-  if (defined(LOSCFG_LIBC_NEWLIB)) {
-    ldflags += [
-      "-Wl,--wrap=_free_r",
-      "-Wl,--wrap,_malloc_usable_size_r",
-      "-Wl,--wrap,_malloc_r",
-      "-Wl,--wrap,_memalign_r",
-      "-Wl,--wrap,_realloc_r",
-      "-Wl,--wrap,_fseeko_r",
-    ]
-    ldflags -= [ "-nostdlib" ]
-  }
   libgcc = exec_script("//build/lite/run_shell_cmd.py",
                        [ "$cc -print-libgcc-file-name" ],
                        "trim string")
@@ -366,7 +347,7 @@ executable("liteos") {
   } else {
     ldflags +=
         [ "-Wl,-T" + rebase_path("tools/build/liteos.ld", root_build_dir) ]
-    ldflags += [ "-nostartfiles" ]
+    ldflags += [ "-Wl,-nostartfiles" ]
     inputs = [ "tools/build/liteos.ld" ]
   }
 

CHANGELOG.md

@@ -1,338 +0,0 @@
-#  (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标记，否则该描述符不会被关闭。
-
-
-

Kconfig

@@ -265,7 +265,7 @@ config MEM_LEAKCHECK
     default n
     depends on DEBUG_VERSION && MEM_DEBUG
     help
-      Answer Y to enable record the LR of Function call stack of Mem operation, it can check the mem leak through the information of mem node.
+      Answer Y to enable record the LR of Function call stack of Mem operation, it can check the mem leak through the informations of mem node.
 config BASE_MEM_NODE_INTEGRITY_CHECK
     bool "Enable integrity check or not"
     default n

Makefile

@@ -82,6 +82,9 @@ 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
 
@@ -118,7 +121,7 @@ sysroot:
 	$(HIDE)echo "sysroot:" $(abspath $(SYSROOT_PATH))
 ifeq ($(origin SYSROOT_PATH),file)
 	$(HIDE)mkdir -p $(SYSROOT_PATH)/build && cd $(SYSROOT_PATH)/build && \
-	ln -snf $(LITEOSTOPDIR)/../../third_party/musl/scripts/build_lite/Makefile && \
+	ln -snf $(LITEOSTOPDIR)/../../prebuilts/lite/sysroot/build/Makefile && \
 	$(MAKE) TARGETS=liteos_a_user \
 		ARCH=$(ARCH) \
 		TARGET=$(LOSCFG_LLVM_TARGET) \

OAT.xml

@@ -15,7 +15,7 @@
 -->
 
 <!--
-   This is the configuration file template for OpenHarmony OSS Audit Tool. Please copy it to your project root dir and modify it by referring to OpenHarmony/tools_oat/README.
+   This is the configuration file template for OpenHarmony OSS Audit Tool, please copy it to your project root dir and modify it refer to OpenHarmony/tools_oat/README.
 -->
 
 <configuration>
@@ -24,7 +24,6 @@
         <policylist>
             <policy name="projectPolicy" desc="">
                 <policyitem type="copyright" name="Huawei Technologies Co., Ltd. All rights reserved." path=".*" desc="original liteos copyright"/>
-                <policyitem type="copyright" name="Huawei Device Co., Ltd. All rights reserved." path=".*" desc="original liteos copyright"/>
                 <policyitem type="license" name="BSD-3-Clause" path=".*" desc="Liteos kernel use bsd3 license"/>
             </policy>
         </policylist>
@@ -39,7 +38,7 @@
                 <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
                 <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
             </filefilter>
-            <filefilter name="defaultPolicyFilter" desc="Filters for license header policies">
+            <filefilter name="defaultPolicyFilter" desc="Filters for compatibility，license header policies">
                 <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
                 <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
                 <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->

README.md

@@ -4,10 +4,10 @@
 -   [Directory Structure](#section161941989596)
 -   [Constraints](#section119744591305)
 -   [Usage](#section741617511812)
--   [Preparations](#section1579912573329)
--   [Source Code Acquisition](#section11443189655)
--   [Compilation and Building](#section2081013992812)
--   [Contribution](#section1371123476304)
+    -   [Preparations](#section1579912573329)
+    -   [Source Code Acquisition](#section11443189655)
+    -   [Compilation and Building](#section2081013992812)
+
 -   [Repositories Involved](#section1371113476307)
 
 ## Introduction<a name="section11660541593"></a>
@@ -67,33 +67,24 @@ 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-appendix-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-lite-introduction-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 Ubuntu.
+You need to set up the compilation environment on Linux.
 
--   [Setting Up Ubuntu Development Environment](https://gitee.com/openharmony/docs/blob/master/en/device-dev/quick-start/Readme-EN.md)
+-   [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).
 
 ### Source Code Acquisition<a name="section11443189655"></a>
 
-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).
+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).
 
 ### Compilation and Building<a name="section2081013992812"></a>
 
-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)
+For details about how to develop the first application, see:
 
-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)
+-   [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)
 
 ## Repositories Involved<a name="section1371113476307"></a>
 

README_zh-HK.md

@@ -4,10 +4,10 @@
 - [目錄](#section161941989596)
 - [約束](#section119744591305)
 - [使用說明](#section741617511812)
-- [準備](#section1579912573329)
-- [獲取源碼](#section11443189655)
-- [編譯構建](#section2081013992812)
-- [貢獻](#section1371123476304)
+    - [準備](#section1579912573329)
+    - [獲取源碼](#section11443189655)
+    - [編譯構建](#section2081013992812)
+
 - [相關倉](#section1371113476307)
 
 ## 簡介<a name="section11660541593"></a>
@@ -67,33 +67,24 @@ 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-appendix-hi3516.md)單板，開發者可基於此單板開發運行自己的應用程序。
+OpenHarmony LiteOS-A內核支持Hi3516DV300（[介紹](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-introduction-hi3516.md)）單板，開發者可基於此單板開發運行自己的應用程序。
 
 ### 準備<a name="section1579912573329"></a>
 
-開發者需要在Ubuntu上搭建編譯環境：
+開發者需要在Linux上搭建編譯環境：
 
-- [編譯環境凖備](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/Readme-CN.md);
+- [編譯環境凖備](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)。
 
 ### 獲取源碼<a name="section11443189655"></a>
 
-在Ubuntu服務器上下載並解壓一套源代碼，源碼獲取方式參考[源碼獲取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。
+在Linux服務器上下載並解壓一套源代碼，源碼獲取方式參考[源碼獲取](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)。
+開發者開發第一個應用程序可參考：
 
-編譯可以參考：[編譯指導](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)
+- [helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-running.md)。
 
 ## 相關倉<a name="section1371113476307"></a>
 

README_zh.md

@@ -4,10 +4,10 @@
 -   [目录](#section161941989596)
 -   [约束](#section119744591305)
 -   [使用说明](#section741617511812)
--   [准备](#section1579912573329)
--   [获取源码](#section11443189655)
--   [编译构建](#section2081013992812)
--   [贡献](#section1371123476304)
+    -   [准备](#section1579912573329)
+    -   [获取源码](#section11443189655)
+    -   [编译构建](#section2081013992812)
+
 -   [相关仓](#section1371113476307)
 
 ## 简介<a name="section11660541593"></a>
@@ -33,7 +33,6 @@ OpenHarmony LiteOS-A内核是基于Huawei LiteOS内核演进发展的新一代
 │       ├── quickstart     # 系统快速启动接口目录
 │       ├── random         # 随机数设备驱动
 │       └── video          # framebuffer驱动框架
-├── figures                # 内核架构图
 ├── fs                     # 文件系统模块，主要来源于NuttX开源项目
 │   ├── fat                # fat文件系统
 │   ├── jffs2              # jffs2文件系统
@@ -55,9 +54,7 @@ OpenHarmony LiteOS-A内核是基于Huawei LiteOS内核演进发展的新一代
 │   ├── include            # 对外暴露头文件存放目录
 │   └── uart               # 串口相关逻辑代码
 ├── security               # 安全特性相关的代码，包括进程权限管理和虚拟id映射管理
-├── shell                  # 接收用户输入的命令，内核去执行
 ├── syscall                # 系统调用
-├── testsuilts             # 测试套件
 └── tools                  # 构建工具及相关配置和代码
 ```
 
@@ -69,33 +66,24 @@ 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-appendix-hi3516.md)单板。开发者可基于此单板开发运行自己的应用程序。
+OpenHarmony LiteOS-A内核支持[Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-introduction-hi3516.md)单板。开发者可基于此单板开发运行自己的应用程序。
 
 ### 准备<a name="section1579912573329"></a>
 
-开发者需要在Ubuntu上搭建编译环境：
+开发者需要在Linux上搭建编译环境：
 
--   [编译环境准备](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/Readme-CN.md);
+-   [编译环境准备](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)。
 
 ### 获取源码<a name="section11443189655"></a>
 
-在Ubuntu服务器源码获取方式参考: [源码获取](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/get-code/sourcecode-acquire.md)。
+在Linux服务器上下载并解压一套源代码，源码获取方式参考[源码获取](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)。
+开发者开发第一个应用程序可参考：
 
-编译可以参考：[编译指导](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)
+-   [helloworld for Hi3516DV300](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/quick-start/quickstart-lite-steps-hi3516-running.md)。
 
 ## 相关仓<a name="section1371113476307"></a>
 

apps/lms/src/sample_usr_lms.c

@@ -180,8 +180,7 @@ static void LmsStrcpyTest(void)
         return;
     }
     char *testStr = "bbbbbbbbbbbbbbbbb";
-    printf("[LmsStrcpyTest] strcpy overflow error should be triggered, src string buf size:%d\n",
-           (int)strlen(testStr) + 1);
+    printf("[LmsStrcpyTest] strcpy overflow error should be triggered, src string buf size:%d\n", strlen(testStr) + 1);
     strcpy(buf, testStr);
     free(buf);
     printf("\n-------- LmsStrcpyTest End --------\n");

apps/mksh/BUILD.gn

@@ -42,7 +42,7 @@ copy("copy_mksh_src") {
 
 build_ext_component("build_mksh") {
   deps = [ ":copy_mksh_src" ]
-  deps += [ "//third_party/musl:sysroot_lite" ]
+  deps += [ "//prebuilts/lite/sysroot" ]
   exec_path = rebase_path("$target_out_dir/mksh_build")
 
   cflags = [

apps/perf/src/main.c

@@ -62,7 +62,7 @@ int main(int argc, char **argv)
         PerfStop(fd);
     } else if ((argc == THREE_ARGS) && strcmp(argv[1], "read") == 0) {
         size_t size = strtoul(argv[THREE_ARGS - 1], NULL, 0);
-        if (size == 0) {
+        if (size <= 0) {
             goto EXIT:
         }
 

apps/shell/include/shell_pri.h

@@ -32,15 +32,13 @@
 #ifndef _SHELL_PRI_H
 #define _SHELL_PRI_H
 
-#include "shell.h"
-
 #ifdef __cplusplus
 #if __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */
 
-extern void ShellEntry(ShellCB *shellCB);
+extern void *ShellEntry(void *argv);
 extern void *ShellTask(void *argv);
 
 #ifdef __cplusplus

apps/shell/include/shmsg.h

@@ -32,7 +32,6 @@
 #ifndef _SHMSG_H
 #define _SHMSG_H
 
-#include "shell_list.h"
 #include "shell.h"
 
 #ifdef __cplusplus
@@ -62,7 +61,8 @@ extern "C" {
 
 typedef void (* OutputFunc)(const char *fmt, ...);
 extern int ShellTaskInit(ShellCB *shellCB);
-extern void ChildExec(const char *cmdName, char *const paramArray[], bool foreground);
+extern int ShellEntryInit(ShellCB *shellCB);
+extern void ChildExec(const char *cmdName, char *const paramArray[]);
 extern void ShellCmdLineParse(char c, OutputFunc outputFunc, ShellCB *shellCB);
 extern int ShellNotify(ShellCB *shellCB);
 

apps/shell/src/main.c

@@ -31,16 +31,13 @@
 
 #define _GNU_SOURCE
 
-#include <signal.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <sys/syscall.h>
 #include "show.h"
 #include "shmsg.h"
 #include "shcmd.h"
-#include "shell_pri.h"
 #include "semaphore.h"
 #include "securec.h"
+#include "unistd.h"
+#include <sys/syscall.h>
 
 ShellCB *g_shellCB = NULL;
 
@@ -49,7 +46,7 @@ ShellCB *OsGetShellCb()
     return g_shellCB;
 }
 
-static void ShellDeinit(ShellCB *shellCB)
+void ShellDeinit(ShellCB *shellCB)
 {
     (void)pthread_mutex_destroy(&shellCB->historyMutex);
     (void)pthread_mutex_destroy(&shellCB->keyMutex);
@@ -65,23 +62,32 @@ static int OsShellCreateTask(ShellCB *shellCB)
 
     ret = sched_getparam(getpid(), &param);
     if (ret != SH_OK) {
-        return ret;
+        goto OUT;
     }
 
     param.sched_priority = SHELL_PROCESS_PRIORITY_INIT;
 
     ret = sched_setparam(getpid(), &param);
     if (ret != SH_OK) {
-        return ret;
+        goto OUT;
     }
 
     ret = ShellTaskInit(shellCB);
     if (ret != SH_OK) {
-        return ret;
+        goto OUT;
     }
 
-    shellCB->shellEntryHandle = pthread_self();
-    return 0;
+    ret = ShellEntryInit(shellCB);
+    if (ret != SH_OK) {
+        goto OUT;
+    }
+
+    (void)pthread_join(shellCB->shellTaskHandle, NULL);
+    (void)pthread_join(shellCB->shellEntryHandle, NULL);
+
+OUT:
+    ShellDeinit(shellCB);
+    return ret;
 }
 
 static int DoShellExec(char **argv)
@@ -92,7 +98,7 @@ static int DoShellExec(char **argv)
     char *cmdLine = NULL;
 
     if (strncmp(argv[0], SHELL_EXEC_COMMAND, SHELL_EXEC_COMMAND_BYTES) == 0) {
-        ChildExec(argv[1], argv + 1, FALSE);
+        ChildExec(argv[1], argv + 1);
     }
     for (i = 0; argv[i]; i++) {
         len += strlen(argv[i]);
@@ -119,22 +125,11 @@ static int DoShellExec(char **argv)
     return ret;
 }
 
-static void ShellSigChildHook(int sig)
-{
-    (void)sig;
-
-    while (waitpid(-1, NULL, WNOHANG) > 0) {
-        continue;
-    }
-}
-
 int main(int argc, char **argv)
 {
     int ret = SH_NOK;
     ShellCB *shellCB = NULL;
 
-    (void)signal(SIGCHLD, ShellSigChildHook);
-
     if (argc > 1) {
         ret = DoShellExec(argv + 1);
         return ret;
@@ -144,7 +139,7 @@ int main(int argc, char **argv)
 
     shellCB = (ShellCB *)malloc(sizeof(ShellCB));
     if (shellCB == NULL) {
-        return SH_NOK;
+        goto ERR_OUT1;
     }
     ret = memset_s(shellCB, sizeof(ShellCB), 0, sizeof(ShellCB));
     if (ret != SH_OK) {
@@ -170,14 +165,7 @@ int main(int argc, char **argv)
     sem_init(&shellCB->shellSem, 0, 0);
 
     g_shellCB = shellCB;
-    ret = OsShellCreateTask(shellCB);
-    if (ret != SH_OK) {
-        ShellDeinit(shellCB);
-        g_shellCB = NULL;
-        return ret;
-    }
-
-    ShellEntry(shellCB);
+    return OsShellCreateTask(shellCB);
 
 ERR_OUT3:
     (void)pthread_mutex_destroy(&shellCB->historyMutex);

apps/shell/src/shmsg.c

@@ -351,7 +351,7 @@ char *GetCmdName(const char *cmdline, unsigned int len)
     return cmdName;
 }
 
-void ChildExec(const char *cmdName, char *const paramArray[], bool foreground)
+void ChildExec(const char *cmdName, char *const paramArray[])
 {
     int ret;
     pid_t gid;
@@ -367,12 +367,10 @@ void ChildExec(const char *cmdName, char *const paramArray[], bool foreground)
         exit(1);
     }
 
-    if (!foreground) {
-        ret = tcsetpgrp(STDIN_FILENO, gid);
-        if (ret != 0) {
-            printf("tcsetpgrp failed, errno %d\n", errno);
-            exit(1);
-        }
+    ret = tcsetpgrp(STDIN_FILENO, gid);
+    if (ret != 0) {
+        printf("tcsetpgrp failed, errno %d\n", errno);
+        exit(1);
     }
 
     ret = execve(cmdName, paramArray, NULL);
@@ -406,30 +404,20 @@ int CheckExit(const char *cmdName, const CmdParsed *cmdParsed)
     exit(ret);
 }
 
-static void DoCmdExec(const char *cmdName, const char *cmdline, unsigned int len, CmdParsed *cmdParsed)
+static void DoCmdExec(const char *cmdName, const char *cmdline, unsigned int len, const CmdParsed *cmdParsed)
 {
-    bool foreground = FALSE;
     int ret;
     pid_t forkPid;
 
     if (strncmp(cmdline, CMD_EXEC_COMMAND, CMD_EXEC_COMMAND_BYTES) == 0) {
-        if ((cmdParsed->paramCnt > 1) && (strcmp(cmdParsed->paramArray[cmdParsed->paramCnt - 1], "&") == 0)) {
-            free(cmdParsed->paramArray[cmdParsed->paramCnt - 1]);
-            cmdParsed->paramArray[cmdParsed->paramCnt - 1] = NULL;
-            cmdParsed->paramCnt--;
-            foreground = TRUE;
-        }
-
         forkPid = fork();
         if (forkPid < 0) {
-            printf("Failed to fork from shell\n");
+            printf("Faild to fork from shell\n");
             return;
         } else if (forkPid == 0) {
-            ChildExec(cmdParsed->paramArray[0], cmdParsed->paramArray, foreground);
+            ChildExec(cmdParsed->paramArray[0], cmdParsed->paramArray);
         } else {
-            if (!foreground) {
-                (void)waitpid(forkPid, 0, 0);
-            }
+            waitpid(forkPid, 0, 0);
             ret = tcsetpgrp(STDIN_FILENO, getpid());
             if (ret != 0) {
                 printf("tcsetpgrp failed, errno %d\n", errno);
@@ -579,10 +567,20 @@ static void ExecCmdline(const char *cmdline)
     free(output);
 }
 
+void RecycleZombieChild(void)
+{
+    while (waitpid(-1, NULL, WNOHANG) > 0) {
+        continue;
+    }
+}
+
 static void ShellCmdProcess(ShellCB *shellCB)
 {
+    char *buf = NULL;
     while (1) {
-        char *buf = GetCmdline(shellCB);
+        /* recycle zombine child process */
+        RecycleZombieChild();
+        buf = GetCmdline(shellCB);
         if (buf == NULL) {
             break;
         }
@@ -656,19 +654,25 @@ static int ShellKernelReg(unsigned int shellHandle)
     return ioctl(STDIN_FILENO, CONSOLE_CONTROL_REG_USERTASK, shellHandle);
 }
 
-void ShellEntry(ShellCB *shellCB)
+void *ShellEntry(void *argv)
 {
     char ch;
     int ret;
     int n;
     pid_t tid = syscall(__NR_gettid);
+    ShellCB *shellCB = (ShellCB *)argv;
 
     if (shellCB == NULL) {
-        return;
+        return NULL;
     }
 
     (void)memset_s(shellCB->shellBuf, SHOW_MAX_LEN, 0, SHOW_MAX_LEN);
 
+    ret = prctl(PR_SET_NAME, "ShellEntry");
+    if (ret != SH_OK) {
+        return NULL;
+    }
+
     ret = ShellKernelReg((int)tid);
     if (ret != 0) {
         printf("another shell is already running!\n");
@@ -681,5 +685,32 @@ void ShellEntry(ShellCB *shellCB)
             ShellCmdLineParse(ch, (OutputFunc)printf, shellCB);
         }
     }
-    return;
+    return NULL;
 }
+
+int ShellEntryInit(ShellCB *shellCB)
+{
+    int ret;
+    size_t stackSize = SHELL_ENTRY_STACKSIZE;
+    void *arg = NULL;
+    pthread_attr_t attr;
+
+    if (shellCB == NULL) {
+        return SH_NOK;
+    }
+
+    ret = pthread_attr_init(&attr);
+    if (ret != SH_OK) {
+        return SH_NOK;
+    }
+
+    pthread_attr_setstacksize(&attr, stackSize);
+    arg = (void *)shellCB;
+    ret = pthread_create(&shellCB->shellEntryHandle, &attr, &ShellEntry, arg);
+    if (ret != SH_OK) {
+        return SH_NOK;
+    }
+
+    return ret;
+}
+

apps/tftp/src/tftpc.c

@@ -500,7 +500,7 @@ static void lwip_tftp_send_error(s32_t iSockNum, u32_t ulError, const char *szEr
     }
 }
 
-/* INTERFACE to get a file using filename
+/* INTEFACE to get a file using filename
     ulHostAddr - IP address of Host
     szSrcFileName - Source file
     szDestDirPath - Destination file path
@@ -1419,7 +1419,7 @@ err_handler:
 }
 
 #ifdef TFTP_TO_RAWMEM
-/* INTERFACE to get a file using filename
+/* INTEFACE to get a file using filename
     ulHostAddr - IP address of Host
     szSrcFileName - Source file
     szDestMemAddr - The target memory address in the client
@@ -1437,8 +1437,10 @@ u32_t lwip_tftp_get_file_by_filename_to_rawmem(u32_t ulHostAddr,
 {
     s32_t iSockNum = TFTP_NULL_INT32;
     u32_t ulSrcStrLen;
+    u32_t lDestStrLen;
     u32_t ulSize;
     u32_t ulRecvSize = TFTP_NULL_UINT32;
+    s32_t iErrCode;
     u32_t ulErrCode;
     u16_t usReadReq;
     u16_t usTempServPort;

apps/toybox/BUILD.gn

@@ -51,7 +51,7 @@ build_ext_component("build_toybox") {
     ":copy_toybox_config",
     ":copy_toybox_src",
   ]
-  deps += [ "//third_party/musl:sysroot_lite" ]
+  deps += [ "//prebuilts/lite/sysroot" ]
   exec_path = rebase_path("$target_out_dir/toybox_build")
 
   cflags = [

apps/trace/src/trace.c

@@ -70,7 +70,7 @@ static void TraceRead(int fd, size_t size)
 {
     ssize_t i;
     ssize_t len;
-    if (size == 0) {
+    if (size <= 0) {
         return;
     }
 

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-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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 sp, UINTPTR parentTopOfStask, UINT32 parentStackSize);
+extern VOID OsUserCloneParentStack(VOID *childStack, 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);

arch/arm/arm/src/include/los_hwi_pri.h

@@ -55,8 +55,8 @@ extern "C" {
 #define HWI_IS_REGISTED(num)             ((&g_hwiForm[num])->pstNext != NULL)
 #endif
 extern VOID OsHwiInit(VOID);
-extern VOID OsIncHwiFormCnt(UINT16 cpuid, UINT32 index);
-extern UINT32 OsGetHwiFormCnt(UINT16 cpuid, UINT32 index);
+extern VOID OsIncHwiFormCnt(UINT32 index);
+extern UINT32 OsGetHwiFormCnt(UINT32 index);
 extern CHAR *OsGetHwiFormName(UINT32 index);
 extern VOID OsInterrupt(UINT32 intNum);
 extern VOID OsSyscallHandleInit(VOID);

arch/arm/arm/src/los_exc.c

@@ -74,7 +74,7 @@
 
 STATIC UINTPTR g_minAddr;
 STATIC UINTPTR g_maxAddr;
-STATIC UINT32 g_currHandleExcCpuid = INVALID_CPUID;
+STATIC UINT32 g_currHandleExcCpuID = INVALID_CPUID;
 VOID OsExcHook(UINT32 excType, ExcContext *excBufAddr, UINT32 far, UINT32 fsr);
 UINT32 g_curNestCount[LOSCFG_KERNEL_CORE_NUM] = { 0 };
 BOOL g_excFromUserMode[LOSCFG_KERNEL_CORE_NUM];
@@ -88,7 +88,6 @@ STATIC UINT32 g_nextExcWaitCpu = INVALID_CPUID;
 #define OS_MAX_BACKTRACE    15U
 #define DUMPSIZE            128U
 #define DUMPREGS            12U
-#define COM_REGS            4U
 #define INSTR_SET_MASK      0x01000020U
 #define THUMB_INSTR_LEN     2U
 #define ARM_INSTR_LEN       4U
@@ -113,11 +112,11 @@ STATIC const StackInfo g_excStack[] = {
 UINT32 OsGetSystemStatus(VOID)
 {
     UINT32 flag;
-    UINT32 cpuid = g_currHandleExcCpuid;
+    UINT32 cpuID = g_currHandleExcCpuID;
 
-    if (cpuid == INVALID_CPUID) {
+    if (cpuID == INVALID_CPUID) {
         flag = OS_SYSTEM_NORMAL;
-    } else if (cpuid == ArchCurrCpuid()) {
+    } else if (cpuID == ArchCurrCpuid()) {
         flag = OS_SYSTEM_EXC_CURR_CPU;
     } else {
         flag = OS_SYSTEM_EXC_OTHER_CPU;
@@ -517,22 +516,13 @@ VOID OsDumpContextMem(const ExcContext *excBufAddr)
         return;
     }
 
-    for (excReg = &(excBufAddr->R0); count < COM_REGS; excReg++, count++) {
+    for (excReg = &(excBufAddr->R0); count <= DUMPREGS; excReg++, count++) {
         if (IS_VALID_ADDR(*excReg)) {
             PrintExcInfo("\ndump mem around R%u:%p", count, (*excReg));
             OsDumpMemByte(DUMPSIZE, ((*excReg) - (DUMPSIZE >> 1)));
         }
     }
-    for (excReg = &(excBufAddr->R4); count < DUMPREGS; excReg++, count++) {
-        if (IS_VALID_ADDR(*excReg)) {
-            PrintExcInfo("\ndump mem around R%u:%p", count, (*excReg));
-            OsDumpMemByte(DUMPSIZE, ((*excReg) - (DUMPSIZE >> 1)));
-        }
-    }
-    if (IS_VALID_ADDR(excBufAddr->R12)) {
-        PrintExcInfo("\ndump mem around R12:%p", excBufAddr->R12);
-        OsDumpMemByte(DUMPSIZE, (excBufAddr->R12 - (DUMPSIZE >> 1)));
-    }
+
     if (IS_VALID_ADDR(excBufAddr->SP)) {
         PrintExcInfo("\ndump mem around SP:%p", excBufAddr->SP);
         OsDumpMemByte(DUMPSIZE, (excBufAddr->SP - (DUMPSIZE >> 1)));
@@ -541,11 +531,11 @@ VOID OsDumpContextMem(const ExcContext *excBufAddr)
 
 STATIC VOID OsExcRestore(VOID)
 {
-    UINT32 currCpuid = ArchCurrCpuid();
+    UINT32 currCpuID = ArchCurrCpuid();
 
-    g_excFromUserMode[currCpuid] = FALSE;
-    g_intCount[currCpuid] = 0;
-    g_curNestCount[currCpuid] = 0;
+    g_excFromUserMode[currCpuID] = FALSE;
+    g_intCount[currCpuID] = 0;
+    g_curNestCount[currCpuID] = 0;
 #ifdef LOSCFG_KERNEL_SMP
     OsCpuStatusSet(CPU_RUNNING);
 #endif
@@ -566,15 +556,15 @@ STATIC VOID OsUserExcHandle(ExcContext *excBufAddr)
 #ifdef LOSCFG_KERNEL_SMP
     LOS_SpinLock(&g_excSerializerSpin);
     if (g_nextExcWaitCpu != INVALID_CPUID) {
-        g_currHandleExcCpuid = g_nextExcWaitCpu;
+        g_currHandleExcCpuID = g_nextExcWaitCpu;
         g_nextExcWaitCpu = INVALID_CPUID;
     } else {
-        g_currHandleExcCpuid = INVALID_CPUID;
+        g_currHandleExcCpuID = INVALID_CPUID;
     }
     g_currHandleExcPID = OS_INVALID_VALUE;
     LOS_SpinUnlock(&g_excSerializerSpin);
 #else
-    g_currHandleExcCpuid = INVALID_CPUID;
+    g_currHandleExcCpuID = INVALID_CPUID;
 #endif
 
 #ifdef LOSCFG_KERNEL_SMP
@@ -655,7 +645,6 @@ STATIC INLINE BOOL FindSuitableStack(UINTPTR regFP, UINTPTR *start, UINTPTR *end
     const StackInfo *stack = NULL;
     vaddr_t kvaddr;
 
-#ifdef LOSCFG_KERNEL_VM
     if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {
         taskCB = OsCurrTaskGet();
         stackStart = taskCB->userMapBase;
@@ -666,7 +655,6 @@ STATIC INLINE BOOL FindSuitableStack(UINTPTR regFP, UINTPTR *start, UINTPTR *end
         }
         return found;
     }
-#endif
 
     /* Search in the task stacks */
     for (index = 0; index < g_taskMaxNum; index++) {
@@ -991,14 +979,14 @@ VOID OsDataAbortExcHandleEntry(ExcContext *excBufAddr)
 #define EXC_WAIT_INTER 50U
 #define EXC_WAIT_TIME  2000U
 
-STATIC VOID WaitAllCpuStop(UINT32 cpuid)
+STATIC VOID WaitAllCpuStop(UINT32 cpuID)
 {
     UINT32 i;
     UINT32 time = 0;
 
     while (time < EXC_WAIT_TIME) {
         for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
-            if ((i != cpuid) && !OsCpuStatusIsHalt(i)) {
+            if ((i != cpuID) && !OsCpuStatusIsHalt(i)) {
                 LOS_Mdelay(EXC_WAIT_INTER);
                 time += EXC_WAIT_INTER;
                 break;
@@ -1012,19 +1000,19 @@ STATIC VOID WaitAllCpuStop(UINT32 cpuid)
     return;
 }
 
-STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuid)
+STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuID)
 {
     while (1) {
         LOS_SpinLock(&g_excSerializerSpin);
-        if ((g_currHandleExcCpuid == INVALID_CPUID) || (g_currHandleExcCpuid == currCpuid)) {
-            g_currHandleExcCpuid = currCpuid;
+        if ((g_currHandleExcCpuID == INVALID_CPUID) || (g_currHandleExcCpuID == currCpuID)) {
+            g_currHandleExcCpuID = currCpuID;
             g_currHandleExcPID = OsCurrProcessGet()->processID;
             LOS_SpinUnlock(&g_excSerializerSpin);
             break;
         }
 
         if (g_nextExcWaitCpu == INVALID_CPUID) {
-            g_nextExcWaitCpu = currCpuid;
+            g_nextExcWaitCpu = currCpuID;
         }
         LOS_SpinUnlock(&g_excSerializerSpin);
         LOS_Mdelay(EXC_WAIT_INTER);
@@ -1033,7 +1021,7 @@ STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuid)
 
 STATIC VOID OsCheckAllCpuStatus(VOID)
 {
-    UINT32 currCpuid = ArchCurrCpuid();
+    UINT32 currCpuID = ArchCurrCpuid();
     UINT32 ret, target;
 
     OsCpuStatusSet(CPU_EXC);
@@ -1041,17 +1029,17 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
 
     LOS_SpinLock(&g_excSerializerSpin);
     /* Only the current CPU anomaly */
-    if (g_currHandleExcCpuid == INVALID_CPUID) {
-        g_currHandleExcCpuid = currCpuid;
+    if (g_currHandleExcCpuID == INVALID_CPUID) {
+        g_currHandleExcCpuID = currCpuID;
         g_currHandleExcPID = OsCurrProcessGet()->processID;
         LOS_SpinUnlock(&g_excSerializerSpin);
 #ifndef LOSCFG_SAVE_EXCINFO
-        if (g_excFromUserMode[currCpuid] == FALSE) {
-            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
+        if (g_excFromUserMode[currCpuID] == FALSE) {
+            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuID));
             HalIrqSendIpi(target, LOS_MP_IPI_HALT);
         }
 #endif
-    } else if (g_excFromUserMode[currCpuid] == TRUE) {
+    } else if (g_excFromUserMode[currCpuID] == TRUE) {
         /* Both cores raise exceptions, and the current core is a user-mode exception.
          * Both cores are abnormal and come from the same process
          */
@@ -1063,12 +1051,12 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
         }
         LOS_SpinUnlock(&g_excSerializerSpin);
 
-        OsWaitOtherCoresHandleExcEnd(currCpuid);
+        OsWaitOtherCoresHandleExcEnd(currCpuID);
     } else {
-        if ((g_currHandleExcCpuid < LOSCFG_KERNEL_CORE_NUM) && (g_excFromUserMode[g_currHandleExcCpuid] == TRUE)) {
-            g_currHandleExcCpuid = currCpuid;
+        if ((g_currHandleExcCpuID < LOSCFG_KERNEL_CORE_NUM) && (g_excFromUserMode[g_currHandleExcCpuID] == TRUE)) {
+            g_currHandleExcCpuID = currCpuID;
             LOS_SpinUnlock(&g_excSerializerSpin);
-            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
+            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuID));
             HalIrqSendIpi(target, LOS_MP_IPI_HALT);
         } else {
             LOS_SpinUnlock(&g_excSerializerSpin);
@@ -1078,7 +1066,7 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
 #ifndef LOSCFG_SAVE_EXCINFO
     /* use halt ipi to stop other active cores */
     if (g_excFromUserMode[ArchCurrCpuid()] == FALSE) {
-        WaitAllCpuStop(currCpuid);
+        WaitAllCpuStop(currCpuID);
     }
 #endif
 }
@@ -1089,7 +1077,7 @@ STATIC VOID OsCheckCpuStatus(VOID)
 #ifdef LOSCFG_KERNEL_SMP
     OsCheckAllCpuStatus();
 #else
-    g_currHandleExcCpuid = ArchCurrCpuid();
+    g_currHandleExcCpuID = ArchCurrCpuid();
 #endif
 }
 

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-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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;
 }
 
-VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfStack, UINT32 parentStackSize)
+LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTopOfStack, UINT32 parentStackSize)
 {
     LosTaskCB *task = OsCurrTaskGet();
     sig_cb *sigcb = &task->sig;
@@ -117,10 +117,6 @@ VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfSta
 
     (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)

arch/arm/arm/src/los_hwi.c

@@ -46,11 +46,16 @@ LITE_OS_SEC_BSS  SPIN_LOCK_INIT(g_hwiSpin);
 size_t g_intCount[LOSCFG_KERNEL_CORE_NUM] = {0};
 HwiHandleForm g_hwiForm[OS_HWI_MAX_NUM];
 STATIC CHAR *g_hwiFormName[OS_HWI_MAX_NUM] = {0};
-STATIC UINT32 g_hwiFormCnt[LOSCFG_KERNEL_CORE_NUM][OS_HWI_MAX_NUM] = {0};
+STATIC UINT32 g_hwiFormCnt[OS_HWI_MAX_NUM] = {0};
 
-UINT32 OsGetHwiFormCnt(UINT16 cpuid, UINT32 index)
+VOID OsIncHwiFormCnt(UINT32 index)
 {
-    return g_hwiFormCnt[cpuid][index];
+    g_hwiFormCnt[index]++;
+}
+
+UINT32 OsGetHwiFormCnt(UINT32 index)
+{
+    return g_hwiFormCnt[index];
 }
 
 CHAR *OsGetHwiFormName(UINT32 index)
@@ -69,17 +74,16 @@ VOID OsInterrupt(UINT32 intNum)
 {
     HwiHandleForm *hwiForm = NULL;
     UINT32 *intCnt = NULL;
-    UINT16 cpuid = ArchCurrCpuid();
 
     /* Must keep the operation at the beginning of the interface */
-    intCnt = &g_intCount[cpuid];
+    intCnt = &g_intCount[ArchCurrCpuid()];
     *intCnt = *intCnt + 1;
 
-#ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqStart(cpuid);
-#endif
-
     OsSchedIrqStartTime();
+
+#ifdef LOSCFG_CPUP_INCLUDE_IRQ
+    OsCpupIrqStart();
+#endif
     OsHookCall(LOS_HOOK_TYPE_ISR_ENTER, intNum);
     hwiForm = (&g_hwiForm[intNum]);
 #ifndef LOSCFG_NO_SHARED_IRQ
@@ -101,14 +105,14 @@ VOID OsInterrupt(UINT32 intNum)
 #ifndef LOSCFG_NO_SHARED_IRQ
     }
 #endif
-    ++g_hwiFormCnt[cpuid][intNum];
+    ++g_hwiFormCnt[intNum];
 
     OsHookCall(LOS_HOOK_TYPE_ISR_EXIT, intNum);
-    OsSchedIrqUsedTimeUpdate();
-
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqEnd(cpuid, intNum);
+    OsCpupIrqEnd(intNum);
 #endif
+    OsSchedIrqUpdateUsedTime();
+
     /* Must keep the operation at the end of the interface */
     *intCnt = *intCnt - 1;
 }

arch/arm/arm/src/startup/reset_vector_mp.S

@@ -121,9 +121,8 @@ reset_vector:
     mcr     p15, 0, r0, c13, c0, 4
     /* do some early cpu setup: i/d cache disable, mmu disabled */
     mrc     p15, 0, r0, c1, c0, 0
-    bic     r0, #(1 << 12)          /* i cache */
-    bic     r0, #(1 << 2)           /* d cache */
-    bic     r0, #(1 << 0)           /* mmu */
+    bic     r0, #(1<<12)
+    bic     r0, #(1<<2 | 1<<0)
     mcr     p15, 0, r0, c1, c0, 0
 
     /* enable fpu+neon */
@@ -276,18 +275,18 @@ mmu_setup:
     mov     r12, #0x7                           /* 0b0111 */
     mcr     p15, 0, r12, c3, c0, 0              /* Set DACR with 0b0111, client and manager domian */
     isb
-    mrc    p15, 0, r12, c1, c0, 1               /* ACTLR, Auxiliary Control Register */
+    mrc    p15, 0, r12, c1, c0, 1               /* ACTLR, Auxlliary Control Register */
     orr    r12, r12, #(1 << 6)                  /* SMP, Enables coherent requests to the processor. */
     orr    r12, r12, #(1 << 2)                  /* Enable D-side prefetch */
     orr    r12, r12, #(1 << 11)                 /* Global BP Enable bit */
-    mcr    p15, 0, r12, c1, c0, 1               /* ACTLR, Auxiliary Control Register */
+    mcr    p15, 0, r12, c1, c0, 1               /* ACTLR, Auxlliary Control Register */
     dsb
     mrc     p15, 0, r12, c1, c0, 0
-    bic     r12, #(1 << 29 | 1 << 28)           /* Disable TRE/AFE */
-    orr     r12, #(1 << 0)                      /* mmu enable */
+    bic     r12, #(1 << 29 | 1 << 28)
+    orr     r12, #(1 << 0)
     bic     r12, #(1 << 1)
-    orr     r12, #(1 << 2)                     /* D cache enable */
-    orr     r12, #(1 << 12)                    /* I cache enable */
+    orr     r12, #(1 << 2)
+    orr     r12, #(1 << 12)
     mcr     p15, 0, r12, c1, c0, 0              /* Set SCTLR with r12: Turn on the MMU, I/D cache Disable TRE/AFE */
     isb
     ldr     pc,  =1f                            /* Convert to VA */

arch/arm/arm/src/startup/reset_vector_up.S

@@ -101,9 +101,8 @@ __exception_handlers:
 reset_vector:
     /* do some early cpu setup: i/d cache disable, mmu disabled */
     mrc     p15, 0, r0, c1, c0, 0
-    bic     r0, #(1 << 12)          /* i cache */
-    bic     r0, #(1 << 2)           /* d cache */
-    bic     r0, #(1 << 0)           /* mmu */
+    bic     r0, #(1<<12)
+    bic     r0, #(1<<2 | 1<<0)
     mcr     p15, 0, r0, c1, c0, 0
 
     /* enable fpu+neon */
@@ -270,11 +269,11 @@ mmu_setup:
     isb
 
     mrc     p15, 0, r12, c1, c0, 0
-    bic     r12, #(1 << 29 | 1 << 28)           /* Disable TRE/AFE */
-    orr     r12, #(1 << 0)                      /* mmu enable */
+    bic     r12, #(1 << 29 | 1 << 28)
+    orr     r12, #(1 << 0)
     bic     r12, #(1 << 1)
-    orr     r12, #(1 << 2)                      /* D cache enable */
-    orr     r12, #(1 << 12)                     /* I cache enable */
+    orr     r12, #(1 << 2)
+    orr     r12, #(1 << 12)
     mcr     p15, 0, r12, c1, c0, 0              /* Set SCTLR with r12: Turn on the MMU, I/D cache Disable TRE/AFE */
     isb
 

arch/arm/arm/src/strncpy_from_user.c

@@ -46,7 +46,7 @@ INT32 LOS_StrncpyFromUser(CHAR *dst, const CHAR *src, INT32 count)
     }
 
     maxCount = (LOS_IsUserAddressRange((VADDR_T)(UINTPTR)src, (size_t)count)) ? \
-                count : (INT32)(USER_ASPACE_TOP_MAX - (UINTPTR)src);
+                count : (USER_ASPACE_TOP_MAX - (UINTPTR)src);
 
     for (i = 0; i < maxCount; ++i) {
         if (LOS_GetUser(&character, src + offset) != LOS_OK) {

bsd/dev/usb/Makefile

@@ -28,7 +28,7 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 include $(LITEOSTOPDIR)/config.mk
-include $(LITEOSTOPDIR)/../../drivers/hdf_core/adapter/khdf/liteos/lite.mk
+include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk
 
 MODULE_NAME := usb_base
 
@@ -122,13 +122,13 @@ LOCAL_SRCS += $(STORAGE_SRC)/umass.c
 endif
 
 ifeq ($(LOSCFG_DRIVERS_USB_HID_CLASS)_$(LOSCFG_DRIVERS_HDF_INPUT), y_y)
-LOCAL_FLAGS += -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/model/input/driver \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/include/core \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/core/common/include/host \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/utils \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/osal \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/ability/sbuf/include \
-               -I$(LITEOSTOPDIR)/../../drivers/hdf_core/framework/include/osal \
+LOCAL_FLAGS += -I$(LITEOSTOPDIR)/../../drivers/framework/model/input/driver \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/include/core \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/core/common/include/host \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/utils \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/osal \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/ability/sbuf/include \
+               -I$(LITEOSTOPDIR)/../../drivers/framework/include/osal \
                -I$(LITEOSTOPDIR)/../../third_party/FreeBSD/sys/dev/evdev
 
 LOCAL_SRCS += $(INPUT_SRC)/uhid.c  \

compat/posix/include/mqueue.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,10 +74,6 @@ 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;

compat/posix/src/misc.c

@@ -53,27 +53,21 @@
 
 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), 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__);
+    (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__);
     if (ret < 0) {
         return -EIO;
     }
 
-    const char *cpuInfo = LOS_CpuInfo();
+    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);
@@ -82,7 +76,6 @@ int uname(struct utsname *name)
     }
 
     name->domainname[0] = '\0';
-#endif
     return 0;
 }
 

compat/posix/src/mqueue.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,19 +44,16 @@
 
 #define FNONBLOCK   O_NONBLOCK
 
-#ifndef LOSCFG_IPC_CONTAINER
+#ifndef MAX_MQ_FD
+#define MAX_MQ_FD CONFIG_NQUEUE_DESCRIPTORS
+#endif
+
 /* 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)
 {
@@ -99,12 +96,12 @@ STATIC INLINE struct mqarray *GetMqueueCBByName(const CHAR *name)
     UINT32 mylen = strlen(name);
 
     for (index = 0; index < LOSCFG_BASE_IPC_QUEUE_LIMIT; index++) {
-        if ((IPC_QUEUE_TABLE[index].mq_name == NULL) || (strlen(IPC_QUEUE_TABLE[index].mq_name) != mylen)) {
+        if ((g_queueTable[index].mq_name == NULL) || (strlen(g_queueTable[index].mq_name) != mylen)) {
             continue;
         }
 
-        if (strncmp(name, (const CHAR *)(IPC_QUEUE_TABLE[index].mq_name), mylen) == 0) {
-            return &(IPC_QUEUE_TABLE[index]);
+        if (strncmp(name, (const CHAR *)(g_queueTable[index].mq_name), mylen) == 0) {
+            return &(g_queueTable[index]);
         }
     }
     return NULL;
@@ -173,8 +170,8 @@ STATIC struct mqpersonal *DoMqueueCreate(const struct mq_attr *attr, const CHAR
         goto ERROUT;
     }
 
-    if (IPC_QUEUE_TABLE[GET_QUEUE_INDEX(mqueueID)].mqcb == NULL) {
-        mqueueCB = &(IPC_QUEUE_TABLE[GET_QUEUE_INDEX(mqueueID)]);
+    if (g_queueTable[GET_QUEUE_INDEX(mqueueID)].mqcb == NULL) {
+        mqueueCB = &(g_queueTable[GET_QUEUE_INDEX(mqueueID)]);
         mqueueCB->mq_id = mqueueID;
     }
 
@@ -300,7 +297,7 @@ STATIC struct mqpersonal *MqGetPrivDataBuff(mqd_t personal)
         errno = EBADF;
         return NULL;
     }
-    return IPC_QUEUE_MQ_PRIV_BUF[id];
+    return g_mqPrivBuf[id];
 }
 
 /**
@@ -314,13 +311,13 @@ STATIC struct mqpersonal *MqGetPrivDataBuff(mqd_t personal)
 STATIC INT32 MqAllocSysFd(int maxfdp, struct mqpersonal *privateMqPersonal)
 {
     INT32 i;
-    fd_set *fdset = &IPC_QUEUE_FD_SET;
+    fd_set *fdset = &g_queueFdSet;
     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 (!IPC_QUEUE_MQ_PRIV_BUF[i]) {
-                IPC_QUEUE_MQ_PRIV_BUF[i] = privateMqPersonal;
+            if (!g_mqPrivBuf[i]) {
+                g_mqPrivBuf[i] = privateMqPersonal;
                 return i + MQUEUE_FD_OFFSET;
             }
         }
@@ -331,10 +328,10 @@ STATIC INT32 MqAllocSysFd(int maxfdp, struct mqpersonal *privateMqPersonal)
 STATIC VOID MqFreeSysFd(mqd_t personal)
 {
     INT32 sysFd = (INT32)personal;
-    fd_set *fdset = &IPC_QUEUE_FD_SET;
+    fd_set *fdset = &g_queueFdSet;
     if (fdset && FD_ISSET(sysFd, fdset)) {
         FD_CLR(sysFd, fdset);
-        IPC_QUEUE_MQ_PRIV_BUF[sysFd - MQUEUE_FD_OFFSET] = NULL;
+        g_mqPrivBuf[sysFd - MQUEUE_FD_OFFSET] = NULL;
     }
 }
 
@@ -344,7 +341,7 @@ void MqueueRefer(int sysFd)
     struct mqarray *mqueueCB = NULL;
     struct mqpersonal *privateMqPersonal = NULL;
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     /* Get the personal sysFd and reset personal fd -1 */
     privateMqPersonal = MqGetPrivDataBuff((mqd_t)sysFd);
     if (privateMqPersonal == NULL) {
@@ -357,7 +354,7 @@ void MqueueRefer(int sysFd)
 
     privateMqPersonal->mq_refcount++;
 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return;
 }
 
@@ -501,7 +498,7 @@ mqd_t mq_open(const char *mqName, int openFlag, ...)
         return (mqd_t)-1;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     mqueueCB = GetMqueueCBByName(mqName);
     if ((UINT32)openFlag & (UINT32)O_CREAT) {
         if (mqueueCB != NULL) {
@@ -546,7 +543,7 @@ mqd_t mq_open(const char *mqName, int openFlag, ...)
         mqFd = (mqd_t)sysFd;
     }
 OUT:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return mqFd;
 }
 
@@ -555,7 +552,7 @@ int mq_close(mqd_t personal)
     INT32 ret = -1;
     struct mqpersonal *privateMqPersonal = NULL;
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
 
     /* Get the personal sysFd and reset personal fd -1 */
     privateMqPersonal = MqGetPrivDataBuff(personal);
@@ -580,7 +577,7 @@ int mq_close(mqd_t personal)
     MqFreeSysFd(personal);
 
 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return ret;
 }
 
@@ -599,10 +596,10 @@ int OsMqGetAttr(mqd_t personal, struct mq_attr *mqAttr)
         return -1;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     if (privateMqPersonal->mq_status != MQ_USE_MAGIC) {
         errno = EBADF;
-        (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+        (VOID)pthread_mutex_unlock(&g_mqueueMutex);
         return -1;
     }
 
@@ -611,7 +608,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(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return 0;
 }
 
@@ -629,10 +626,10 @@ int OsMqSetAttr(mqd_t personal, const struct mq_attr *mqSetAttr, struct mq_attr
         return -1;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     if (privateMqPersonal->mq_status != MQ_USE_MAGIC) {
         errno = EBADF;
-        (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+        (VOID)pthread_mutex_unlock(&g_mqueueMutex);
         return -1;
     }
 
@@ -644,7 +641,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(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return 0;
 }
 
@@ -665,7 +662,7 @@ int mq_unlink(const char *mqName)
         return -1;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     mqueueCB = GetMqueueCBByName(mqName);
     if (mqueueCB == NULL) {
         errno = ENOENT;
@@ -678,11 +675,11 @@ int mq_unlink(const char *mqName)
         ret = DoMqueueDelete(mqueueCB);
     }
 
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return ret;
 
 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return -1;
 }
 
@@ -770,7 +767,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(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     privateMqPersonal = MqGetPrivDataBuff(personal);
 
     OS_MQ_GOTO_ERROUT_UNLOCK_IF(privateMqPersonal == NULL || privateMqPersonal->mq_status != MQ_USE_MAGIC, EBADF);
@@ -784,7 +781,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(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
 
     if (LOS_ListEmpty(&mqueueCB->mqcb->readWriteList[OS_QUEUE_READ])) {
         MqSendNotify(mqueueCB);
@@ -796,7 +793,7 @@ int mq_timedsend(mqd_t personal, const char *msg, size_t msgLen, unsigned int ms
     }
     return 0;
 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
 ERROUT:
     return -1;
 }
@@ -818,7 +815,7 @@ ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *
         *msgPrio = 0;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     privateMqPersonal = MqGetPrivDataBuff(personal);
     if (privateMqPersonal == NULL || privateMqPersonal->mq_status != MQ_USE_MAGIC) {
         errno = EBADF;
@@ -842,7 +839,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(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
 
     err = LOS_QueueReadCopy(mqueueID, (VOID *)msg, &receiveLen, (UINT32)absTicks);
     if (map_errno(err) == ENOERR) {
@@ -852,7 +849,7 @@ ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *
     }
 
 ERROUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
 ERROUT:
     return -1;
 }
@@ -901,7 +898,7 @@ int OsMqNotify(mqd_t personal, const struct sigevent *sigev)
         goto ERROUT;
     }
 
-    (VOID)pthread_mutex_lock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_lock(&g_mqueueMutex);
     privateMqPersonal = MqGetPrivDataBuff(personal);
     if (privateMqPersonal == NULL) {
         goto OUT_UNLOCK;
@@ -939,10 +936,10 @@ int OsMqNotify(mqd_t personal, const struct sigevent *sigev)
         mqnotify->pid = LOS_GetCurrProcessID();
     }
 
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
     return 0;
 OUT_UNLOCK:
-    (VOID)pthread_mutex_unlock(&IPC_QUEUE_MUTEX);
+    (VOID)pthread_mutex_unlock(&g_mqueueMutex);
 ERROUT:
     return -1;
 }

compat/posix/src/pthread.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-2021 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:
@@ -158,7 +158,7 @@ STATIC VOID SetPthreadAttr(const _pthread_data *self, const pthread_attr_t *attr
     }
     if (outAttr->inheritsched == PTHREAD_INHERIT_SCHED) {
         if (self->task == NULL) {
-            outAttr->schedparam.sched_priority = LOS_TaskPriGet(OsCurrTaskGet()->taskID);
+            outAttr->schedparam.sched_priority = ((LosTaskCB *)(OsCurrTaskGet()))->priority;
         } else {
             outAttr->schedpolicy = self->attr.schedpolicy;
             outAttr->schedparam  = self->attr.schedparam;
@@ -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 = (UINTPTR)OsGetKernelInitProcess();
+        taskInitParam.processID = OsGetKernelInitProcessID();
     } else {
-        taskInitParam.processID = (UINTPTR)OsCurrProcessGet();
+        taskInitParam.processID = OsCurrProcessGet()->processID;
     }
     if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {
         taskInitParam.uwResved = LOS_TASK_STATUS_DETACHED;

compat/posix/src/time.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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:
@@ -71,7 +71,7 @@
 
 #ifdef LOSCFG_AARCH64
 /*
- * This two structures originally didn't exit,
+ * This two structures originally did't exit,
  * they added by liteos to support 64bit interfaces on 32bit platform,
  * in 64bit platform, timeval64 define to timeval which is platform adaptive.
  */
@@ -117,7 +117,7 @@ STATIC INLINE BOOL ValidTimerID(UINT16 swtmrID)
     }
 
     /* check owner of this timer */
-    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != (UINTPTR)OsCurrProcessGet()) {
+    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != LOS_GetCurrProcessID()) {
         return FALSE;
     }
 
@@ -387,16 +387,9 @@ int gettimeofday64(struct timeval64 *tv, struct timezone *tz)
 }
 #endif
 
-#ifdef LOSCFG_LIBC_NEWLIB
-int gettimeofday(struct timeval *tv, void *_tz)
-#else
 int gettimeofday(struct timeval *tv, struct timezone *tz)
-#endif
 {
     struct timeval64 stTimeVal64 = {0};
-#ifdef LOSCFG_LIBC_NEWLIB
-    struct timezone *tz = (struct timezone *)_tz;
-#endif
 
     if (tv == NULL) {
         TIME_RETURN(EINVAL);
@@ -478,13 +471,14 @@ static int PthreadGetCputime(clockid_t clockID, struct timespec *ats)
     uint64_t runtime;
     UINT32 intSave;
     UINT32 tid = GetTidFromClockID(clockID);
+
     if (OS_TID_CHECK_INVALID(tid)) {
         return -EINVAL;
     }
 
     LosTaskCB *task = OsGetTaskCB(tid);
 
-    if (OsCurrTaskGet()->processCB != task->processCB) {
+    if (OsCurrTaskGet()->processID != task->processID) {
         return -EINVAL;
     }
 
@@ -599,22 +593,13 @@ 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;
@@ -648,7 +633,7 @@ int clock_gettime(clockid_t clockID, struct timespec *tp)
 
     return 0;
 
-ERROUT:
+    ERROUT:
     TIME_RETURN(EINVAL);
 }
 
@@ -733,7 +718,6 @@ typedef struct {
 
 static VOID SwtmrProc(UINTPTR tmrArg)
 {
-#ifdef LOSCFG_KERNEL_VM
     INT32 sig, ret;
     UINT32 intSave;
     pid_t pid;
@@ -757,7 +741,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->processCB);
+        ret = OsUserProcessOperatePermissionsCheck(stcb, stcb->processID);
         OS_GOTO_EXIT_IF(ret != LOS_OK, -ret);
 
         /* Dispatch the signal to thread, bypassing normal task group thread
@@ -777,47 +761,9 @@ static VOID SwtmrProc(UINTPTR tmrArg)
     return;
 EXIT:
     PRINT_ERR("Dispatch signals failed!, ret: %d\r\n", ret);
-#endif
     return;
 }
 
-int timer_create(clockid_t clockID, struct sigevent *restrict evp, timer_t *restrict timerID)
-{
-    UINT32 ret;
-    UINT16 swtmrID;
-#ifdef LOSCFG_SECURITY_VID
-    UINT16 vid;
-#endif
-
-    if (!timerID || (clockID != CLOCK_REALTIME) || !evp) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    if ((evp->sigev_notify != SIGEV_THREAD) || evp->sigev_notify_attributes) {
-        errno = ENOTSUP;
-        return -1;
-    }
-
-    ret = LOS_SwtmrCreate(1, LOS_SWTMR_MODE_ONCE, (SWTMR_PROC_FUNC)evp->sigev_notify_function,
-                          &swtmrID, (UINTPTR)evp->sigev_value.sival_ptr);
-    if (ret != LOS_OK) {
-        errno = (ret == LOS_ERRNO_SWTMR_MAXSIZE) ? EAGAIN : EINVAL;
-        return -1;
-    }
-
-#ifdef LOSCFG_SECURITY_VID
-    vid = AddNodeByRid(swtmrID);
-    if (vid == MAX_INVALID_TIMER_VID) {
-        (VOID)LOS_SwtmrDelete(swtmrID);
-        return -1;
-    }
-    swtmrID = vid;
-#endif
-    *timerID = (timer_t)(UINTPTR)swtmrID;
-    return 0;
-}
-
 int OsTimerCreate(clockid_t clockID, struct ksigevent *evp, timer_t *timerID)
 {
     UINT32 ret;
@@ -877,7 +823,6 @@ int timer_delete(timer_t timerID)
 {
     UINT16 swtmrID = (UINT16)(UINTPTR)timerID;
     VOID *arg = NULL;
-    UINTPTR swtmrProc;
 
 #ifdef LOSCFG_SECURITY_VID
     swtmrID = GetRidByVid(swtmrID);
@@ -887,11 +832,10 @@ int timer_delete(timer_t timerID)
     }
 
     arg = (VOID *)OS_SWT_FROM_SID(swtmrID)->uwArg;
-    swtmrProc = (UINTPTR)OS_SWT_FROM_SID(swtmrID)->pfnHandler;
     if (LOS_SwtmrDelete(swtmrID)) {
         goto ERROUT;
     }
-    if ((swtmrProc == (UINTPTR)SwtmrProc) && (arg != NULL)) {
+    if (arg != NULL) {
         free(arg);
     }
 
@@ -1035,11 +979,7 @@ STATIC INT32 DoNanoSleep(UINT64 nanoseconds)
     return -1;
 }
 
-#ifdef LOSCFG_LIBC_NEWLIB
-int usleep(unsigned long useconds)
-#else
 int usleep(unsigned useconds)
-#endif
 {
     return DoNanoSleep((UINT64)useconds * OS_SYS_NS_PER_US);
 }
@@ -1096,7 +1036,8 @@ clock_t times(struct tms *buf)
 int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue)
 {
     UINT32 intSave;
-    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
+    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
     timer_t timerID = 0;
     struct itimerspec spec;
     struct itimerspec ospec;
@@ -1149,7 +1090,8 @@ int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue
 
 int getitimer(int which, struct itimerval *value)
 {
-    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
+    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
     struct itimerspec spec = {};
 
     int ret = LOS_OK;

drivers/Kconfig

@@ -5,7 +5,7 @@ config DRIVERS
       Answer Y to enable LiteOS support driver.
 
 source "bsd/dev/usb/Kconfig"
-source "../../drivers/hdf_core/adapter/khdf/liteos/Kconfig"
+source "../../drivers/adapter/khdf/liteos/Kconfig"
 
 # Device driver Kconfig import
 source "$(DEVICE_PATH)/drivers/Kconfig"
@@ -17,4 +17,5 @@ source "drivers/char/video/Kconfig"
 source "drivers/char/trace/Kconfig"
 source "drivers/char/perf/Kconfig"
 
+source "../../drivers/liteos/tzdriver/Kconfig"
 source "../../drivers/liteos/hievent/Kconfig"

drivers/block/disk/include/disk.h

@@ -163,7 +163,7 @@ extern "C" {
 #define DISK_ATA_GET_MODEL      21  /* Get model name */
 #define DISK_ATA_GET_SN         22  /* Get serial number */
 
-#ifndef LOSCFG_FS_FAT_CACHE
+#ifdef LOSCFG_FS_FAT_CACHE
 #define DISK_DIRECT_BUFFER_SIZE 4   /* los_disk direct io buffer when bcache is off */
 #endif
 

drivers/block/disk/include/disk_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-2021 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:
@@ -42,7 +42,7 @@
 
 #ifdef __cplusplus
 #if __cplusplus
-extern "C" {
+extern "C"{
 #endif
 #endif /* __cplusplus */
 

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();
-        PRINT_ERR("disk_init : %s, failed to find the vnode, ERRNO=%d\n", diskName, ret);
+        ret = ENOENT;
         goto DISK_FIND_ERROR;
     }
     struct block_operations *bops2 = (struct block_operations *)((struct drv_data *)blkDriver->data)->ops;

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 (LOS_GetCurrProcessID() != OS_USER_ROOT_PROCESS_ID) {
+    if (OsGetUserInitProcessID() != LOS_GetCurrProcessID()) {
         PRINT_ERR("Permission denios!\n");
         return -EACCES;
     }

drivers/mtd/multi_partition/BUILD.gn

@@ -39,6 +39,10 @@ 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" ]
 }
 

drivers/mtd/multi_partition/Makefile

@@ -36,6 +36,10 @@ 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)

drivers/mtd/multi_partition/src/mtd_partition.c

@@ -39,6 +39,11 @@
 #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;
 
@@ -129,10 +134,17 @@ 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;
 }
@@ -146,7 +158,11 @@ 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;
     }

fs/fat/os_adapt/fatfs.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-2021 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:
@@ -343,8 +343,7 @@ static FRESULT init_cluster(DIR_FILE *pdfp, DIR *dp_new, FATFS *fs, int type, co
     return FR_OK;
 }
 
-static int fatfs_create_obj(struct Vnode *parent, const char *name, int mode, struct Vnode **vpp,
-                            BYTE type,  const char *target)
+static int fatfs_create_obj(struct Vnode *parent, const char *name, int mode, struct Vnode **vpp, BYTE type, const char *target)
 {
     struct Vnode *vp = NULL;
     FATFS *fs = (FATFS *)parent->originMount->data;
@@ -1409,7 +1408,7 @@ DWORD fattime_format(time_t time)
     ftime |= ((DWORD)((st.tm_year > YEAR_OFFSET) ? (st.tm_year - YEAR_OFFSET) : 0)) << FTIME_YEAR_OFFSET;
     ftime <<= FTIME_DATE_OFFSET;
 
-    ftime |= (DWORD)st.tm_sec / SEC_MULTIPLIER;
+    ftime = (DWORD)st.tm_sec / SEC_MULTIPLIER;
     ftime |= ((DWORD)st.tm_min) << FTIME_MIN_OFFSET;
     ftime |= ((DWORD)st.tm_hour) << FTIME_HR_OFFSET;
 
@@ -2167,7 +2166,7 @@ int fatfs_symlink(struct Vnode *parentVnode, struct Vnode **newVnode, const char
 ssize_t fatfs_readlink(struct Vnode *vnode, char *buffer, size_t bufLen)
 {
     int ret;
-    FRESULT res;
+    FRESULT res = FR_OK;
     DWORD clust;
     QWORD sect;
     DIR_FILE *dfp = (DIR_FILE *)(vnode->data);

fs/fat/os_adapt/fatfs.h

@@ -64,7 +64,7 @@ extern "C" {
 #define MBR_PRIMARY_PART_NUM 4
 #define JUMP_CODE "\xEB\xFE\x90"
 
-/* Partition type */
+/* Partiton type */
 #define FAT12                  0x01 /* FAT12 as primary partition in first physical 32MB */
 #define FAT16                  0x04 /* FAT16 with less than 65536 sectors(32MB) */
 #define EXTENDED_PARTITION_CHS  0x05

fs/fat/virpart/src/virpart.c

@@ -179,7 +179,7 @@ static INT FatfsDisablePart(void *handle)
  * Scan the FAT inside the boundary of CHILD FATFS limit, and update the free cluster and last cluster
  * for all CHILD FATFS.
  * Acceptable Return Value:
- * - FR_OK              : Successfully scanned the FAT and update field.
+ * - FR_OK              : Successfully scaned the FAT and update field.
  * Others Return Value:
  * - FR_INVAILD_FATFS   : The FATFS object has error or the info in it has been occuried
  * - FR_DENIED          : The virtual partition feature has been shut down by switcher

fs/fat/virpart/src/virpartff.c

@@ -373,7 +373,7 @@ static FRESULT FatfsCheckScanFatParam(FATFS *fs)
 * Scan the FAT inside the boundary of CHILD FATFS limit, and update the free cluster and last cluster
 *
 * Acceptable Return Value:
-* - FR_OK : Successfully scanned the FAT and update field.
+* - FR_OK : Successfully scaned the FAT and update field.
 *
 * Others Return Value:
 * - FR_INVAILD_FATFS   :   The FATFS object has error or the info in it has been occuried

fs/include/fs/fd_table.h

@@ -59,9 +59,6 @@ struct files_struct {
     spinlock_t workdir_lock;
     char workdir[PATH_MAX];
 #endif
-#ifdef LOSCFG_CHROOT
-    struct Vnode *rootVnode;
-#endif
 };
 
 typedef struct ProcessCB LosProcessCB;

fs/include/fs/fs_operation.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-2021 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:
@@ -244,9 +244,8 @@ extern int chattr(const char *pathname, struct IATTR *attr);
  *
  * @retval #0  On success.
  * @retval #-1 On failure with errno set.
- * @retval CONTINE_NUTTX_FCNTL doesn't support some cmds in VfsFcntl, needs to continue going through 
- * Nuttx vfs operation.</li>
- *     
+ * @retval CONTINE_NUTTX_FCNTL doesn't support some cmds in VfsFcntl, needs to continue going through Nuttx vfs operation.</li>
+ *
  * @par Dependency:
  * <ul><li>fs.h</li></ul>
  * @see None

fs/include/fs/mount.h

@@ -39,7 +39,6 @@
 #define MS_NOSYNC 2
 
 struct MountOps;
-struct fsmap_t;
 
 struct Mount {
     LIST_ENTRY mountList;              /* mount list */
@@ -50,7 +49,7 @@ struct Mount {
     LIST_HEAD vnodeList;               /* list of vnodes */
     int vnodeSize;                     /* size of vnode list */
     LIST_HEAD activeVnodeList;         /* list of active vnodes */
-    int activeVnodeSize;               /* size of active vnodes list */
+    int activeVnodeSize;               /* szie of active vnodes list */
     void *data;                        /* private data */
     uint32_t hashseed;                 /* Random seed for vfshash */
     unsigned long mountFlags;          /* Flags for mount */
@@ -70,11 +69,8 @@ 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);
-#ifdef LOSCFG_MNT_CONTAINER
-LIST_HEAD *GetMountCache(void);
-#endif
+struct Mount* MountAlloc(struct Vnode* vnode, struct MountOps* mop);
+LIST_HEAD* GetMountList(void);
 int foreach_mountpoint(foreach_mountpoint_t handler, void *arg);
 int ForceUmountDev(struct Vnode *dev);
 #endif

fs/jffs2/jffs2.patch

@@ -2311,7 +2311,7 @@ diff -Nupr old/fs/jffs2/erase.c new/fs/jffs2/erase.c
 diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 --- old/fs/jffs2/file.c	2022-05-09 17:22:53.000000000 +0800
 +++ new/fs/jffs2/file.c	2022-05-10 09:43:14.250000000 +0800
-@@ -9,335 +9,30 @@
+@@ -9,325 +9,34 @@
   * For licensing information, see the file 'LICENCE' in this directory.
   *
   */
@@ -2336,35 +2336,32 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -			loff_t pos, unsigned len, unsigned flags,
 -			struct page **pagep, void **fsdata);
 -static int jffs2_readpage (struct file *filp, struct page *pg);
+-
+-int jffs2_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
+-{
+-	struct inode *inode = filp->f_mapping->host;
+-	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
+-	int ret;
+-
+-	ret = file_write_and_wait_range(filp, start, end);
+-	if (ret)
+-		return ret;
+ 
+-	inode_lock(inode);
+-	/* Trigger GC to flush any pending writes for this inode */
+-	jffs2_flush_wbuf_gc(c, inode->i_ino);
+-	inode_unlock(inode);
 +static unsigned char gc_buffer[PAGE_SIZE];	//avoids malloc when user may be under memory pressure
  
--int jffs2_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
+-	return 0;
+-}
+ 
+-const struct file_operations jffs2_file_operations =
 +unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 +				   struct jffs2_inode_info *f,
 +				   unsigned long offset,
 +				   unsigned long *priv)
  {
--	struct inode *inode = filp->f_mapping->host;
--	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
-+	/* FIXME: This works only with one file system mounted at a time */
- 	int ret;
--
--	ret = file_write_and_wait_range(filp, start, end);
-+	ret = jffs2_read_inode_range(c, f, gc_buffer,
-+			 offset & ~(PAGE_SIZE-1), PAGE_SIZE);
- 	if (ret)
--		return ret;
--
--	inode_lock(inode);
--	/* Trigger GC to flush any pending writes for this inode */
--	jffs2_flush_wbuf_gc(c, inode->i_ino);
--	inode_unlock(inode);
--
--	return 0;
--}
--
--const struct file_operations jffs2_file_operations =
--{
 -	.llseek =	generic_file_llseek,
 -	.open =		generic_file_open,
 - 	.read_iter =	generic_file_read_iter,
@@ -2398,8 +2395,9 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 -	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 -	unsigned char *pg_buf;
--	int ret;
--
++	/* FIXME: This works only with one file system mounted at a time */
+ 	int ret;
+ 
 -	jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n",
 -		  __func__, inode->i_ino, pg->index << PAGE_SHIFT);
 -
@@ -2438,15 +2436,18 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -{
 -	struct jffs2_inode_info *f = JFFS2_INODE_INFO(pg->mapping->host);
 -	int ret;
--
++	ret = jffs2_read_inode_range(c, f, gc_buffer,
++			 offset & ~(PAGE_SIZE-1), PAGE_SIZE);
++	if (ret)
++		return ERR_PTR(ret);
+ 
 -	mutex_lock(&f->sem);
 -	ret = jffs2_do_readpage_unlock(pg->mapping->host, pg);
 -	mutex_unlock(&f->sem);
 -	return ret;
-+		return ERR_PTR(ret);
 +	return gc_buffer;
  }
- 
+-
 -static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
 -			loff_t pos, unsigned len, unsigned flags,
 -			struct page **pagep, void **fsdata)
@@ -2457,15 +2458,20 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -	struct page *pg;
 -	struct inode *inode = mapping->host;
 -	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
--	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 -	pgoff_t index = pos >> PAGE_SHIFT;
 -	uint32_t pageofs = index << PAGE_SHIFT;
 -	int ret = 0;
 -
+-	pg = grab_cache_page_write_begin(mapping, index, flags);
+-	if (!pg)
+-		return -ENOMEM;
+-	*pagep = pg;
+-
 -	jffs2_dbg(1, "%s()\n", __func__);
 -
 -	if (pageofs > inode->i_size) {
 -		/* Make new hole frag from old EOF to new page */
+-		struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 -		struct jffs2_raw_inode ri;
 -		struct jffs2_full_dnode *fn;
 -		uint32_t alloc_len;
@@ -2476,7 +2482,7 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -		ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
 -					  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
 -		if (ret)
--			goto out_err;
+-			goto out_page;
 -
 -		mutex_lock(&f->sem);
 -		memset(&ri, 0, sizeof(ri));
@@ -2506,7 +2512,7 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -			ret = PTR_ERR(fn);
 -			jffs2_complete_reservation(c);
 -			mutex_unlock(&f->sem);
--			goto out_err;
+-			goto out_page;
 -		}
 -		ret = jffs2_add_full_dnode_to_inode(c, f, fn);
 -		if (f->metadata) {
@@ -2521,7 +2527,7 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -			jffs2_free_full_dnode(fn);
 -			jffs2_complete_reservation(c);
 -			mutex_unlock(&f->sem);
--			goto out_err;
+-			goto out_page;
 -		}
 -		jffs2_complete_reservation(c);
 -		inode->i_size = pageofs;
@@ -2529,19 +2535,6 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -	}
 -
 -	/*
--	 * While getting a page and reading data in, lock c->alloc_sem until
--	 * the page is Uptodate. Otherwise GC task may attempt to read the same
--	 * page in read_cache_page(), which causes a deadlock.
--	 */
--	mutex_lock(&c->alloc_sem);
--	pg = grab_cache_page_write_begin(mapping, index, flags);
--	if (!pg) {
--		ret = -ENOMEM;
--		goto release_sem;
--	}
--	*pagep = pg;
--
--	/*
 -	 * Read in the page if it wasn't already present. Cannot optimize away
 -	 * the whole page write case until jffs2_write_end can handle the
 -	 * case of a short-copy.
@@ -2550,20 +2543,19 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -		mutex_lock(&f->sem);
 -		ret = jffs2_do_readpage_nolock(inode, pg);
 -		mutex_unlock(&f->sem);
--		if (ret) {
--			unlock_page(pg);
--			put_page(pg);
--			goto release_sem;
--		}
+-		if (ret)
+-			goto out_page;
 -	}
 -	jffs2_dbg(1, "end write_begin(). pg->flags %lx\n", pg->flags);
--
--release_sem:
--	mutex_unlock(&c->alloc_sem);
--out_err:
 -	return ret;
--}
 -
+-out_page:
+-	unlock_page(pg);
+-	put_page(pg);
+-	return ret;
++	/* Do nothing */
+ }
+ 
 -static int jffs2_write_end(struct file *filp, struct address_space *mapping,
 -			loff_t pos, unsigned len, unsigned copied,
 -			struct page *pg, void *fsdata)
@@ -2661,8 +2653,7 @@ diff -Nupr old/fs/jffs2/file.c new/fs/jffs2/file.c
 -	unlock_page(pg);
 -	put_page(pg);
 -	return writtenlen > 0 ? writtenlen : ret;
-+	/* Do nothing */
- }
+-}
 diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 --- old/fs/jffs2/fs.c	2022-05-09 17:22:53.000000000 +0800
 +++ new/fs/jffs2/fs.c	2022-05-10 16:13:37.830000000 +0800
@@ -2778,11 +2769,7 @@ 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);
@@ -2804,7 +2791,16 @@ 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);
@@ -2818,10 +2814,6 @@ 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;
@@ -2831,7 +2823,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;
@@ -2883,7 +2875,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 *inode, struct iattr *iattr)
+@@ -147,23 +140,20 @@ int jffs2_do_setattr (struct inode *inod
  		return PTR_ERR(new_metadata);
  	}
  	/* It worked. Update the inode */
@@ -2916,7 +2908,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 *inode, struct iattr *iattr)
+@@ -182,315 +172,201 @@ int jffs2_do_setattr (struct inode *inod
  	   We are protected from a simultaneous write() extending i_size
  	   back past iattr->ia_size, because do_truncate() holds the
  	   generic inode semaphore. */
@@ -2935,43 +2927,31 @@ 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;
-+	// 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;
++	jffs2_do_clear_inode(c, f);
  }
  
 -int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
-+struct jffs2_inode *new_inode(struct super_block *sb)
++static struct jffs2_inode *ilookup(struct super_block *sb, uint32_t ino)
  {
 -	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;
@@ -2990,35 +2970,47 @@ 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;
-+	struct jffs2_inode *inode = NULL;
++	if (sb->s_root == NULL) {
++		return NULL;
++	}
  
 -	return 0;
--}
-+	inode = zalloc(sizeof (struct jffs2_inode));
-+	if (inode == NULL)
-+		return 0;
- 
-+	D2(PRINTK("malloc new_inode %x ####################################\n",
-+		inode));
++	// 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;
+ }
  
+-
 -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);
-+	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)));
++	struct jffs2_inode *inode = NULL;
  
 -	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;
  }
  
@@ -3083,16 +3075,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;
  
--	switch (inode->i_mode & S_IFMT) {
+-	inode->i_blocks = (inode->i_size + 511) >> 9;
 +	(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;
@@ -3162,21 +3154,20 @@ 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);
-+	return inode;
- }
+-}
++	Jffs2NodeUnlock();
  
 -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,19 +3186,16 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -	iattr.ia_ctime = inode->i_ctime;
 -
 -	jffs2_do_setattr(inode, &iattr);
--}
-+// -------------------------------------------------------------------------
-+// Decrement the reference count on an inode. If this makes the ref count
-+// zero, then this inode can be freed.
++	return inode;
+ }
  
 -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.
@@ -3218,9 +3206,12 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
 -		jffs2_flush_wbuf_pad(c);
 -		mutex_unlock(&c->alloc_sem);
 -	}
--
--	if (!(fc->sb_flags & SB_RDONLY))
--		jffs2_start_garbage_collect_thread(c);
++// -------------------------------------------------------------------------
++// 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)
++{
 +	// Called in jffs2_find
 +	// (and jffs2_open and jffs2_ops_mkdir?)
 +	// super.c jffs2_fill_super,
@@ -3242,6 +3233,9 @@ 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;
  }
@@ -3348,7 +3342,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,118 +386,17 @@ static int calculate_inocache_hashsize(uint32_t flash_size)
+@@ -510,117 +386,17 @@ static int calculate_inocache_hashsize(u
  	return hashsize;
  }
  
@@ -3444,9 +3438,8 @@ 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);
--	jffs2_clear_xattr_subsystem(c);
--	jffs2_sum_exit(c);
 - out_inohash:
+-	jffs2_clear_xattr_subsystem(c);
 -	kfree(c->inocache_list);
 - out_wbuf:
 -	jffs2_flash_cleanup(c);
@@ -3455,7 +3448,8 @@ 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);
@@ -3470,7 +3464,7 @@ diff -Nupr old/fs/jffs2/fs.c new/fs/jffs2/fs.c
  	struct jffs2_inode_cache *ic;
  
  	if (unlinked) {
-@@ -669,72 +444,9 @@ struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
+@@ -668,72 +444,9 @@ struct jffs2_inode_info *jffs2_gc_fetch_
  		   Just iget() it, and if read_inode() is necessary that's OK.
  		*/
  		inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
@@ -5505,7 +5499,7 @@ diff -Nupr old/fs/jffs2/readinode.c new/fs/jffs2/readinode.c
  			break;
  
  		default:
-+		    JFFS2_ERROR("Unknown f->inocache->state %d!\n", f->inocache->state);
++		    JFFS2_ERROR("Unknow f->inocache->state %d!\n", f->inocache->state);
  			BUG();
  		}
  	}
@@ -5562,7 +5556,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_info *c, struct jffs2_eraseblock *jeb)
+@@ -74,7 +73,7 @@ static int file_dirty(struct jffs2_sb_in
  		return ret;
  	if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
  		return ret;
@@ -5571,13 +5565,15 @@ 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_info *c)
+@@ -95,40 +94,26 @@ int jffs2_scan_medium(struct jffs2_sb_in
  	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) {
@@ -5590,9 +5586,6 @@ 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 */
@@ -5620,7 +5613,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_info *c)
+@@ -140,7 +125,9 @@ int jffs2_scan_medium(struct jffs2_sb_in
  		}
  	}
  
@@ -5631,7 +5624,7 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
  		struct jffs2_eraseblock *jeb = &c->blocks[i];
  
  		cond_resched();
-@@ -269,14 +256,10 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
+@@ -269,19 +256,12 @@ int jffs2_scan_medium(struct jffs2_sb_in
  			ret = -EIO;
  			goto out;
  		}
@@ -5641,254 +5634,20 @@ diff -Nupr old/fs/jffs2/scan.c new/fs/jffs2/scan.c
  	}
  	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);
--	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 */
+-	if (buf_size)
+-		kfree(flashbuf);
 -#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);
+-	else
+-		mtd_unpoint(c->mtd, 0, c->mtd->size);
 -#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
++
+ 	return ret;
+ }
+ 
+@@ -411,7 +391,7 @@ static int jffs2_scan_xref_node(struct j
  	if (!ref)
  		return -ENOMEM;
  
@@ -5897,7 +5656,7 @@ diff
  	 * 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
+@@ -484,10 +464,10 @@ static int jffs2_scan_eraseblock (struct
  		struct jffs2_sum_marker *sm;
  		void *sumptr = NULL;
  		uint32_t sumlen;
@@ -5910,7 +5669,7 @@ diff
  			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
+@@ -500,13 +480,13 @@ static int jffs2_scan_eraseblock (struct
  				buf_len = sizeof(*sm);
  
  			/* Read as much as we want into the _end_ of the preallocated buffer */
@@ -5927,7 +5686,7 @@ diff
  			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
+@@ -521,18 +501,15 @@ static int jffs2_scan_eraseblock (struct
  					sumptr = kmalloc(sumlen, GFP_KERNEL);
  					if (!sumptr)
  						return -ENOMEM;
@@ -5950,7 +5709,7 @@ diff
  				}
  			}
  
-@@ -545,7 +525,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
+@@ -543,7 +520,7 @@ static int jffs2_scan_eraseblock (struct
  
  			if (buf_size && sumlen > buf_size)
  				kfree(sumptr);
@@ -5959,7 +5718,7 @@ diff
  			   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
+@@ -605,7 +582,7 @@ full_scan:
  	/* Now ofs is a complete physical flash offset as it always was... */
  	ofs += jeb->offset;
  
@@ -5968,7 +5727,7 @@ diff
  
  	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
+@@ -698,7 +675,7 @@ scan_more:
  				scan_end = buf_len;
  				goto more_empty;
  			}
@@ -5977,7 +5736,7 @@ diff
  			/* 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
+@@ -948,7 +925,7 @@ scan_more:
  	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);
@@ -5986,7 +5745,7 @@ diff
  	/* 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
+@@ -976,7 +953,6 @@ struct jffs2_inode_cache *jffs2_scan_mak
  		pr_notice("%s(): allocation of inode cache failed\n", __func__);
  		return NULL;
  	}
@@ -5994,7 +5753,7 @@ diff
  
  	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
+@@ -1067,7 +1043,7 @@ static int jffs2_scan_dirent_node(struct
  	pseudo_random += je32_to_cpu(rd->version);
  
  	/* Should never happen. Did. (OLPC trac #4184)*/
@@ -6003,7 +5762,7 @@ diff
  	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
+@@ -1079,7 +1055,7 @@ static int jffs2_scan_dirent_node(struct
  	memcpy(&fd->name, rd->name, checkedlen);
  	fd->name[checkedlen] = 0;
  
@@ -6012,7 +5771,7 @@ diff
  	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
+@@ -1104,7 +1080,7 @@ static int jffs2_scan_dirent_node(struct
  	fd->next = NULL;
  	fd->version = je32_to_cpu(rd->version);
  	fd->ino = je32_to_cpu(rd->ino);

fs/jffs2/src/vfs_jffs2.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-2021 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:
@@ -682,6 +682,7 @@ int VfsJffs2Rmdir(struct Vnode *parentVnode, struct Vnode *targetVnode, const ch
     LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
     ret = jffs2_rmdir(parentInode, targetInode, (const unsigned char *)path);
+
     if (ret == 0) {
         (void)jffs2_iput(targetInode);
     }
@@ -780,6 +781,7 @@ ssize_t VfsJffs2Readlink(struct Vnode *vnode, char *buffer, size_t bufLen)
 
     cnt = (bufLen - 1) < targetLen ? (bufLen - 1) : targetLen;
     if (LOS_CopyFromKernel(buffer, bufLen, (const char *)f->target, cnt) != 0) {
+        cnt = 0;
         LOS_MuxUnlock(&g_jffs2FsLock);
         return -EFAULT;
     }
@@ -807,6 +809,7 @@ int VfsJffs2Unlink(struct Vnode *parentVnode, struct Vnode *targetVnode, const c
     LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
     ret = jffs2_unlink(parentInode, targetInode, (const unsigned char *)path);
+
     if (ret == 0) {
         (void)jffs2_iput(targetInode);
     }

fs/proc/BUILD.gn

@@ -34,9 +34,7 @@ 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",

fs/proc/Kconfig

@@ -4,8 +4,3 @@ 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

fs/proc/include/internal.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,16 +45,6 @@ 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);
@@ -67,15 +57,15 @@ struct ProcDirEntry *ProcFindEntry(const char *path);
 
 void ProcFreeEntry(struct ProcDirEntry *pde);
 
-int ProcStat(const char *file, struct ProcStat *buf);
+extern int ProcStat(const char *file, struct ProcStat *buf);
 
-void ProcMountsInit(void);
+extern void ProcMountsInit(void);
 
-void ProcUptimeInit(void);
+extern void ProcUptimeInit(void);
 
-void ProcFsCacheInit(void);
+extern void ProcFsCacheInit(void);
 
-void ProcFdInit(void);
+extern void ProcFdInit(void);
 
 #ifdef __cplusplus
 #if __cplusplus

fs/proc/include/proc_fs.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,7 +82,6 @@ typedef unsigned short fmode_t;
 #define FMODE_READ        ((fmode_t)0x1)
 
 struct ProcFile;
-struct ProcDirEntry;
 
 struct ProcFileOperations {
     char *name;
@@ -90,7 +89,6 @@ 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 {
@@ -139,7 +137,7 @@ struct ProcData {
 #define S_IALLUGO (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
 
 /**
- * Interface for modules using proc below internal proc module;
+ * Interface for modules using proc below internal proc moudule;
  */
 /**
  * @ingroup  procfs
@@ -246,35 +244,6 @@ 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

fs/proc/os_adapt/fd_proc.c

@@ -135,7 +135,7 @@ void ProcFdInit(void)
 {
     struct ProcDirEntry *pde = CreateProcEntry("fd", 0, NULL);
     if (pde == NULL) {
-        PRINT_ERR("create /proc/fd error.\n");
+        PRINT_ERR("creat /proc/fd error.\n");
         return;
     }
 

fs/proc/os_adapt/file_sys.c

@@ -1,69 +0,0 @@
-/*
- * 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;
-}

fs/proc/os_adapt/fs_cache_proc.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-2021 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:
@@ -154,8 +154,7 @@ static int FsCacheInfoFill(struct SeqBuf *buf, void *arg)
 
     VnodeHold();
     LosBufPrintf(buf, "\n=================================================================\n");
-    LosBufPrintf(buf,
-        "VnodeAddr     ParentAddr     DataAddr      VnodeOps      Hash           Ref    Type    Gid    Uid    Mode\n");
+    LosBufPrintf(buf, "VnodeAddr     ParentAddr     DataAddr      VnodeOps      Hash          Ref    Type    Gid    Uid    Mode\n");
     vnodeVirtual = VnodeListProcess(buf, GetVnodeVirtualList());
     vnodeFree = VnodeListProcess(buf, GetVnodeFreeList());
     vnodeActive = VnodeListProcess(buf, GetVnodeActiveList());

fs/proc/os_adapt/mem_info.c

@@ -1,69 +0,0 @@
-/*
- * 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:%25u KB\n", mem.totalUsedSize);
-    (void)LosBufPrintf(seqBuf, "FreeSize:%25u KB\n", mem.totalFreeSize);
-    (void)LosBufPrintf(seqBuf, "MaxFreeNodeSize:%18u KB\n", mem.maxFreeNodeSize);
-    (void)LosBufPrintf(seqBuf, "UsedNodeNum:%22u KB\n", mem.usedNodeNum);
-    (void)LosBufPrintf(seqBuf, "FreeNodeNum:%22u KB\n", mem.freeNodeNum);
-#ifdef LOSCFG_MEM_WATERLINE
-    (void)LosBufPrintf(seqBuf, "UsageWaterLine:%19u KB\n", mem.freeNodeNum);
-#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;
-}

fs/proc/os_adapt/mounts_proc.c

@@ -91,7 +91,7 @@ void ProcMountsInit(void)
 {
     struct ProcDirEntry *pde = CreateProcEntry("mounts", 0, NULL);
     if (pde == NULL) {
-        PRINT_ERR("create mounts error!\n");
+        PRINT_ERR("creat mounts error!\n");
         return;
     }
 

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-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,10 +68,6 @@ 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);

fs/proc/os_adapt/proc_vfs.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-2021 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:
@@ -278,10 +278,8 @@ int VfsProcfsOpendir(struct Vnode *node,  struct fs_dirent_s *dir)
         return -EINVAL;
     }
     pde->pdirCurrent = pde->subdir;
-    if (pde->pf == NULL) {
-        return -EINVAL;
-    }
     pde->pf->fPos = 0;
+
     return LOS_OK;
 }
 
@@ -337,20 +335,6 @@ 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->procFileOps != NULL) && (pde->procFileOps->readLink != NULL)) {
-        result = pde->procFileOps->readLink(pde, buffer, bufLen);
-    }
-    return result;
-}
-
 const struct MountOps procfs_operations = {
     .Mount = VfsProcfsMount,
     .Unmount = NULL,
@@ -363,8 +347,7 @@ static struct VnodeOps g_procfsVops = {
     .Readdir = VfsProcfsReaddir,
     .Opendir = VfsProcfsOpendir,
     .Closedir = VfsProcfsClosedir,
-    .Truncate = VfsProcfsTruncate,
-    .Readlink = VfsProcfsReadlink,
+    .Truncate = VfsProcfsTruncate
 };
 
 static struct file_operations_vfs g_procfsFops = {

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-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,436 +32,7 @@
 #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;
-};
-
-#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 = (LosProcessCB *)data->process;
-    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 KB\n", vmSpace->size);
-    (void)LosBufPrintf(seqBuf, "VMRegionSize:            %u KB\n", heap->range.size);
-    (void)LosBufPrintf(seqBuf, "RegionFlags:             %s\n", OsGetRegionNameOrFilePath(heap));
-    (void)LosBufPrintf(seqBuf, "ShmidAboutSharedRegion:  %u\n", heap->shmid);
-    (void)LosBufPrintf(seqBuf, "VMSpaceRorkFlags:        0x%x\n", heap->forkFlags);
-    (void)LosBufPrintf(seqBuf, "VMRegionRype:            0x%x\n", heap->regionType);
-    (void)LosBufPrintf(seqBuf, "VMSpaceMappingAreaSize:  %u KB\n", vmSpace->mapSize);
-    (void)LosBufPrintf(seqBuf, "TLB Asid:                %u\n", vmSpace->archMmu.asid);
-    (void)LOS_MemFree(m_aucSysMem1, vmSpace);
-    return 0;
-}
-
-#ifdef LOSCFG_KERNEL_CPUP
-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\n", processCpup->allTime);
-    (void)LosBufPrintf(seqBuf, "StartTime:               %lu\n", processCpup->startTime);
-    (void)LosBufPrintf(seqBuf, "HistoricalRunningTime:   ");
-    for (UINT32 i = 0; i < OS_CPUP_HISTORY_RECORD_NUM + 1; i++) {
-        (void)LosBufPrintf(seqBuf, "%lu  ", 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 = (LosProcessCB *)data->process;
-    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_sec = 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, (LosProcessCB *)data->process);
-    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, (LosProcessCB *)data->process);
-#ifdef LOSCFG_KERNEL_CPUP
-        case PROC_PID_CPUP:
-            return ProcessCpupRead(m, (LosProcessCB *)data->process);
-#endif
-        default:
-            break;
-    }
-    return -EINVAL;
-}
-
-static const struct ProcFileOperations PID_FOPS = {
-    .read = ProcProcessRead,
-};
-
-static struct ProcProcess g_procProcess[] = {
-    {
-        .name = NULL,
-        .mode = S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH,
-        .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 (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);
-    }
-    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;
-        }
-    }
-
-    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)
 {
@@ -481,13 +52,7 @@ 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_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;
+    pde->procFileOps = &PROCESS_PROC_FOPS;
 }
+

fs/proc/os_adapt/uptime_proc.c

@@ -78,7 +78,7 @@ void ProcUptimeInit(void)
 {
     struct ProcDirEntry *pde = CreateProcEntry("uptime", 0, NULL);
     if (pde == NULL) {
-        PRINT_ERR("create /proc/uptime error!\n");
+        PRINT_ERR("creat /proc/uptime error!\n");
         return;
     }
 

fs/proc/src/proc_file.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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:
@@ -62,9 +62,8 @@ static struct ProcDirEntry g_procRootDirEntry = {
 
 int ProcMatch(unsigned int len, const char *name, struct ProcDirEntry *pn)
 {
-    if (len != pn->nameLen) {
+    if (len != pn->nameLen)
         return 0;
-    }
     return !strncmp(name, pn->name, len);
 }
 
@@ -351,11 +350,7 @@ static struct ProcDirEntry *ProcCreateFile(struct ProcDirEntry *parent, const ch
     }
 
     pn->procFileOps = procFileOps;
-    if (S_ISLNK(mode)) {
-        pn->type = VNODE_TYPE_LNK;
-    } else {
-        pn->type = VNODE_TYPE_REG;
-    }
+    pn->type = VNODE_TYPE_REG;
     ret = ProcAddNode(parent, pn);
     if (ret != 0) {
         free(pn->pf);
@@ -387,18 +382,13 @@ static void FreeProcEntry(struct ProcDirEntry *entry)
         free(entry->pf);
         entry->pf = NULL;
     }
-    if (entry->data != NULL) {
-        free(entry->data);
-        entry->data = NULL;
-    }
     free(entry);
 }
 
 void ProcFreeEntry(struct ProcDirEntry *pn)
 {
-    if (atomic_dec_and_test(&pn->count)) {
+    if (atomic_dec_and_test(&pn->count))
         FreeProcEntry(pn);
-    }
 }
 
 static void RemoveProcEntryTravalsal(struct ProcDirEntry *pn)
@@ -537,7 +527,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, pde->data) != 0) {
+        if (pde->procFileOps->read(sb, NULL) != 0) {
             return PROC_ERROR;
         }
     }

fs/proc/src/proc_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-2021 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:
@@ -62,8 +62,8 @@ int OsShellCmdWriteProc(int argc, char **argv)
 
     if (argc == WRITEPROC_ARGC) {
         value = argv[0];
-        path = argv[2]; // 2: index of path
-        len = strlen(value) + 1;  /* + 1:add the \0 */
+        path = argv[2];
+        len = strlen(value) + 1;  /* +1:add the \0 */
         if (strncmp(argv[1], ">>", strlen(">>")) == 0) {
             if ((realpath(path, realPath) == NULL) || (strncmp(realPath, rootProcDir, strlen(rootProcDir)) != 0)) {
                 PRINT_ERR("No such file or directory\n");

fs/rootfs/Kconfig

@@ -29,9 +29,10 @@ endchoice
 config BOOTENV_ADDR
     int "Address of boot command line (KB)"
     depends on PLATFORM_ROOTFS && (STORAGE_SPINOR || STORAGE_SPINAND || STORAGE_EMMC)
+    range 0 1024
     default 512
     help
-      Boot command line addr.
+      Boot command line addr, range from 0 to 1MB.
 
 config BOOTENV_RAM
     bool "Read bootenv from RAM"

fs/rootfs/Makefile

@@ -33,6 +33,10 @@ 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)

fs/rootfs/los_bootargs.c

@@ -32,10 +32,14 @@
 #include "los_base.h"
 #include "string.h"
 
-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
+#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
 #include "mtd_list.h"
 #endif
 
+#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
+#include "cfiflash.h"
+#endif
+
 #ifdef LOSCFG_STORAGE_EMMC
 #include "disk.h"
 #endif
@@ -94,6 +98,19 @@ 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);

fs/rootfs/los_rootfs.c

@@ -37,11 +37,15 @@
 #include "sys/stat.h"
 #include "sys/types.h"
 
-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
+#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
 #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"
@@ -124,7 +128,14 @@ STATIC INT32 AddEmmcParts(INT32 rootAddr, INT32 rootSize, INT32 userAddr, INT32
 
 STATIC INT32 AddPartitions(CHAR *dev, UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
 {
-#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
+#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)
     INT32 ret;
     INT32 blk0 = 0;
     INT32 blk2 = 2;

fs/rootfs/los_rootfs.h

@@ -59,6 +59,12 @@
 #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

fs/vfs/bcache/src/bcache.c

@@ -581,8 +581,8 @@ static OsBcacheBlock *AllocNewBlock(OsBcache *bc, BOOL read, UINT64 num)
         DelBlock(bc, prefer);
     }
 
-    if (prefer->used) { /* do not combine with next check */
-        MergeSyncBlocks(bc, prefer); /* prefer->used may be changed here */
+    if (prefer->used) {
+        MergeSyncBlocks(bc, prefer);
     }
 
     if (prefer->used) {

fs/vfs/epoll/fs_epoll.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-2021 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:
@@ -164,23 +164,23 @@ static VOID DoEpollClose(struct epoll_head *epHead)
 }
 
 /**
- * epoll_create unsupported api
- *
- * epoll_create is implemented by calling epoll_create1, it's parameter 'size' is useless.
- *
- * epoll_create1,
+ * epoll_create,
  * The simple version of epoll does not use red-black trees,
  * so when fd is normal value (greater than 0),
  * actually allocated epoll can manage num of EPOLL_DEFAULT_SIZE
  *
- * @param flags: not actually used
+ * @param size: not actually used
  * @return epoll fd
  */
-int epoll_create1(int flags)
+int epoll_create(int size)
 {
-    (void)flags;
     int fd = -1;
 
+    if (size <= 0) {
+        set_errno(EINVAL);
+        return fd;
+    }
+
     struct epoll_head *epHead = (struct epoll_head *)malloc(sizeof(struct epoll_head));
     if (epHead == NULL) {
         set_errno(ENOMEM);
@@ -304,7 +304,7 @@ int epoll_wait(int epfd, FAR struct epoll_event *evs, int maxevents, int timeout
     int pollSize;
 
     epHead = EpollGetDataBuff(epfd);
-    if (epHead == NULL) {
+    if (epHead== NULL) {
         set_errno(EBADF);
         return -1;
     }

fs/vfs/include/bcache/bcache.h

@@ -138,7 +138,7 @@ typedef struct tagOsBcache {
  * <li>The block number is automatically adjusted if position is greater than block size.</li>
  * </ul>
  *
- * @retval #0           read succeeded
+ * @retval #0           read succeded
  * @retval #INT32       read failed
  *
  * @par Dependency:
@@ -168,7 +168,7 @@ INT32 BlockCacheRead(OsBcache *bc,
  * <li>The block number is automatically adjusted if position is greater than block size.</li>
  * </ul>
  *
- * @retval #0           write succeeded
+ * @retval #0           write succeded
  * @retval #INT32       write failed
  *
  * @par Dependency:
@@ -193,7 +193,7 @@ INT32 BlockCacheWrite(OsBcache *bc,
  * <li>None.</li>
  * </ul>
  *
- * @retval #0           sync succeeded
+ * @retval #0           sync succeded
  * @retval #INT32       sync failed
  *
  * @par Dependency:
@@ -219,7 +219,7 @@ INT32 BlockCacheSync(OsBcache *bc);
  * <li>None.</li>
  * </ul>
  *
- * @retval #OsBcache *      init succeeded
+ * @retval #OsBcache *      init succeded
  * @retval #NULL            init failed
  *
  * @par Dependency:

fs/vfs/include/epoll.h

@@ -72,7 +72,7 @@ struct epoll_event {
     epoll_data_t data;
 };
 
-int epoll_create1(int flags);
+int epoll_create(int size);
 int epoll_close(int epfd);
 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
 int epoll_wait(int epfd, FAR struct epoll_event *evs, int maxevents, int timeout);

fs/vfs/include/vnode.h

@@ -127,9 +127,6 @@ 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 {
@@ -163,7 +160,7 @@ typedef int VfsHashCmp(struct Vnode *vnode, void *arg);
 
 int VnodesInit(void);
 int VnodeDevInit(void);
-int VnodeAlloc(struct VnodeOps *vop, struct Vnode **newVnode);
+int VnodeAlloc(struct VnodeOps *vop, struct Vnode **vnode);
 int VnodeFree(struct Vnode *vnode);
 int VnodeLookup(const char *path, struct Vnode **vnode, uint32_t flags);
 int VnodeLookupFullpath(const char *fullpath, struct Vnode **vnode, uint32_t flags);
@@ -188,5 +185,5 @@ LIST_HEAD* GetVnodeFreeList(void);
 LIST_HEAD* GetVnodeActiveList(void);
 LIST_HEAD* GetVnodeVirtualList(void);
 int VnodeClearCache(void);
-struct Vnode *GetCurrRootVnode(void);
+
 #endif /* !_VNODE_H_ */

fs/vfs/mount.c

@@ -37,16 +37,11 @@
 #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;
@@ -67,26 +62,7 @@ struct Mount *MountAlloc(struct Vnode *vnodeBeCovered, struct MountOps *fsop)
     return mnt;
 }
 
-#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)
+LIST_HEAD* GetMountList()
 {
     if (g_mountList == NULL) {
         g_mountList = zalloc(sizeof(LIST_HEAD));
@@ -98,4 +74,3 @@ LIST_HEAD* GetMountList(void)
     }
     return g_mountList;
 }
-#endif

fs/vfs/operation/fullpath.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-2021 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:
@@ -225,6 +225,7 @@ static char *vfs_normalize_fullpath(const char *directory, const char *filename,
         /* it's a absolute path, use it directly */
 
         fullpath = strdup(filename); /* copy string */
+
         if (fullpath == NULL) {
             *pathname = NULL;
             set_errno(ENOMEM);
@@ -257,10 +258,11 @@ int vfs_normalize_path(const char *directory, const char *filename, char **pathn
     }
 
 #ifdef VFS_USING_WORKDIR
-    if (directory == NULL) {
+    if (directory == NULL)
+      {
         spin_lock_irqsave(&curr->files->workdir_lock, lock_flags);
         directory = curr->files->workdir;
-    }
+      }
 #else
     if ((directory == NULL) && (filename[0] != '/')) {
         PRINT_ERR("NO_WORKING_DIR\n");
@@ -273,18 +275,20 @@ int vfs_normalize_path(const char *directory, const char *filename, char **pathn
 
     if ((filename[0] != '/') && (strlen(directory) + namelen + 2 > TEMP_PATH_MAX)) {
 #ifdef VFS_USING_WORKDIR
-        if (dir_flags == TRUE) {
+        if (dir_flags == TRUE)
+          {
             spin_unlock_irqrestore(&curr->files->workdir_lock, lock_flags);
-        }
+          }
 #endif
         return -ENAMETOOLONG;
     }
 
     fullpath = vfs_normalize_fullpath(directory, filename, pathname, namelen);
 #ifdef VFS_USING_WORKDIR
-    if (dir_flags == TRUE) {
+    if (dir_flags == TRUE)
+      {
         spin_unlock_irqrestore(&curr->files->workdir_lock, lock_flags);
-    }
+      }
 #endif
     if (fullpath == NULL) {
         return -get_errno();
@@ -304,7 +308,7 @@ int vfs_normalize_path(const char *directory, const char *filename, char **pathn
 
 int vfs_normalize_pathat(int dirfd, const char *filename, char **pathname)
 {
-    /* Get path by dirfd */
+    /* Get path by dirfd*/
     char *relativeoldpath = NULL;
     char *fullpath = NULL;
     int ret = 0;

fs/vfs/operation/vfs_fallocate64.c

@@ -133,7 +133,7 @@ int fallocate64(int fd, int mode, off64_t offset, off64_t len)
         return VFS_ERROR;
     }
 
-    if ((unsigned int)filep->f_oflags & O_DIRECTORY) {
+    if (filep->f_oflags & O_DIRECTORY) {
         set_errno(EBADF);
         return VFS_ERROR;
     }

fs/vfs/operation/vfs_force_umount.c

@@ -353,7 +353,7 @@ static struct file_operations_vfs g_errorFileOps = {
     .unlink = ErrorFopUnlink,
 };
 
-static struct Mount* GetDevMountPoint(const struct Vnode *dev)
+static struct Mount* GetDevMountPoint(struct Vnode *dev)
 {
     struct Mount *mnt = NULL;
     LIST_HEAD *mntList = GetMountList();
@@ -394,7 +394,7 @@ static void FilePreClose(struct file *filep, const struct file_operations_vfs *o
     }
 }
 
-static void FileDisableAndClean(const struct Mount *mnt)
+static void FileDisableAndClean(struct Mount *mnt)
 {
     struct filelist *flist = &tg_filelist;
     struct file *filep = NULL;
@@ -435,7 +435,7 @@ static void VnodeTryFree(struct Vnode *vnode)
     vnode->fop = &g_errorFileOps;
 }
 
-static void VnodeTryFreeAll(const struct Mount *mount)
+static void VnodeTryFreeAll(struct Mount *mount)
 {
     struct Vnode *vnode = NULL;
     struct Vnode *nextVnode = NULL;

fs/vfs/operation/vfs_other.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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:
@@ -132,19 +132,19 @@ int VfsPermissionCheck(uint fuid, uint fgid, uint fileMode, int accMode)
 #ifdef VFS_USING_WORKDIR
 static int SetWorkDir(const char *dir, size_t len)
 {
-    errno_t ret;
-    uint lock_flags;
-    LosProcessCB *curr = OsCurrProcessGet();
+  errno_t ret;
+  uint lock_flags;
+  LosProcessCB *curr = OsCurrProcessGet();
 
-    spin_lock_irqsave(&curr->files->workdir_lock, lock_flags);
-    ret = strncpy_s(curr->files->workdir, PATH_MAX, dir, len);
-    curr->files->workdir[PATH_MAX - 1] = '\0';
-    spin_unlock_irqrestore(&curr->files->workdir_lock, lock_flags);
-    if (ret != EOK) {
-        return -1;
-    }
+  spin_lock_irqsave(&curr->files->workdir_lock, lock_flags);
+  ret = strncpy_s(curr->files->workdir, PATH_MAX, dir, len);
+  curr->files->workdir[PATH_MAX - 1] = '\0';
+  spin_unlock_irqrestore(&curr->files->workdir_lock, lock_flags);
+  if (ret != EOK) {
+      return -1;
+  }
 
-        return 0;
+  return 0;
 }
 #endif
 
@@ -155,6 +155,7 @@ int chdir(const char *path)
     char *fullpath_bak = NULL;
     struct stat statBuff;
 
+
     if (!path) {
         set_errno(EFAULT);
         return -1;
@@ -482,7 +483,7 @@ exit_with_nomem:
     return (char *)NULL;
 }
 
-static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name, const char *linkName)
+static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name)
 {
     mode_t mode;
     char str[UGO_NUMS][UGO_NUMS + 1] = {0};
@@ -504,18 +505,11 @@ static void PrintFileInfo64(const struct stat64 *stat64Info, const char *name, c
         dirFlag = '-';
     }
 
-    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);
-    }
+    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, const char *linkName)
+static void PrintFileInfo(const struct stat *statInfo, const char *name)
 {
     mode_t mode;
     char str[UGO_NUMS][UGO_NUMS + 1] = {0};
@@ -537,33 +531,19 @@ static void PrintFileInfo(const struct stat *statInfo, const char *name, const c
         dirFlag = '-';
     }
 
-    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);
-    }
+    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) {
-        if (S_ISLNK(stat64Info.st_mode)) {
-            readlink(path, linkName, NAME_MAX);
-        }
-        PrintFileInfo64(&stat64Info, path, (const char *)linkName);
+        PrintFileInfo64(&stat64Info, path);
     } else if (stat(path, &statInfo) == 0) {
-        if (S_ISLNK(statInfo.st_mode)) {
-            readlink(path, linkName, NAME_MAX);
-        }
-        PrintFileInfo(&statInfo, path, (const char *)linkName);
+        PrintFileInfo(&statInfo, path);
     } else {
         return -1;
     }
@@ -575,7 +555,6 @@ 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;
@@ -591,34 +570,28 @@ int LsDir(const char *path)
         pdirent = readdir(d);
         if (pdirent == NULL) {
             break;
-        }
-        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);
+            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);
         }
-        free(fullpath_bak);
     } while (1);
     (void)closedir(d);
 
@@ -758,45 +731,3 @@ 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

fs/vfs/operation/vfs_utime.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-2021 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:
@@ -57,6 +57,7 @@ int utime(const char *path, const struct utimbuf *ptimes)
 
     /* Sanity checks */
 
+
     if (path == NULL) {
         ret = -EINVAL;
         goto errout;

fs/vfs/operation/vfs_writev.c

@@ -66,6 +66,7 @@ static int iov_trans_to_buf(char *buf, ssize_t totallen, const struct iovec *iov
             } else {
                 writepart = bytestowrite - ret;
                 curbuf += writepart;
+                totallen -= writepart;
                 break;
             }
         }

fs/vfs/vnode.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2021-2021 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:
@@ -29,11 +29,9 @@
  */
 
 #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 */
@@ -69,13 +67,6 @@ 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;
 }
 
@@ -248,7 +239,7 @@ BOOL VnodeInUseIter(const struct Mount *mount)
     return FALSE;
 }
 
-int VnodeHold(void)
+int VnodeHold()
 {
     int ret = LOS_MuxLock(&g_vnodeMux, LOS_WAIT_FOREVER);
     if (ret != LOS_OK) {
@@ -257,7 +248,7 @@ int VnodeHold(void)
     return ret;
 }
 
-int VnodeDrop(void)
+int VnodeDrop()
 {
     int ret = LOS_MuxUnlock(&g_vnodeMux);
     if (ret != LOS_OK) {
@@ -290,7 +281,7 @@ static int PreProcess(const char *originPath, struct Vnode **startVnode, char **
 
     ret = vfs_normalize_path(NULL, originPath, &absolutePath);
     if (ret == LOS_OK) {
-        *startVnode = GetCurrRootVnode();
+        *startVnode = g_rootVnode;
         *path = absolutePath;
     }
 
@@ -302,21 +293,7 @@ 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)
@@ -417,7 +394,7 @@ int VnodeLookupAt(const char *path, struct Vnode **result, uint32_t flags, struc
     }
 
     if (normalizedPath[1] == '\0' && normalizedPath[0] == '/') {
-        *result = GetCurrRootVnode();
+        *result = g_rootVnode;
         free(normalizedPath);
         return LOS_OK;
     }
@@ -477,7 +454,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, GetCurrRootVnode());
+    return VnodeLookupAt(fullpath, vnode, flags, g_rootVnode);
 }
 
 static void ChangeRootInternal(struct Vnode *rootOld, char *dirname)
@@ -519,17 +496,6 @@ 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");
 }
@@ -617,7 +583,7 @@ int VnodeCreate(struct Vnode *parent, const char *name, int mode, struct Vnode *
     return 0;
 }
 
-int VnodeDevInit(void)
+int VnodeDevInit()
 {
     struct Vnode *devNode = NULL;
     struct Mount *devMount = NULL;
@@ -650,7 +616,7 @@ int VnodeGetattr(struct Vnode *vnode, struct stat *buf)
     return LOS_OK;
 }
 
-struct Vnode *VnodeGetRoot(void)
+struct Vnode *VnodeGetRoot()
 {
     return g_rootVnode;
 }
@@ -716,25 +682,6 @@ 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;
@@ -750,7 +697,7 @@ LIST_HEAD* GetVnodeActiveList()
     return &g_vnodeActiveList;
 }
 
-int VnodeClearCache(void)
+int VnodeClearCache()
 {
     struct Vnode *item = NULL;
     struct Vnode *nextItem = NULL;
@@ -772,13 +719,3 @@ int VnodeClearCache(void)
 
     return count;
 }
-
-struct Vnode *GetCurrRootVnode(void)
-{
-#ifdef LOSCFG_CHROOT
-    LosProcessCB *curr = OsCurrProcessGet();
-    return curr->files->rootVnode;
-#else
-    return g_rootVnode;
-#endif
-}

kernel/Kconfig

@@ -67,49 +67,7 @@ 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.
-
 endmenu

kernel/base/BUILD.gn

@@ -1,5 +1,5 @@
 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 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,14 +32,7 @@ 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",
@@ -72,12 +65,10 @@ kernel_module(module_name) {
     "mp/los_mp.c",
     "mp/los_percpu.c",
     "mp/los_spinlock.c",
+    "mp/los_stat.c",
     "om/los_err.c",
-    "sched/los_idle.c",
-    "sched/los_priority.c",
-    "sched/los_sched.c",
-    "sched/los_sortlink.c",
-    "sched/los_statistics.c",
+    "sched/sched_sq/los_sched.c",
+    "sched/sched_sq/los_sortlink.c",
     "vm/los_vm_boot.c",
     "vm/los_vm_dump.c",
     "vm/los_vm_fault.c",
@@ -97,13 +88,8 @@ kernel_module(module_name) {
   }
 
   public_configs = [ ":public" ]
-  configs += [ ":private" ]
 }
 
 config("public") {
   include_dirs = [ "include" ]
 }
-
-config("private") {
-  cflags = [ "-Wno-frame-address" ]
-}

kernel/base/Makefile

@@ -1,5 +1,5 @@
 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 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:
@@ -28,7 +28,7 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 include $(LITEOSTOPDIR)/config.mk
-include $(LITEOSTOPDIR)/../../drivers/hdf_core/adapter/khdf/liteos/lite.mk
+include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk
 
 MODULE_NAME := $(notdir $(shell pwd))
 
@@ -37,11 +37,9 @@ LOCAL_SRCS := 	$(wildcard ipc/*.c) $(wildcard core/*.c) $(wildcard mem/membox/*.
 		$(wildcard misc/*.c)\
 		$(wildcard mem/tlsf/*.c) \
 		$(wildcard mp/*.c) \
-		$(wildcard sched/*.c) \
-		$(wildcard vm/*.c) \
-		$(wildcard container/*.c)
+		$(wildcard sched/sched_sq/*.c) \
+		$(wildcard vm/*.c)
 
-
-LOCAL_FLAGS := $(LITEOS_CFLAGS_INTERWORK) -Wno-frame-address
+LOCAL_FLAGS := $(LITEOS_CFLAGS_INTERWORK)
 
 include $(MODULE)

kernel/base/container/los_container.c

@@ -1,212 +0,0 @@
-/*
- * 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;
-}
-
-/*
- * 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;
-    UINT32 ret = LOS_OK;
-
-    if (!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWPID | CLONE_NEWNET | CLONE_NEWTIME))) {
-        SCHEDULER_LOCK(intSave);
-        child->container = parent->container;
-        LOS_AtomicInc(&child->container->rc);
-        SCHEDULER_UNLOCK(intSave);
-    } else {
-        child->container = CreateContainer();
-        if (child->container == NULL) {
-            return ENOMEM;
-        }
-    }
-
-    /* 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;
-}
-
-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) {
-        OsPidContainersDestroyAllProcess(processCB);
-    }
-#endif
-
-#ifdef LOSCFG_UTS_CONTAINER
-    OsUtsContainersDestroy(processCB);
-#endif
-
-#ifdef LOSCFG_MNT_CONTAINER
-    OsMntContainersDestroy(processCB);
-#endif
-
-#ifdef LOSCFG_IPC_CONTAINER
-    OsIpcContainersDestroy(processCB);
-#endif
-
-#ifdef LOSCFG_TIME_CONTAINER
-    OsTimeContainersDestroy(processCB);
-#endif
-
-#ifndef LOSCFG_PID_CONTAINER
-    LOS_AtomicDec(&curr->container->rc);
-    if (LOS_AtomicRead(&processCB->container->rc) == 0) {
-        (VOID)LOS_MemFree(m_aucSysMem1, processCB->container);
-        processCB->container = NULL;
-    }
-#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;
-}
-#endif

kernel/base/container/los_ipc_container.c

@@ -1,165 +0,0 @@
-/*
- * 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);
-}
-
-VOID OsIpcContainersDestroy(LosProcessCB *curr)
-{
-    UINT32 intSave;
-    if (curr->container == NULL) {
-        return;
-    }
-
-    SCHEDULER_LOCK(intSave);
-    IpcContainer *ipcContainer = curr->container->ipcContainer;
-    if (ipcContainer != NULL) {
-        LOS_AtomicDec(&ipcContainer->rc);
-        if (LOS_AtomicRead(&ipcContainer->rc) == 0) {
-            g_currentIpcContainerNum--;
-            SCHEDULER_UNLOCK(intSave);
-            ShmDeinit();
-            curr->container->ipcContainer = NULL;
-            (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer->allQueue);
-            (VOID)LOS_MemFree(m_aucSysMem1, ipcContainer);
-            return;
-        }
-    }
-    SCHEDULER_UNLOCK(intSave);
-    return;
-}
-
-UINT32 OsGetIpcContainerID(IpcContainer *ipcContainer)
-{
-    if (ipcContainer == NULL) {
-        return OS_INVALID_VALUE;
-    }
-
-    return ipcContainer->containerID;
-}
-
-IpcContainer *OsGetCurrIpcContainer(VOID)
-{
-    return OsCurrProcessGet()->container->ipcContainer;
-}
-#endif

kernel/base/container/los_mnt_container.c

@@ -1,191 +0,0 @@
-/*
- * 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);
-}
-
-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 OsMntContainersDestroy(LosProcessCB *curr)
-{
-    UINT32 intSave;
-    if (curr->container == NULL) {
-        return;
-    }
-
-    SCHEDULER_LOCK(intSave);
-    MntContainer *mntContainer = curr->container->mntContainer;
-    if (mntContainer != NULL) {
-        LOS_AtomicDec(&mntContainer->rc);
-        if (LOS_AtomicRead(&mntContainer->rc) == 0) {
-            g_currentMntContainerNum--;
-            SCHEDULER_UNLOCK(intSave);
-            FreeMountList(&mntContainer->mountList);
-            curr->container->mntContainer = NULL;
-            (VOID)LOS_MemFree(m_aucSysMem1, mntContainer);
-            return;
-        }
-    }
-    SCHEDULER_UNLOCK(intSave);
-    return;
-}
-
-UINT32 OsGetMntContainerID(MntContainer *mntContainer)
-{
-    if (mntContainer == NULL) {
-        return OS_INVALID_VALUE;
-    }
-
-    return mntContainer->containerID;
-}
-#endif

kernel/base/container/los_pid_container.c

@@ -1,455 +0,0 @@
-/*
- * 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 OsPidContainersDestroyAllProcess(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);
-    } else {
-        LOS_AtomicSet(&newPidContainer->level, 0);
-    }
-    return newPidContainer;
-}
-
-STATIC UINT32 CreatePidContainer(LosProcessCB *child, LosProcessCB *parent)
-{
-    UINT32 intSave;
-    UINT32 ret;
-    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) {
-        SCHEDULER_UNLOCK(intSave);
-        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
-        return EINVAL;
-    }
-
-    g_currentPidContainerNum++;
-    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;
-        SCHEDULER_UNLOCK(intSave);
-        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
-        return ENOSPC;
-    }
-    SCHEDULER_UNLOCK(intSave);
-    return LOS_OK;
-}
-
-VOID OsPidContainersDestroy(LosProcessCB *curr)
-{
-    if (curr->container == NULL) {
-        return;
-    }
-
-    PidContainer *pidContainer = curr->container->pidContainer;
-    if (pidContainer != NULL) {
-        FreeVpid(curr);
-        if (LOS_AtomicRead(&pidContainer->rc) == 0) {
-            g_currentPidContainerNum--;
-            curr->container->pidContainer = NULL;
-            curr->container->pidForChildContainer = NULL;
-            (VOID)LOS_MemFree(m_aucSysMem1, pidContainer);
-        }
-    }
-
-    LOS_AtomicDec(&curr->container->rc);
-    if (LOS_AtomicRead(&curr->container->rc) == 0) {
-        (VOID)LOS_MemFree(m_aucSysMem1, curr->container);
-        curr->container = NULL;
-    }
-}
-
-UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
-{
-    UINT32 ret;
-    UINT32 intSave;
-
-    if (!(flags & CLONE_NEWPID)) {
-        SCHEDULER_LOCK(intSave);
-        child->container->pidContainer = parent->container->pidContainer;
-        child->container->pidForChildContainer = parent->container->pidContainer;
-        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;
-    }
-
-    ret = CreatePidContainer(child, parent);
-    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;
-}
-
-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

kernel/base/container/los_time_container.c

@@ -1,182 +0,0 @@
-/*
- * 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;
-    TimeContainer *parentContainer = parent->container->timeContainer;
-    TimeContainer *newTimeContainer = CreateNewTimeContainer(parentContainer);
-    if (newTimeContainer == NULL) {
-        return ENOMEM;
-    }
-
-    SCHEDULER_LOCK(intSave);
-    g_currentTimeContainerNum++;
-    (VOID)memcpy_s(&newTimeContainer->monotonic, sizeof(struct timespec64),
-                   &parentContainer->monotonic, sizeof(struct timespec64));
-    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 (!(flags & CLONE_NEWTIME)) {
-        SCHEDULER_LOCK(intSave);
-        if (!currTimeContainer->frozenOffsets) {
-            currTimeContainer->frozenOffsets = TRUE;
-        }
-        LOS_AtomicInc(&currTimeContainer->rc);
-        child->container->timeContainer = currTimeContainer;
-        child->container->timeForChildContainer = currTimeContainer;
-        SCHEDULER_UNLOCK(intSave);
-        return LOS_OK;
-    }
-
-    return CreateTimeContainer(child, parent);
-}
-
-VOID OsTimeContainersDestroy(LosProcessCB *curr)
-{
-    UINT32 intSave;
-    if (curr->container == NULL) {
-        return;
-    }
-
-    SCHEDULER_LOCK(intSave);
-    TimeContainer *timeContainer = curr->container->timeContainer;
-    if (timeContainer != NULL) {
-        LOS_AtomicDec(&timeContainer->rc);
-        if (LOS_AtomicRead(&timeContainer->rc) == 0) {
-            g_currentTimeContainerNum--;
-            curr->container->timeContainer = NULL;
-            curr->container->timeForChildContainer = NULL;
-            SCHEDULER_UNLOCK(intSave);
-            (VOID)LOS_MemFree(m_aucSysMem1, timeContainer);
-            return;
-        }
-    }
-    SCHEDULER_UNLOCK(intSave);
-    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

kernel/base/container/los_uts_container.c

@@ -1,186 +0,0 @@
-/*
- * 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)
-{
-    UINT32 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);
-}
-
-VOID OsUtsContainersDestroy(LosProcessCB *curr)
-{
-    UINT32 intSave;
-    if (curr->container == NULL) {
-        return;
-    }
-
-    SCHEDULER_LOCK(intSave);
-    UtsContainer *utsContainer = curr->container->utsContainer;
-    if (utsContainer != NULL) {
-        LOS_AtomicDec(&utsContainer->rc);
-        if (LOS_AtomicRead(&utsContainer->rc) == 0) {
-            g_currentUtsContainerNum--;
-            curr->container->utsContainer = NULL;
-            SCHEDULER_UNLOCK(intSave);
-            (VOID)LOS_MemFree(m_aucSysMem1, utsContainer);
-            return;
-        }
-    }
-    SCHEDULER_UNLOCK(intSave);
-    return;
-}
-
-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

kernel/base/core/los_info.c

@@ -1,249 +0,0 @@
-/*
- * 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;
-}

kernel/base/core/los_smp.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,13 +45,11 @@ STATIC VOID OsSmpSecondaryInit(VOID *arg)
 {
     UNUSED(arg);
 
-    OsCurrTaskSet(OsGetMainTask());
-
 #ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
     OsSwtmrInit();
 #endif
 
-    OsIdleTaskCreate((UINTPTR)OsGetIdleProcess());
+    OsIdleTaskCreate();
     OsInitCall(LOS_INIT_LEVEL_KMOD_TASK);
 
     OsSchedStart();

kernel/base/core/los_swtmr.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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:
@@ -43,9 +43,6 @@
 #error "swtmr maxnum cannot be zero"
 #endif /* LOSCFG_BASE_CORE_SWTMR_LIMIT <= 0 */
 
-STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr);
-STATIC INLINE UINT64 SwtmrToStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid);
-
 LITE_OS_SEC_BSS SWTMR_CTRL_S    *g_swtmrCBArray = NULL;     /* First address in Timer memory space */
 LITE_OS_SEC_BSS UINT8           *g_swtmrHandlerPool = NULL; /* Pool of Swtmr Handler */
 LITE_OS_SEC_BSS LOS_DL_LIST     g_swtmrFreeList;            /* Free list of Software Timer */
@@ -55,232 +52,22 @@ LITE_OS_SEC_BSS  SPIN_LOCK_INIT(g_swtmrSpin);
 #define SWTMR_LOCK(state)       LOS_SpinLockSave(&g_swtmrSpin, &(state))
 #define SWTMR_UNLOCK(state)     LOS_SpinUnlockRestore(&g_swtmrSpin, (state))
 
-typedef struct {
-    SortLinkAttribute swtmrSortLink;
-    LosTaskCB         *swtmrTask;           /* software timer task id */
-    LOS_DL_LIST       swtmrHandlerQueue;     /* software timer timeout queue id */
-} SwtmrRunqueue;
-
-STATIC SwtmrRunqueue g_swtmrRunqueue[LOSCFG_KERNEL_CORE_NUM];
-
-#ifdef LOSCFG_SWTMR_DEBUG
-#define OS_SWTMR_PERIOD_TO_CYCLE(period) (((UINT64)(period) * OS_NS_PER_TICK) / OS_NS_PER_CYCLE)
-STATIC SwtmrDebugData *g_swtmrDebugData = NULL;
-
-BOOL OsSwtmrDebugDataUsed(UINT32 swtmrID)
-{
-    if (swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) {
-        return FALSE;
-    }
-
-    return g_swtmrDebugData[swtmrID].swtmrUsed;
-}
-
-UINT32 OsSwtmrDebugDataGet(UINT32 swtmrID, SwtmrDebugData *data, UINT32 len, UINT8 *mode)
-{
-    UINT32 intSave;
-    errno_t ret;
-
-    if ((swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) || (data == NULL) ||
-        (mode == NULL) || (len < sizeof(SwtmrDebugData))) {
-        return LOS_NOK;
-    }
-
-    SWTMR_CTRL_S *swtmr = &g_swtmrCBArray[swtmrID];
-    SWTMR_LOCK(intSave);
-    ret = memcpy_s(data, len, &g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData));
-    *mode = swtmr->ucMode;
-    SWTMR_UNLOCK(intSave);
-    if (ret != EOK) {
-        return LOS_NOK;
-    }
-    return LOS_OK;
-}
-#endif
-
-STATIC VOID SwtmrDebugDataInit(VOID)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    UINT32 size = sizeof(SwtmrDebugData) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
-    g_swtmrDebugData = (SwtmrDebugData *)LOS_MemAlloc(m_aucSysMem1, size);
-    if (g_swtmrDebugData == NULL) {
-        PRINT_ERR("SwtmrDebugDataInit malloc failed!\n");
-        return;
-    }
-    (VOID)memset_s(g_swtmrDebugData, size, 0, size);
-#endif
-}
-
-STATIC INLINE VOID SwtmrDebugDataUpdate(SWTMR_CTRL_S *swtmr, UINT32 ticks, UINT32 times)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
-    if (data->period != ticks) {
-        (VOID)memset_s(&data->base, sizeof(SwtmrDebugBase), 0, sizeof(SwtmrDebugBase));
-        data->period = ticks;
-    }
-    data->base.startTime = swtmr->startTime;
-    data->base.times += times;
-#endif
-}
-
-STATIC INLINE VOID SwtmrDebugDataStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
-    data->swtmrUsed = TRUE;
-    data->handler = swtmr->pfnHandler;
-    data->cpuid = cpuid;
-#endif
-}
-
-STATIC INLINE VOID SwtmrDebugWaitTimeCalculate(UINT32 swtmrID, SwtmrHandlerItemPtr swtmrHandler)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrID].base;
-    swtmrHandler->swtmrID = swtmrID;
-    UINT64 currTime = OsGetCurrSchedTimeCycle();
-    UINT64 waitTime = currTime - data->startTime;
-    data->waitTime += waitTime;
-    if (waitTime > data->waitTimeMax) {
-        data->waitTimeMax = waitTime;
-    }
-    data->readyStartTime = currTime;
-    data->waitCount++;
-#endif
-}
-
-STATIC INLINE VOID SwtmrDebugDataClear(UINT32 swtmrID)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    (VOID)memset_s(&g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData), 0, sizeof(SwtmrDebugData));
-#endif
-}
-
-STATIC INLINE VOID SwtmrHandler(SwtmrHandlerItemPtr swtmrHandle)
-{
-#ifdef LOSCFG_SWTMR_DEBUG
-    UINT32 intSave;
-    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrHandle->swtmrID].base;
-    UINT64 startTime = OsGetCurrSchedTimeCycle();
-#endif
-    swtmrHandle->handler(swtmrHandle->arg);
-#ifdef LOSCFG_SWTMR_DEBUG
-    UINT64 runTime = OsGetCurrSchedTimeCycle() - startTime;
-    SWTMR_LOCK(intSave);
-    data->runTime += runTime;
-    if (runTime > data->runTimeMax) {
-        data->runTimeMax = runTime;
-    }
-    runTime = startTime - data->readyStartTime;
-    data->readyTime += runTime;
-    if (runTime > data->readyTimeMax) {
-        data->readyTimeMax = runTime;
-    }
-    data->runCount++;
-    SWTMR_UNLOCK(intSave);
-#endif
-}
-
-STATIC INLINE VOID SwtmrWake(SwtmrRunqueue *srq, UINT64 startTime, SortLinkList *sortList)
-{
-    UINT32 intSave;
-    SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
-    SwtmrHandlerItemPtr swtmrHandler = (SwtmrHandlerItemPtr)LOS_MemboxAlloc(g_swtmrHandlerPool);
-    LOS_ASSERT(swtmrHandler != NULL);
-
-    OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
-
-    SWTMR_LOCK(intSave);
-    swtmrHandler->handler = swtmr->pfnHandler;
-    swtmrHandler->arg = swtmr->uwArg;
-    LOS_ListTailInsert(&srq->swtmrHandlerQueue, &swtmrHandler->node);
-    SwtmrDebugWaitTimeCalculate(swtmr->usTimerID, swtmrHandler);
-
-    if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) {
-        SwtmrDelete(swtmr);
-
-        if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
-            swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT;
-        } else {
-            swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
-        }
-    } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
-        swtmr->ucState = OS_SWTMR_STATUS_CREATED;
-    } else {
-        swtmr->uwOverrun++;
-        swtmr->startTime = startTime;
-        (VOID)SwtmrToStart(swtmr, ArchCurrCpuid());
-    }
-
-    SWTMR_UNLOCK(intSave);
-}
-
-STATIC INLINE VOID ScanSwtmrTimeList(SwtmrRunqueue *srq)
-{
-    UINT32 intSave;
-    SortLinkAttribute *swtmrSortLink = &srq->swtmrSortLink;
-    LOS_DL_LIST *listObject = &swtmrSortLink->sortLink;
-
-    /*
-     * it needs to be carefully coped with, since the swtmr is in specific sortlink
-     * while other cores still has the chance to process it, like stop the timer.
-     */
-    LOS_SpinLockSave(&swtmrSortLink->spinLock, &intSave);
-
-    if (LOS_ListEmpty(listObject)) {
-        LOS_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
-        return;
-    }
-    SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-
-    UINT64 currTime = OsGetCurrSchedTimeCycle();
-    while (sortList->responseTime <= currTime) {
-        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-        UINT64 startTime = GET_SORTLIST_VALUE(sortList);
-        OsDeleteNodeSortLink(swtmrSortLink, sortList);
-        LOS_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
-
-        SwtmrWake(srq, startTime, sortList);
-
-        LOS_SpinLockSave(&swtmrSortLink->spinLock, &intSave);
-        if (LOS_ListEmpty(listObject)) {
-            break;
-        }
-
-        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-    }
-
-    LOS_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
-    return;
-}
-
 STATIC VOID SwtmrTask(VOID)
 {
+    SwtmrHandlerItemPtr swtmrHandlePtr = NULL;
     SwtmrHandlerItem swtmrHandle;
-    UINT32 intSave;
-    UINT64 waitTime;
+    UINT32 ret, swtmrHandlerQueue;
 
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[ArchCurrCpuid()];
-    LOS_DL_LIST *head = &srq->swtmrHandlerQueue;
+    swtmrHandlerQueue = OsSchedSwtmrHandlerQueueGet();
     for (;;) {
-        waitTime = OsSortLinkGetNextExpireTime(OsGetCurrSchedTimeCycle(), &srq->swtmrSortLink);
-        if (waitTime != 0) {
-            SCHEDULER_LOCK(intSave);
-            srq->swtmrTask->ops->delay(srq->swtmrTask, waitTime);
-            OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, srq->swtmrTask);
-            SCHEDULER_UNLOCK(intSave);
-        }
-
-        ScanSwtmrTimeList(srq);
-
-        while (!LOS_ListEmpty(head)) {
-            SwtmrHandlerItemPtr swtmrHandlePtr = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(head), SwtmrHandlerItem, node);
-            LOS_ListDelete(&swtmrHandlePtr->node);
-
-            (VOID)memcpy_s(&swtmrHandle, sizeof(SwtmrHandlerItem), swtmrHandlePtr, sizeof(SwtmrHandlerItem));
+        ret = LOS_QueueRead(swtmrHandlerQueue, &swtmrHandlePtr, sizeof(CHAR *), LOS_WAIT_FOREVER);
+        if ((ret == LOS_OK) && (swtmrHandlePtr != NULL)) {
+            swtmrHandle.handler = swtmrHandlePtr->handler;
+            swtmrHandle.arg = swtmrHandlePtr->arg;
             (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandlePtr);
-            SwtmrHandler(&swtmrHandle);
+            if (swtmrHandle.handler != NULL) {
+                swtmrHandle.handler(swtmrHandle.arg);
+            }
         }
     }
 }
@@ -307,11 +94,6 @@ STATIC UINT32 SwtmrTaskCreate(UINT16 cpuid, UINT32 *swtmrTaskID)
     return ret;
 }
 
-UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid)
-{
-    return g_swtmrRunqueue[cpuid].swtmrTask->taskID;
-}
-
 BOOL OsIsSwtmrTask(const LosTaskCB *taskCB)
 {
     if (taskCB->taskEntry == (TSK_ENTRY_FUNC)SwtmrTask) {
@@ -320,67 +102,60 @@ BOOL OsIsSwtmrTask(const LosTaskCB *taskCB)
     return FALSE;
 }
 
-LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINTPTR ownerID)
+LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINT32 processID)
 {
     for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
-        if (g_swtmrCBArray[index].uwOwnerPid == ownerID) {
+        if (g_swtmrCBArray[index].uwOwnerPid == processID) {
             LOS_SwtmrDelete(index);
         }
     }
 }
 
-STATIC UINT32 SwtmrBaseInit(VOID)
-{
-    UINT32 ret;
-    UINT32 size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
-    SWTMR_CTRL_S *swtmr = (SWTMR_CTRL_S *)LOS_MemAlloc(m_aucSysMem0, size); /* system resident resource */
-    if (swtmr == NULL) {
-        return LOS_ERRNO_SWTMR_NO_MEMORY;
-    }
-
-    (VOID)memset_s(swtmr, size, 0, size);
-    g_swtmrCBArray = swtmr;
-    LOS_ListInit(&g_swtmrFreeList);
-    for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
-        swtmr->usTimerID = index;
-        LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
-    }
-
-    size = LOS_MEMBOX_SIZE(sizeof(SwtmrHandlerItem), OS_SWTMR_HANDLE_QUEUE_SIZE);
-    g_swtmrHandlerPool = (UINT8 *)LOS_MemAlloc(m_aucSysMem1, size); /* system resident resource */
-    if (g_swtmrHandlerPool == NULL) {
-        return LOS_ERRNO_SWTMR_NO_MEMORY;
-    }
-
-    ret = LOS_MemboxInit(g_swtmrHandlerPool, size, sizeof(SwtmrHandlerItem));
-    if (ret != LOS_OK) {
-        return LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
-    }
-
-    for (UINT16 index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
-        SwtmrRunqueue *srq = &g_swtmrRunqueue[index];
-        /* The linked list of all cores must be initialized at core 0 startup for load balancing */
-        OsSortLinkInit(&srq->swtmrSortLink);
-        LOS_ListInit(&srq->swtmrHandlerQueue);
-        srq->swtmrTask = NULL;
-    }
-
-    SwtmrDebugDataInit();
-
-    return LOS_OK;
-}
-
 LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
 {
+    UINT32 size;
+    UINT16 index;
     UINT32 ret;
+    SWTMR_CTRL_S *swtmr = NULL;
+    UINT32 swtmrHandlePoolSize;
     UINT32 cpuid = ArchCurrCpuid();
-    UINT32 swtmrTaskID;
+    UINT32 swtmrTaskID, swtmrHandlerQueue;
 
     if (cpuid == 0) {
-        ret = SwtmrBaseInit();
-        if (ret != LOS_OK) {
+        size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
+        swtmr = (SWTMR_CTRL_S *)LOS_MemAlloc(m_aucSysMem0, size); /* system resident resource */
+        if (swtmr == NULL) {
+            ret = LOS_ERRNO_SWTMR_NO_MEMORY;
             goto ERROR;
         }
+
+        (VOID)memset_s(swtmr, size, 0, size);
+        g_swtmrCBArray = swtmr;
+        LOS_ListInit(&g_swtmrFreeList);
+        for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
+            swtmr->usTimerID = index;
+            LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
+        }
+
+        swtmrHandlePoolSize = LOS_MEMBOX_SIZE(sizeof(SwtmrHandlerItem), OS_SWTMR_HANDLE_QUEUE_SIZE);
+
+        g_swtmrHandlerPool = (UINT8 *)LOS_MemAlloc(m_aucSysMem1, swtmrHandlePoolSize); /* system resident resource */
+        if (g_swtmrHandlerPool == NULL) {
+            ret = LOS_ERRNO_SWTMR_NO_MEMORY;
+            goto ERROR;
+        }
+
+        ret = LOS_MemboxInit(g_swtmrHandlerPool, swtmrHandlePoolSize, sizeof(SwtmrHandlerItem));
+        if (ret != LOS_OK) {
+            ret = LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
+            goto ERROR;
+        }
+    }
+
+    ret = LOS_QueueCreate(NULL, OS_SWTMR_HANDLE_QUEUE_SIZE, &swtmrHandlerQueue, 0, sizeof(CHAR *));
+    if (ret != LOS_OK) {
+        ret = LOS_ERRNO_SWTMR_QUEUE_CREATE_FAILED;
+        goto ERROR;
     }
 
     ret = SwtmrTaskCreate(cpuid, &swtmrTaskID);
@@ -389,88 +164,25 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
         goto ERROR;
     }
 
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
-    srq->swtmrTask = OsGetTaskCB(swtmrTaskID);
+    OsSchedRunQueSwtmrInit(swtmrTaskID, swtmrHandlerQueue);
     return LOS_OK;
 
 ERROR:
-    PRINT_ERR("OsSwtmrInit error! ret = %u\n", ret);
     (VOID)LOS_MemFree(m_aucSysMem0, g_swtmrCBArray);
     g_swtmrCBArray = NULL;
     (VOID)LOS_MemFree(m_aucSysMem1, g_swtmrHandlerPool);
     g_swtmrHandlerPool = NULL;
+    PRINT_ERR("OsSwtmrInit error! ret = %u\n", ret);
     return ret;
 }
 
-#ifdef LOSCFG_KERNEL_SMP
-STATIC INLINE VOID FindIdleSwtmrRunqueue(UINT16 *idleCpuid)
-{
-    SwtmrRunqueue *idleRq = &g_swtmrRunqueue[0];
-    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->swtmrSortLink);
-    UINT16 cpuid = 1;
-    do {
-        SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
-        UINT32 temp = OsGetSortLinkNodeNum(&srq->swtmrSortLink);
-        if (nodeNum > temp) {
-            *idleCpuid = cpuid;
-            nodeNum = temp;
-        }
-        cpuid++;
-    } while (cpuid < LOSCFG_KERNEL_CORE_NUM);
-}
-#endif
-
-STATIC INLINE VOID AddSwtmr2TimeList(SortLinkList *node, UINT64 responseTime, UINT16 cpuid)
-{
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
-    OsAdd2SortLink(&srq->swtmrSortLink, node, responseTime, cpuid);
-}
-
-STATIC INLINE VOID DeSwtmrFromTimeList(SortLinkList *node)
-{
-#ifdef LOSCFG_KERNEL_SMP
-    UINT16 cpuid = OsGetSortLinkNodeCpuid(node);
-#else
-    UINT16 cpuid = 0;
-#endif
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
-    OsDeleteFromSortLink(&srq->swtmrSortLink, node);
-    return;
-}
-
-STATIC VOID SwtmrAdjustCheck(UINT16 cpuid, UINT64 responseTime)
-{
-    UINT32 ret;
-    UINT32 intSave;
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
-    SCHEDULER_LOCK(intSave);
-    if ((srq->swtmrTask == NULL) || !OsTaskIsBlocked(srq->swtmrTask)) {
-        SCHEDULER_UNLOCK(intSave);
-        return;
-    }
-
-    if (responseTime >= GET_SORTLIST_VALUE(&srq->swtmrTask->sortList)) {
-        SCHEDULER_UNLOCK(intSave);
-        return;
-    }
-
-    ret = OsSchedTimeoutQueueAdjust(srq->swtmrTask, responseTime);
-    SCHEDULER_UNLOCK(intSave);
-    if (ret != LOS_OK) {
-        return;
-    }
-
-    if (cpuid == ArchCurrCpuid()) {
-        OsSchedExpireTimeUpdate();
-    } else {
-        LOS_MpSchedule(CPUID_TO_AFFI_MASK(cpuid));
-    }
-}
-
-STATIC UINT64 SwtmrToStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid)
+/*
+ * Description: Start Software Timer
+ * Input      : swtmr --- Need to start software timer
+ */
+LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr)
 {
     UINT32 ticks;
-    UINT32 times = 0;
 
     if ((swtmr->uwOverrun == 0) && ((swtmr->ucMode == LOS_SWTMR_MODE_ONCE) ||
         (swtmr->ucMode == LOS_SWTMR_MODE_OPP) ||
@@ -481,122 +193,75 @@ STATIC UINT64 SwtmrToStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid)
     }
     swtmr->ucState = OS_SWTMR_STATUS_TICKING;
 
-    UINT64 period = (UINT64)ticks * OS_CYCLE_PER_TICK;
-    UINT64 responseTime = swtmr->startTime + period;
-    UINT64 currTime = OsGetCurrSchedTimeCycle();
-    if (responseTime < currTime) {
-        times = (UINT32)((currTime - swtmr->startTime) / period);
-        swtmr->startTime += times * period;
-        responseTime = swtmr->startTime + period;
-        PRINT_WARN("Swtmr already timeout! SwtmrID: %u\n", swtmr->usTimerID);
-    }
-
-    AddSwtmr2TimeList(&swtmr->stSortList, responseTime, cpuid);
-    SwtmrDebugDataUpdate(swtmr, ticks, times);
-    return responseTime;
-}
-
-/*
- * Description: Start Software Timer
- * Input      : swtmr --- Need to start software timer
- */
-STATIC INLINE VOID SwtmrStart(SWTMR_CTRL_S *swtmr)
-{
-    UINT64 responseTime;
-    UINT16 idleCpu = 0;
-#ifdef LOSCFG_KERNEL_SMP
-    FindIdleSwtmrRunqueue(&idleCpu);
-#endif
-    swtmr->startTime = OsGetCurrSchedTimeCycle();
-    responseTime = SwtmrToStart(swtmr, idleCpu);
-
-    SwtmrDebugDataStart(swtmr, idleCpu);
-
-    SwtmrAdjustCheck(idleCpu, responseTime);
+    OsSchedAddSwtmr2TimeList(&swtmr->stSortList, swtmr->startTime, ticks);
+    OsSchedUpdateExpireTime();
+    return;
 }
 
 /*
  * Description: Delete Software Timer
  * Input      : swtmr --- Need to delete software timer, When using, Ensure that it can't be NULL.
  */
-STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr)
+STATIC INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr)
 {
     /* insert to free list */
     LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
     swtmr->ucState = OS_SWTMR_STATUS_UNUSED;
-    swtmr->uwOwnerPid = OS_INVALID_VALUE;
-
-    SwtmrDebugDataClear(swtmr->usTimerID);
+    swtmr->uwOwnerPid = 0;
 }
 
-STATIC INLINE VOID SwtmrRestart(UINT64 startTime, SortLinkList *sortList, UINT16 cpuid)
+VOID OsSwtmrWake(SchedRunQue *rq, UINT64 startTime, SortLinkList *sortList)
+{
+    SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
+
+    OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
+    LOS_SpinLock(&g_swtmrSpin);
+    SwtmrHandlerItemPtr swtmrHandler = (SwtmrHandlerItemPtr)LOS_MemboxAlloc(g_swtmrHandlerPool);
+    if (swtmrHandler != NULL) {
+        swtmrHandler->handler = swtmr->pfnHandler;
+        swtmrHandler->arg = swtmr->uwArg;
+
+        if (LOS_QueueWrite(rq->swtmrHandlerQueue, swtmrHandler, sizeof(CHAR *), LOS_NO_WAIT)) {
+            (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandler);
+        }
+    }
+
+    if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) {
+        OsSwtmrDelete(swtmr);
+
+        if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
+            swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT;
+        } else {
+            swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
+        }
+    } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
+        swtmr->ucState = OS_SWTMR_STATUS_CREATED;
+    } else {
+        swtmr->uwOverrun++;
+        swtmr->startTime = startTime;
+        OsSwtmrStart(swtmr);
+    }
+
+    LOS_SpinUnlock(&g_swtmrSpin);
+}
+
+VOID OsSwtmrRestart(UINT64 startTime, SortLinkList *sortList)
 {
     UINT32 intSave;
 
     SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
     SWTMR_LOCK(intSave);
     swtmr->startTime = startTime;
-    (VOID)SwtmrToStart(swtmr, cpuid);
+    OsSwtmrStart(swtmr);
     SWTMR_UNLOCK(intSave);
 }
 
-VOID OsSwtmrResponseTimeReset(UINT64 startTime)
-{
-    UINT16 cpuid = ArchCurrCpuid();
-    SortLinkAttribute *swtmrSortLink = &g_swtmrRunqueue[cpuid].swtmrSortLink;
-    LOS_DL_LIST *listHead = &swtmrSortLink->sortLink;
-    LOS_DL_LIST *listNext = listHead->pstNext;
-
-    LOS_SpinLock(&swtmrSortLink->spinLock);
-    while (listNext != listHead) {
-        SortLinkList *sortList = LOS_DL_LIST_ENTRY(listNext, SortLinkList, sortLinkNode);
-        OsDeleteNodeSortLink(swtmrSortLink, sortList);
-        LOS_SpinUnlock(&swtmrSortLink->spinLock);
-
-        SwtmrRestart(startTime, sortList, cpuid);
-
-        LOS_SpinLock(&swtmrSortLink->spinLock);
-        listNext = listNext->pstNext;
-    }
-    LOS_SpinUnlock(&swtmrSortLink->spinLock);
-}
-
-STATIC INLINE BOOL SwtmrRunqueueFind(SortLinkAttribute *swtmrSortLink, SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
-{
-    LOS_DL_LIST *listObject = &swtmrSortLink->sortLink;
-    LOS_DL_LIST *list = listObject->pstNext;
-
-    LOS_SpinLock(&swtmrSortLink->spinLock);
-    while (list != listObject) {
-        SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
-        if (checkFunc((UINTPTR)listSorted, arg)) {
-            LOS_SpinUnlock(&swtmrSortLink->spinLock);
-            return TRUE;
-        }
-        list = list->pstNext;
-    }
-
-    LOS_SpinUnlock(&swtmrSortLink->spinLock);
-    return FALSE;
-}
-
-STATIC BOOL SwtmrTimeListFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
-{
-    for (UINT16 cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
-        SortLinkAttribute *swtmrSortLink = &g_swtmrRunqueue[ArchCurrCpuid()].swtmrSortLink;
-        if (SwtmrRunqueueFind(swtmrSortLink, checkFunc, arg)) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
 BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
 {
     UINT32 intSave;
 
     SWTMR_LOCK(intSave);
-    BOOL find = SwtmrTimeListFind(checkFunc, arg);
+    BOOL find = OsSchedSwtmrTimeListFind(checkFunc, arg);
     SWTMR_UNLOCK(intSave);
     return find;
 }
@@ -608,8 +273,7 @@ BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
 LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
 {
     UINT64 currTime = OsGetCurrSchedTimeCycle();
-    SwtmrRunqueue *srq = &g_swtmrRunqueue[ArchCurrCpuid()];
-    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &srq->swtmrSortLink) / OS_CYCLE_PER_TICK);
+    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &OsSchedRunQue()->swtmrSortLink) / OS_CYCLE_PER_TICK);
     if (time > OS_INVALID_VALUE) {
         time = OS_INVALID_VALUE;
     }
@@ -620,12 +284,14 @@ LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
  * Description: Stop of Software Timer interface
  * Input      : swtmr --- the software timer control handler
  */
-STATIC VOID SwtmrStop(SWTMR_CTRL_S *swtmr)
+LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
 {
+    OsSchedDeSwtmrFromTimeList(&swtmr->stSortList);
+
     swtmr->ucState = OS_SWTMR_STATUS_CREATED;
     swtmr->uwOverrun = 0;
 
-    DeSwtmrFromTimeList(&swtmr->stSortList);
+    OsSchedUpdateExpireTime();
 }
 
 /*
@@ -680,7 +346,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
     LOS_ListDelete(LOS_DL_LIST_FIRST(&g_swtmrFreeList));
     SWTMR_UNLOCK(intSave);
 
-    swtmr->uwOwnerPid = (UINTPTR)OsCurrProcessGet();
+    swtmr->uwOwnerPid = OsCurrProcessGet()->processID;
     swtmr->pfnHandler = handler;
     swtmr->ucMode = mode;
     swtmr->uwOverrun = 0;
@@ -723,10 +389,11 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrID)
          * then start the swtmr again.
          */
         case OS_SWTMR_STATUS_TICKING:
-            SwtmrStop(swtmr);
+            OsSwtmrStop(swtmr);
             /* fall-through */
         case OS_SWTMR_STATUS_CREATED:
-            SwtmrStart(swtmr);
+            swtmr->startTime = OsGetCurrSchedTimeCycle();
+            OsSwtmrStart(swtmr);
             break;
         default:
             ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
@@ -766,7 +433,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrID)
             ret = LOS_ERRNO_SWTMR_NOT_STARTED;
             break;
         case OS_SWTMR_STATUS_TICKING:
-            SwtmrStop(swtmr);
+            OsSwtmrStop(swtmr);
             break;
         default:
             ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
@@ -844,10 +511,10 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT16 swtmrID)
             ret = LOS_ERRNO_SWTMR_NOT_CREATED;
             break;
         case OS_SWTMR_STATUS_TICKING:
-            SwtmrStop(swtmr);
+            OsSwtmrStop(swtmr);
             /* fall-through */
         case OS_SWTMR_STATUS_CREATED:
-            SwtmrDelete(swtmr);
+            OsSwtmrDelete(swtmr);
             break;
         default:
             ret = LOS_ERRNO_SWTMR_STATUS_INVALID;

kernel/base/core/los_task.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 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,9 +61,6 @@
 #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"
@@ -84,42 +81,28 @@ 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(VOID)
+LosTaskCB *OsGetMainTask()
 {
     return (LosTaskCB *)(g_mainTask + ArchCurrCpuid());
 }
 
-VOID OsSetMainTask(VOID)
+VOID OsSetMainTask()
 {
     UINT32 i;
     CHAR *name = "osMain";
-    SchedParam schedParam = { 0 };
-
-    schedParam.policy = LOS_SCHED_RR;
-    schedParam.basePrio = OS_PROCESS_PRIORITY_HIGHEST;
-    schedParam.priority = OS_TASK_PRIORITY_LOWEST;
 
     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].processCB = OS_KERNEL_PROCESS_GROUP;
+        g_mainTask[i].processID = OS_KERNEL_PROCESS_GROUP;
+        g_mainTask[i].basePrio = OS_TASK_PRIORITY_HIGHEST;
+        g_mainTask[i].priority = OS_TASK_PRIORITY_LOWEST;
 #ifdef LOSCFG_KERNEL_SMP_LOCKDEP
         g_mainTask[i].lockDep.lockDepth = 0;
         g_mainTask[i].lockDep.waitLock = NULL;
 #endif
         (VOID)strncpy_s(g_mainTask[i].taskName, OS_TCB_NAME_LEN, name, OS_TCB_NAME_LEN - 1);
         LOS_ListInit(&g_mainTask[i].lockList);
-        (VOID)OsSchedParamInit(&g_mainTask[i], schedParam.policy, &schedParam, NULL);
-    }
-}
-
-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
     }
 }
 
@@ -137,11 +120,13 @@ VOID OsTaskInsertToRecycleList(LosTaskCB *taskCB)
 
 LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB)
 {
+    LosTaskCB *resumedTask = NULL;
+
     if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
         if (!LOS_ListEmpty(&taskCB->joinList)) {
-            LosTaskCB *resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));
+            resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));
             OsTaskWakeClearPendMask(resumedTask);
-            resumedTask->ops->wake(resumedTask);
+            OsSchedTaskWake(resumedTask);
         }
     }
     taskCB->taskStatus |= OS_TASK_STATUS_EXIT;
@@ -159,8 +144,7 @@ LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB)
 
     if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) {
         OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER);
-        LosTaskCB *runTask = OsCurrTaskGet();
-        return runTask->ops->wait(runTask, &taskCB->joinList, LOS_WAIT_FOREVER);
+        return OsSchedTaskWait(&taskCB->joinList, LOS_WAIT_FOREVER, TRUE);
     }
 
     return LOS_EINVAL;
@@ -181,7 +165,7 @@ LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
     return LOS_EINVAL;
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
+LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
 {
     UINT32 index;
     UINT32 size;
@@ -205,14 +189,9 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
     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:
@@ -224,10 +203,10 @@ EXIT:
 
 UINT32 OsGetIdleTaskId(VOID)
 {
-    return OsSchedRunqueueIdleGet()->taskID;
+    return OsSchedGetRunQueIdle();
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
+LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
 {
     UINT32 ret;
     TSK_INIT_PARAM_S taskInitParam;
@@ -237,21 +216,18 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE;
     taskInitParam.pcName = "Idle";
-    taskInitParam.policy = LOS_SCHED_IDLE;
     taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;
-    taskInitParam.processID = processID;
+    taskInitParam.processID = OsGetIdleProcessID();
 #ifdef LOSCFG_KERNEL_SMP
     taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());
 #endif
     ret = LOS_TaskCreateOnly(&idleTaskID, &taskInitParam);
-    if (ret != LOS_OK) {
-        return ret;
-    }
     LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
     idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;
-    OsSchedRunqueueIdleInit(idleTask);
+    OsSchedRunQueIdleInit(idleTaskID);
+    OsSchedSetIdleTaskSchedParam(idleTask);
 
-    return LOS_TaskResume(idleTaskID);
+    return ret;
 }
 
 /*
@@ -268,7 +244,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
     return runTask->taskID;
 }
 
-STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
+STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
 {
 #ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
     UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);
@@ -328,14 +304,11 @@ 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);
 }
 
@@ -361,12 +334,12 @@ STATIC VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
         taskCB->userArea = 0;
         SCHEDULER_UNLOCK(intSave);
 
-        LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
+        LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
         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",
-                      processCB->processID, taskCB->taskID, mapBase, mapSize, ret);
+                      taskCB->processID, taskCB->taskID, mapBase, mapSize, ret);
         }
 
 #ifdef LOSCFG_KERNEL_LITEIPC
@@ -396,11 +369,12 @@ STATIC VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
 
 LITE_OS_SEC_TEXT VOID OsTaskCBRecycleToFree()
 {
+    LosTaskCB *taskCB = NULL;
     UINT32 intSave;
 
     SCHEDULER_LOCK(intSave);
     while (!LOS_ListEmpty(&g_taskRecycleList)) {
-        LosTaskCB *taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_taskRecycleList));
+        taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_taskRecycleList));
         LOS_ListDelete(&taskCB->pendList);
         SCHEDULER_UNLOCK(intSave);
 
@@ -417,6 +391,8 @@ LITE_OS_SEC_TEXT VOID OsTaskCBRecycleToFree()
  */
 LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
 {
+    LosTaskCB *taskCB = NULL;
+
     LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID));
 
     /*
@@ -427,7 +403,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
     LOS_SpinUnlock(&g_taskSpin);
     (VOID)LOS_IntUnLock();
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     taskCB->joinRetval = taskCB->taskEntry(taskCB->args[0], taskCB->args[1],
                                            taskCB->args[2], taskCB->args[3]); /* 2 & 3: just for args array index */
     if (!(taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN)) {
@@ -437,9 +413,11 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
     OsRunningTaskToExit(taskCB, 0);
 }
 
-STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
+LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
+    TSK_INIT_PARAM_S *initParam, VOID **pool)
 {
     UINT32 poolSize = OS_SYS_MEM_SIZE;
+    *pool = (VOID *)m_aucSysMem1;
 
     if (taskID == NULL) {
         return LOS_ERRNO_TSK_ID_INVALID;
@@ -449,7 +427,8 @@ STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initP
         return LOS_ERRNO_TSK_PTR_NULL;
     }
 
-    if (!OsProcessIsUserMode((LosProcessCB *)initParam->processID)) {
+    LosProcessCB *process = OS_PCB_FROM_PID(initParam->processID);
+    if (!OsProcessIsUserMode(process)) {
         if (initParam->pcName == NULL) {
             return LOS_ERRNO_TSK_NAME_EMPTY;
         }
@@ -479,52 +458,33 @@ STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initP
     return LOS_OK;
 }
 
-STATIC VOID TaskCBDeInit(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID **topStack, UINT32 stackSize, VOID *pool)
 {
-    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);
+    *topStack = (VOID *)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
 }
 
-STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
+LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInitBase(LosTaskCB *taskCB,
+                                                   const VOID *stackPtr,
+                                                   const VOID *topStack,
+                                                   const TSK_INIT_PARAM_S *initParam)
 {
-    taskCB->stackPointer = NULL;
+    taskCB->stackPointer = (VOID *)stackPtr;
     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)NULL;
+    taskCB->topOfStack   = (UINTPTR)topStack;
     taskCB->stackSize    = initParam->uwStackSize;
+    taskCB->priority     = initParam->usTaskPrio;
     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) ?
                             initParam->usCpuAffiMask : LOSCFG_KERNEL_CPU_MASK;
 #endif
+    taskCB->policy = (initParam->policy == LOS_SCHED_FIFO) ? LOS_SCHED_FIFO : LOS_SCHED_RR;
     taskCB->taskStatus = OS_TASK_STATUS_INIT;
     if (initParam->uwResved & LOS_TASK_ATTR_JOINABLE) {
         taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN;
@@ -533,30 +493,26 @@ STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
 
     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 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
+STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
+                           const VOID *stackPtr, const VOID *topStack)
 {
     UINT32 ret;
     UINT32 numCount;
-    SchedParam schedParam = { 0 };
-    UINT16 policy = (initParam->policy == LOS_SCHED_NORMAL) ? LOS_SCHED_RR : initParam->policy;
 
-    TaskCBBaseInit(taskCB, initParam);
+    OsTaskCBInitBase(taskCB, stackPtr, topStack, initParam);
 
-    schedParam.policy = policy;
-    ret = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam, &numCount);
-    if (ret != LOS_OK) {
-        return ret;
-    }
-
-    ret = OsSchedParamInit(taskCB, policy, &schedParam, initParam);
-    if (ret != LOS_OK) {
-        return ret;
+    numCount = OsProcessAddNewTask(initParam->processID, taskCB);
+#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);
     }
+#endif
 
     if (initParam->pcName != NULL) {
         ret = (UINT32)OsSetTaskName(taskCB, initParam->pcName, FALSE);
@@ -571,29 +527,10 @@ STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
     return LOS_OK;
 }
 
-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)
+LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
 {
     UINT32 intSave;
+    LosTaskCB *taskCB = NULL;
 
     SCHEDULER_LOCK(intSave);
     if (LOS_ListEmpty(&g_losFreeTask)) {
@@ -602,7 +539,7 @@ STATIC LosTaskCB *GetFreeTaskCB(VOID)
         return NULL;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_losFreeTask));
+    taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_losFreeTask));
     LOS_ListDelete(LOS_DL_LIST_FIRST(&g_losFreeTask));
     SCHEDULER_UNLOCK(intSave);
 
@@ -611,31 +548,39 @@ STATIC LosTaskCB *GetFreeTaskCB(VOID)
 
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
-    UINT32 errRet = TaskCreateParamCheck(taskID, initParam);
+    UINT32 intSave, errRet;
+    VOID *topStack = NULL;
+    VOID *stackPtr = NULL;
+    LosTaskCB *taskCB = NULL;
+    VOID *pool = NULL;
+
+    errRet = OsTaskCreateParamCheck(taskID, initParam, &pool);
     if (errRet != LOS_OK) {
         return errRet;
     }
 
-    LosTaskCB *taskCB = GetFreeTaskCB();
+    taskCB = OsGetFreeTaskCB();
     if (taskCB == NULL) {
-        return LOS_ERRNO_TSK_TCB_UNAVAILABLE;
+        errRet = LOS_ERRNO_TSK_TCB_UNAVAILABLE;
+        goto LOS_ERREND;
     }
 
-    errRet = TaskCBInit(taskCB, initParam);
+    errRet = OsTaskSyncCreate(taskCB);
     if (errRet != LOS_OK) {
-        goto DEINIT_TCB;
+        goto LOS_ERREND_REWIND_TCB;
     }
 
-    errRet = TaskSyncCreate(taskCB);
+    OsTaskStackAlloc(&topStack, initParam->uwStackSize, pool);
+    if (topStack == NULL) {
+        errRet = LOS_ERRNO_TSK_NO_MEMORY;
+        goto LOS_ERREND_REWIND_SYNC;
+    }
+
+    stackPtr = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
+    errRet = OsTaskCBInit(taskCB, initParam, stackPtr, topStack);
     if (errRet != LOS_OK) {
-        goto DEINIT_TCB;
+        goto LOS_ERREND_TCB_INIT;
     }
-
-    errRet = TaskStackInit(taskCB, initParam);
-    if (errRet != LOS_OK) {
-        goto DEINIT_TCB;
-    }
-
     if (OsConsoleIDSetHook != NULL) {
         OsConsoleIDSetHook(taskCB->taskID, OsCurrTaskGet()->taskID);
     }
@@ -644,8 +589,17 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S
     OsHookCall(LOS_HOOK_TYPE_TASK_CREATE, taskCB);
     return LOS_OK;
 
-DEINIT_TCB:
-    TaskCBDeInit(taskCB);
+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:
     return errRet;
 }
 
@@ -663,9 +617,9 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
     }
 
     if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        initParam->processID = (UINTPTR)OsGetKernelInitProcess();
+        initParam->processID = OsGetKernelInitProcessID();
     } else {
-        initParam->processID = (UINTPTR)OsCurrProcessGet();
+        initParam->processID = OsCurrProcessGet()->processID;
     }
 
     ret = LOS_TaskCreateOnly(taskID, initParam);
@@ -676,7 +630,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
     LosTaskCB *taskCB = OS_TCB_FROM_TID(*taskID);
 
     SCHEDULER_LOCK(intSave);
-    taskCB->ops->enqueue(OsSchedRunqueue(), taskCB);
+    OsSchedTaskEnQueue(taskCB);
     SCHEDULER_UNLOCK(intSave);
 
     /* in case created task not running on this core,
@@ -693,13 +647,13 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
 {
     UINT32 intSave;
     UINT32 errRet;
-    BOOL needSched = FALSE;
+    LosTaskCB *taskCB = NULL;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
         return LOS_ERRNO_TSK_ID_INVALID;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
 
     /* clear pending signal */
@@ -713,7 +667,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
         OS_GOTO_ERREND();
     }
 
-    errRet = taskCB->ops->resume(taskCB, &needSched);
+    BOOL needSched = OsSchedResume(taskCB);
     SCHEDULER_UNLOCK(intSave);
 
     LOS_MpSchedule(OS_MP_CPU_ALL);
@@ -721,7 +675,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
         LOS_Schedule();
     }
 
-    return errRet;
+    return LOS_OK;
 
 LOS_ERREND:
     SCHEDULER_UNLOCK(intSave);
@@ -769,7 +723,9 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
 LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
 {
     UINT32 errRet;
-    UINT16 tempStatus = taskCB->taskStatus;
+    UINT16 tempStatus;
+
+    tempStatus = taskCB->taskStatus;
     if (tempStatus & OS_TASK_STATUS_UNUSED) {
         return LOS_ERRNO_TSK_NOT_CREATED;
     }
@@ -783,19 +739,21 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
         return errRet;
     }
 
-    return taskCB->ops->suspend(taskCB);
+    OsSchedSuspend(taskCB);
+    return LOS_OK;
 }
 
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
 {
     UINT32 intSave;
+    LosTaskCB *taskCB = NULL;
     UINT32 errRet;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
         return LOS_ERRNO_TSK_ID_INVALID;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
         return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
     }
@@ -843,7 +801,7 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
 {
     UINT32 intSave;
 
-    if (OsIsProcessThreadGroup(runTask)) {
+    if (OsProcessThreadGroupIDGet(runTask) == runTask->taskID) {
         OsProcessThreadGroupDestroy();
     }
 
@@ -854,11 +812,11 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
         SCHEDULER_UNLOCK(intSave);
 
         OsTaskResourcesToFree(runTask);
-        OsProcessResourcesToFree(OS_PCB_FROM_TCB(runTask));
+        OsProcessResourcesToFree(OS_PCB_FROM_PID(runTask->processID));
 
         SCHEDULER_LOCK(intSave);
 
-        OsProcessNaturalExit(OS_PCB_FROM_TCB(runTask), status);
+        OsProcessNaturalExit(OS_PCB_FROM_PID(runTask->processID), status);
         OsTaskReleaseHoldLock(runTask);
         OsTaskStatusUnusedSet(runTask);
     } else if (runTask->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
@@ -884,11 +842,11 @@ LITE_OS_SEC_TEXT VOID OsInactiveTaskDelete(LosTaskCB *taskCB)
 
     OsTaskReleaseHoldLock(taskCB);
 
-    taskCB->ops->exit(taskCB);
+    OsSchedTaskExit(taskCB);
     if (taskStatus & OS_TASK_STATUS_PENDING) {
         LosMux *mux = (LosMux *)taskCB->taskMux;
         if (LOS_MuxIsValid(mux) == TRUE) {
-            OsMuxBitmapRestore(mux, NULL, taskCB);
+            OsMuxBitmapRestore(mux, taskCB, (LosTaskCB *)mux->owner);
         }
     }
 
@@ -914,17 +872,13 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
 
     LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
     if (taskCB == OsCurrTaskGet()) {
-        if (!OsPreemptable()) {
-            return LOS_ERRNO_TSK_DELETE_LOCKED;
-        }
-
         OsRunningTaskToExit(taskCB, OS_PRO_EXIT_OK);
         return LOS_NOK;
     }
 
     SCHEDULER_LOCK(intSave);
-    if (OsTaskIsNotDelete(taskCB)) {
-        if (OsTaskIsUnused(taskCB)) {
+    if (taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_FLAG_SYSTEM_TASK | OS_TASK_FLAG_NO_DELETE)) {
+        if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
             ret = LOS_ERRNO_TSK_NOT_CREATED;
         } else {
             ret = LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -946,22 +900,20 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
 
 LOS_ERREND:
     SCHEDULER_UNLOCK(intSave);
-    if (ret == LOS_OK) {
-        LOS_Schedule();
-    }
     return ret;
 }
 
 LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
 {
     UINT32 intSave;
+    LosTaskCB *runTask = NULL;
 
     if (OS_INT_ACTIVE) {
         PRINT_ERR("In interrupt not allow delay task!\n");
         return LOS_ERRNO_TSK_DELAY_IN_INT;
     }
 
-    LosTaskCB *runTask = OsCurrTaskGet();
+    runTask = OsCurrTaskGet();
     if (runTask->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
         OsBackTrace();
         return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -976,37 +928,39 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
     }
 
     SCHEDULER_LOCK(intSave);
-    UINT32 ret = runTask->ops->delay(runTask, OS_SCHED_TICK_TO_CYCLE(tick));
+    OsSchedDelay(runTask, tick);
     OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, runTask);
     SCHEDULER_UNLOCK(intSave);
-    return ret;
+
+    return LOS_OK;
 }
 
 LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
 {
     UINT32 intSave;
-    SchedParam param = { 0 };
+    LosTaskCB *taskCB = NULL;
+    UINT16 priority;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
         return (UINT16)OS_INVALID;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
         return (UINT16)OS_INVALID;
     }
 
-    taskCB->ops->schedParamGet(taskCB, &param);
+    priority = taskCB->priority;
     SCHEDULER_UNLOCK(intSave);
-    return param.priority;
+    return priority;
 }
 
 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
 {
     UINT32 intSave;
-    SchedParam param = { 0 };
+    LosTaskCB *taskCB = NULL;
 
     if (taskPrio > OS_TASK_PRIORITY_LOWEST) {
         return LOS_ERRNO_TSK_PRIOR_ERROR;
@@ -1016,7 +970,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
         return LOS_ERRNO_TSK_ID_INVALID;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
         return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
     }
@@ -1027,15 +981,11 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
         return LOS_ERRNO_TSK_NOT_CREATED;
     }
 
-    taskCB->ops->schedParamGet(taskCB, &param);
-
-    param.priority = taskPrio;
-
-    BOOL needSched = taskCB->ops->schedParamModify(taskCB, &param);
+    BOOL isReady = OsSchedModifyTaskSchedParam(taskCB, taskCB->policy, taskPrio);
     SCHEDULER_UNLOCK(intSave);
 
     LOS_MpSchedule(OS_MP_CPU_ALL);
-    if (needSched && OS_SCHEDULER_ACTIVE) {
+    if (isReady && OS_SCHEDULER_ACTIVE) {
         LOS_Schedule();
     }
     return LOS_OK;
@@ -1065,7 +1015,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID)
 
     SCHEDULER_LOCK(intSave);
     /* reset timeslice of yielded task */
-    runTask->ops->yield(runTask);
+    OsSchedYield();
     SCHEDULER_UNLOCK(intSave);
     return LOS_OK;
 }
@@ -1095,7 +1045,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_TaskUnlock(VOID)
 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskID, TSK_INFO_S *taskInfo)
 {
     UINT32 intSave;
-    SchedParam param = { 0 };
+    LosTaskCB *taskCB = NULL;
 
     if (taskInfo == NULL) {
         return LOS_ERRNO_TSK_PTR_NULL;
@@ -1105,7 +1055,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskID, TSK_INFO_S *taskInf
         return LOS_ERRNO_TSK_ID_INVALID;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
@@ -1118,9 +1068,8 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskID, TSK_INFO_S *taskInf
         taskInfo->uwSP = ArchSPGet();
     }
 
-    taskCB->ops->schedParamGet(taskCB, &param);
     taskInfo->usTaskStatus = taskCB->taskStatus;
-    taskInfo->usTaskPrio = param.priority;
+    taskInfo->usTaskPrio = taskCB->priority;
     taskInfo->uwStackSize = taskCB->stackSize;
     taskInfo->uwTopOfStack = taskCB->topOfStack;
     taskInfo->uwEventMask = taskCB->eventMask;
@@ -1164,6 +1113,7 @@ LITE_OS_SEC_TEXT BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMas
 
 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskID, UINT16 cpuAffiMask)
 {
+    LosTaskCB *taskCB = NULL;
     BOOL needSched = FALSE;
     UINT32 intSave;
     UINT16 currCpuMask;
@@ -1176,7 +1126,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskID, UINT16 cpuAffiMa
         return LOS_ERRNO_TSK_CPU_AFFINITY_MASK_ERR;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
@@ -1197,6 +1147,7 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskID)
 {
 #ifdef LOSCFG_KERNEL_SMP
 #define INVALID_CPU_AFFI_MASK   0
+    LosTaskCB *taskCB = NULL;
     UINT16 cpuAffiMask;
     UINT32 intSave;
 
@@ -1204,7 +1155,7 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskID)
         return INVALID_CPU_AFFI_MASK;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
@@ -1257,7 +1208,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsTaskProcSignal(VOID)
     } else if (runTask->signal & SIGNAL_AFFI) {
         runTask->signal &= ~SIGNAL_AFFI;
 
-        /* priority queue has updated, notify the target cpu */
+        /* pri-queue has updated, notify the target cpu */
         LOS_MpSchedule((UINT32)runTask->cpuAffiMask);
 #endif
     }
@@ -1294,8 +1245,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 (OsIsProcessThreadGroup(taskCB) && (setPName == TRUE)) {
-        err = (INT32)OsSetProcessName(OS_PCB_FROM_TCB(taskCB), (const CHAR *)taskCB->taskName);
+    if ((taskCB->taskID == OsProcessThreadGroupIDGet(taskCB)) && (setPName == TRUE)) {
+        err = (INT32)OsSetProcessName(OS_PCB_FROM_PID(taskCB->processID), (const CHAR *)taskCB->taskName);
         if (err != LOS_OK) {
             err = EINVAL;
         }
@@ -1308,16 +1259,16 @@ EXIT:
 
 INT32 OsUserTaskOperatePermissionsCheck(const LosTaskCB *taskCB)
 {
-    return OsUserProcessOperatePermissionsCheck(taskCB, (UINTPTR)OsCurrProcessGet());
+    return OsUserProcessOperatePermissionsCheck(taskCB, OsCurrProcessGet()->processID);
 }
 
-INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR processCB)
+INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 processID)
 {
     if (taskCB == NULL) {
         return LOS_EINVAL;
     }
 
-    if (processCB == (UINTPTR)OsGetDefaultProcessCB()) {
+    if (processID == OS_INVALID_VALUE) {
         return LOS_EINVAL;
     }
 
@@ -1325,7 +1276,7 @@ INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR proc
         return LOS_EINVAL;
     }
 
-    if (processCB != taskCB->processCB) {
+    if (processID != taskCB->processID) {
         return LOS_EPERM;
     }
 
@@ -1360,7 +1311,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID,
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam)
+LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam)
 {
     UINT32 taskID;
     UINT32 ret;
@@ -1377,7 +1328,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_
     if (processID == OS_INVALID_VALUE) {
         SCHEDULER_LOCK(intSave);
         LosProcessCB *processCB = OsCurrProcessGet();
-        initParam->processID = (UINTPTR)processCB;
+        initParam->processID = processCB->processID;
         initParam->consoleID = processCB->consoleID;
         SCHEDULER_UNLOCK(intSave);
     } else {
@@ -1396,22 +1347,21 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_
 LITE_OS_SEC_TEXT INT32 LOS_GetTaskScheduler(INT32 taskID)
 {
     UINT32 intSave;
+    LosTaskCB *taskCB = NULL;
     INT32 policy;
-    SchedParam param = { 0 };
 
     if (OS_TID_CHECK_INVALID(taskID)) {
         return -LOS_EINVAL;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         policy = -LOS_EINVAL;
         OS_GOTO_ERREND();
     }
 
-    taskCB->ops->schedParamGet(taskCB, &param);
-    policy = (INT32)param.policy;
+    policy = taskCB->policy;
 
 LOS_ERREND:
     SCHEDULER_UNLOCK(intSave);
@@ -1420,8 +1370,8 @@ LOS_ERREND:
 
 LITE_OS_SEC_TEXT INT32 LOS_SetTaskScheduler(INT32 taskID, UINT16 policy, UINT16 priority)
 {
-    SchedParam param = { 0 };
     UINT32 intSave;
+    BOOL needSched = FALSE;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
         return LOS_ESRCH;
@@ -1435,21 +1385,8 @@ LITE_OS_SEC_TEXT INT32 LOS_SetTaskScheduler(INT32 taskID, UINT16 policy, UINT16
         return LOS_EINVAL;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
-    if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
-        return LOS_EPERM;
-    }
-
     SCHEDULER_LOCK(intSave);
-    if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
-        SCHEDULER_UNLOCK(intSave);
-        return LOS_EINVAL;
-    }
-
-    taskCB->ops->schedParamGet(taskCB, &param);
-    param.policy = policy;
-    param.priority = priority;
-    BOOL needSched = taskCB->ops->schedParamModify(taskCB, &param);
+    needSched = OsSchedModifyTaskSchedParam(OS_TCB_FROM_TID(taskID), policy, priority);
     SCHEDULER_UNLOCK(intSave);
 
     LOS_MpSchedule(OS_MP_CPU_ALL);
@@ -1474,15 +1411,9 @@ STATIC UINT32 OsTaskJoinCheck(UINT32 taskID)
         return LOS_EINVAL;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
-    if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
-        return LOS_EPERM;
-    }
-
-    if (taskCB == OsCurrTaskGet()) {
+    if (taskID == OsCurrTaskGet()->taskID) {
         return LOS_EDEADLK;
     }
-
     return LOS_OK;
 }
 
@@ -1490,6 +1421,7 @@ UINT32 LOS_TaskJoin(UINT32 taskID, UINTPTR *retval)
 {
     UINT32 intSave;
     LosTaskCB *runTask = OsCurrTaskGet();
+    LosTaskCB *taskCB = NULL;
     UINT32 errRet;
 
     errRet = OsTaskJoinCheck(taskID);
@@ -1497,14 +1429,14 @@ UINT32 LOS_TaskJoin(UINT32 taskID, UINTPTR *retval)
         return errRet;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EINVAL;
     }
 
-    if (runTask->processCB != taskCB->processCB) {
+    if (runTask->processID != taskCB->processID) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EPERM;
     }
@@ -1530,6 +1462,7 @@ UINT32 LOS_TaskDetach(UINT32 taskID)
 {
     UINT32 intSave;
     LosTaskCB *runTask = OsCurrTaskGet();
+    LosTaskCB *taskCB = NULL;
     UINT32 errRet;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
@@ -1540,14 +1473,14 @@ UINT32 LOS_TaskDetach(UINT32 taskID)
         return LOS_EINTR;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+    taskCB = OS_TCB_FROM_TID(taskID);
     SCHEDULER_LOCK(intSave);
     if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EINVAL;
     }
 
-    if (runTask->processCB != taskCB->processCB) {
+    if (runTask->processID != taskCB->processID) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EPERM;
     }
@@ -1567,11 +1500,6 @@ 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);