本篇关键词:、、、

下载 >> 离线文档.鸿蒙内核源码分析(百篇博客分析.挖透鸿蒙内核).pdf

进程管理相关篇为:

系列篇从内核视角用一句话概括shell的底层实现为:两个任务,三个阶段。其本质是独立进程,因而划到进程管理模块。每次创建shell进程都会再创建两个任务。

  • 客户端任务(ShellEntry): 负责接受来自终端(控制台)敲入的一个个字符,字符按VT规范组装成一句句的命令。
  • 服务端任务(ShellTask): 对命令进行解析并执行,将结果输出到控制台。 而按命令生命周期可分三个阶段。
  • 编辑: 鸿蒙在这个部分实现了一个简单的编辑器功能,处理控制台输入的每个字符,主要包括了对控制字符 例如 <ESC>\t\b\n\r,四个方向键0x41 ~ 0x44 的处理。
  • 解析: 对编辑后的字符串进行解析,解析出命令项和参数项,找到对应的命令项执行函数。
  • 执行: 命令可通过静态和动态两种方式注册到内核,解析出具体命令后在注册表中找到对应函数回调。将结果输出到控制台。

编辑部分由客户端任务完成,后两个部分由服务端任务完成,命令全局注册由内核完成。

  • 本篇主要说 服务端任务解析/执行过程
  • 客户端任务编辑过程 已在(Shell编辑篇)中说明,请自行翻看。

总体过程

  • 第一步: 将支持的shell命令注册进全局链表,支持静态和动态两种方式,内容包括命令项,参数信息和回调函数。
  • 第二步: 由独立任务解析出用户输入的命令行,拆分出命令项和参数内容
  • 第三步: 通过命令项在全局链表中遍历找到已注册的回调函数,并执行。

结构体

鸿蒙对命令的注册用了三个结构体,个人感觉前两个可以合成一个,降低代码阅读难度。

STATIC CmdModInfo g_cmdInfo;//shell 命令模块信息,上面挂了所有的命令项(ls,cd ,cp ==)

typedef struct {//命令项
    CmdType cmdType;	//命令类型
		//CMD_TYPE_EX:不支持标准命令参数输入,会把用户填写的命令关键字屏蔽掉,例如:输入ls /ramfs,传入给注册函数的参数只有/ramfs,而ls命令关键字并不会被传入。
		//CMD_TYPE_STD:支持的标准命令参数输入,所有输入的字符都会通过命令解析后被传入。
    const CHAR *cmdKey;	//命令关键字,例如:ls 函数在Shell中访问的名称。
    UINT32 paraNum;		//调用的执行函数的入参最大个数,暂不支持。
    CmdCallBackFunc cmdHook;//命令执行函数地址,即命令实际执行函数。
} CmdItem;
typedef struct {	//命令节点
    LOS_DL_LIST list;	//双向链表
    CmdItem *cmd;	//命令项
} CmdItemNode;

/* global info for shell module */
typedef struct {//shell 模块的全局信息
    CmdItemNode cmdList;	//命令项节点
    UINT32 listNum;//节点数量
    UINT32 initMagicFlag;//初始魔法标签 0xABABABAB
    LosMux muxLock;	//操作链表互斥锁
    CmdVerifyTransID transIdHook;//暂不知何意
} CmdModInfo;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

解读

  • CmdItem为注册的内容载体结构体,cmdHook为回调函数,是命令的真正执行体。
  • 通过双向链表CmdItemNode.list将所有命令穿起来
  • CmdModInfo记录命令数量和操作的互斥锁,shell的魔法数字为 0xABABABAB

第一步 | Shell 注册

  • 静态宏方式注册,链接时处理 静态注册命令方式一般用在系统常用命令注册,鸿蒙已支持以下命令。

        arp           cat           cd            chgrp         chmod         chown         cp            cpup          
        date          dhclient      dmesg         dns           format        free          help          hwi           
        ifconfig      ipdebug       kill          log           ls            lsfd          memcheck      mkdir         
        mount         netstat       oom           partinfo      partition     ping          ping6         pwd           
        reset         rm            rmdir         sem           statfs        su            swtmr         sync          
        systeminfo    task          telnet        test          tftp          touch         umount        uname         
        watch         writeproc  
    
    1
    2
    3
    4
    5
    6
    7

    例如注册 ls命令

    SHELLCMD_ENTRY(ls_shellcmd,  CMD_TYPE_EX, "ls", XARGS,  (CMD_CBK_FUNC)osShellCmdLs)
    
    1

    需在链接选项中添加链接该新增命令项参数,具体在liteos_tables_ldflags.mk文件的LITEOS_TABLES_LDFLAGS项下添加-uls_shellcmd。至于SHELLCMD_ENTRY是如何实现的在链接阶段的注册,请自行翻看(内联汇编篇),有详细说明实现细节。

  • 动态命令方式,运行时处理 动态注册命令方式一般用在用户命令注册,具体实现代码如下:

    osCmdReg(CMD_TYPE_EX, "ls", XARGS,  (CMD_CBK_FUNC)osShellCmdLs)
    {
        // ....
        //5.正式创建命令,挂入链表
        return OsCmdItemCreate(cmdType, cmdKey, paraNum, cmdProc);//不存在就注册命令
    }
    //创建一个命令项,例如 chmod
    STATIC UINT32 OsCmdItemCreate(CmdType cmdType, const CHAR *cmdKey, UINT32 paraNum, CmdCallBackFunc cmdProc)
    {
        CmdItem *cmdItem = NULL;
        CmdItemNode *cmdItemNode = NULL;
        //1.构造命令节点过程
        cmdItem = (CmdItem *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdItem));
        if (cmdItem == NULL) {
            return OS_ERRNO_SHELL_CMDREG_MEMALLOC_ERROR;
        }
        (VOID)memset_s(cmdItem, sizeof(CmdItem)'\0'sizeof(CmdItem));
    
        cmdItemNode = (CmdItemNode *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdItemNode));
        if (cmdItemNode == NULL) {
            (VOID)LOS_MemFree(m_aucSysMem0, cmdItem);
            return OS_ERRNO_SHELL_CMDREG_MEMALLOC_ERROR;
        }
        (VOID)memset_s(cmdItemNode, sizeof(CmdItemNode)'\0'sizeof(CmdItemNode));
        cmdItemNode->cmd = cmdItem;			//命令项 
        cmdItemNode->cmd->cmdHook = cmdProc;//回调函数 osShellCmdLs
        cmdItemNode->cmd->paraNum = paraNum;//`777`,'/home'
        cmdItemNode->cmd->cmdType = cmdType;//关键字类型
        cmdItemNode->cmd->cmdKey = cmdKey;	//`chmod`
        //2.完成构造后挂入全局链表
        (VOID)LOS_MuxLock(&g_cmdInfo.muxLock, LOS_WAIT_FOREVER);
        OsCmdAscendingInsert(cmdItemNode);//按升序方式插入
        g_cmdInfo.listNum++;//命令总数增加
        (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
    
        return LOS_OK;
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37

第二步 解析 | ShellTask

//shell 服务端任务初始化,这个任务负责解析和执行命令
LITE_OS_SEC_TEXT_MINOR UINT32 ShellTaskInit(ShellCB *shellCB)
{
    CHAR *name = NULL;
    TSK_INIT_PARAM_S initParam = {0};
	//输入Shell命令的两种方式
    if (shellCB->consoleID == CONSOLE_SERIAL) {	//通过串口工具
        name = SERIAL_SHELL_TASK_NAME;
    } else if (shellCB->consoleID == CONSOLE_TELNET) {//通过远程工具
        name = TELNET_SHELL_TASK_NAME;
    } else {
        return LOS_NOK;
    }

    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)ShellTask;//任务入口函数,主要是解析shell命令
    initParam.usTaskPrio   = 9; /* 9:shell task priority */
    initParam.auwArgs[0]   = (UINTPTR)shellCB;
    initParam.uwStackSize  = 0x3000;
    initParam.pcName       = name;
    initParam.uwResved     = LOS_TASK_STATUS_DETACHED;

    (VOID)LOS_EventInit(&shellCB->shellEvent);//初始化事件,以事件方式通知任务解析命令

    return LOS_TaskCreate(&shellCB->shellTaskHandle, &initParam);//创建任务
}
LITE_OS_SEC_TEXT_MINOR UINT32 ShellTask(UINTPTR param1,
                                        UINTPTR param2,
                                        UINTPTR param3,
                                        UINTPTR param4)
{
    UINT32 ret;
    ShellCB *shellCB = (ShellCB *)param1;
    (VOID)param2;
    (VOID)param3;
    (VOID)param4;

    while (1) {
        PRINTK("\nOHOS # ");//读取shell 输入事件 例如: cat weharmony.net 命令
        ret = LOS_EventRead(&shellCB->shellEvent,
                            0xFFF, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
        if (ret == SHELL_CMD_PARSE_EVENT) {//获得解析命令事件
            ShellCmdProcess(shellCB);//处理命令 
        } else if (ret == CONSOLE_SHELL_KEY_EVENT) {//退出shell事件
            break;
        }
    }
    OsShellKeyDeInit((CmdKeyLink *)shellCB->cmdKeyLink);//
    OsShellKeyDeInit((CmdKeyLink *)shellCB->cmdHistoryKeyLink);
    (VOID)LOS_EventDestroy(&shellCB->shellEvent);//注销事件
    (VOID)LOS_MemFree((VOID *)m_aucSysMem0, shellCB);//释放shell控制块
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

解读

  • 任务优先级和 客户端任务 一样同为 9

  • 指定内核栈大小为0x3000 = 12K ,因任务负责命令的解析和执行,所以需要更大的内核空间。

  • 任务的入口函数ShellTask,一个死循环在以LOS_WAIT_FOREVER方式死等事件发生。

    • SHELL_CMD_PARSE_EVENT 通知开始解析事件,该事件由 客户端任务ShellEntry检测到回车键时发出。
      STATIC VOID ShellNotify(ShellCB *shellCB)
      {
          (VOID)LOS_EventWrite(&shellCB->shellEvent, SHELL_CMD_PARSE_EVENT);
      }
    
    1
    2
    3
    4
    • CONSOLE_SHELL_KEY_EVENT 收到 exit命令时将发出该事件,退出shell回收资源 鸿蒙内核是如何管理和使用事件的请自行翻看(事件控制篇)
  • 层层跟进ShellCmdProcess,解析出命令项和参数内容,最终跑到OsCmdExec中遍历 已注册的命令表,找出命令对应的函数完成回调。

    LITE_OS_SEC_TEXT_MINOR UINT32 OsCmdExec(CmdParsed *cmdParsed, CHAR *cmdStr)
      {
          UINT32 ret;
          CmdCallBackFunc cmdHook = NULL;
          CmdItemNode *curCmdItem = NULL;
          UINT32 i;
          const CHAR *cmdKey = NULL;
    
          if ((cmdParsed == NULL) || (cmdStr == NULL) || (strlen(cmdStr) == 0)) {
              return (UINT32)OS_ERROR;
          }
    
          ret = OsCmdParse(cmdStr, cmdParsed);//解析出命令关键字,参数
          if (ret != LOS_OK) {
              goto OUT;
          }
          //遍历命令注册全局链表
          LOS_DL_LIST_FOR_EACH_ENTRY(curCmdItem, &(g_cmdInfo.cmdList.list), CmdItemNode, list) {
              cmdKey = curCmdItem->cmd->cmdKey;
              if ((cmdParsed->cmdType == curCmdItem->cmd->cmdType) &&
                  (strlen(cmdKey) == strlen(cmdParsed->cmdKeyword)) &&
                  (strncmp(cmdKey, (CHAR *)(cmdParsed->cmdKeyword)strlen(cmdKey)) == 0)) {//找到命令的回调函数 例如: ls <-> osShellCmdLs
                  cmdHook = curCmdItem->cmd->cmdHook;
                  break;
              }
          }
    
          ret = OS_ERROR;
          if (cmdHook != NULL) {//执行命令,即回调函数
              ret = (cmdHook)(cmdParsed->paramCnt, (const CHAR **)cmdParsed->paramArray);
          }
    
      OUT:
          for (i = 0; i < cmdParsed->paramCnt; i++) {//无效的命令要释放掉保存参数的内存
              if (cmdParsed->paramArray[i] != NULL) {
                  (VOID)LOS_MemFree(m_aucSysMem0, cmdParsed->paramArray[i]);
                  cmdParsed->paramArray[i] = NULL;
              }
          }
    
          return (UINT32)ret;
      }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42

第三步 | 执行

想知道有哪些系统shell命令,可以搜索关键词SHELLCMD_ENTRY拿到所有通过静态方式注册的命令。 其中有网络的,进程的,任务的,内存的 等等,此处列出几个常用的shell命令的实现。

ls 命令

SHELLCMD_ENTRY(ls_shellcmd, CMD_TYPE_EX, "ls", XARGS, (CmdCallBackFunc)osShellCmdLs);

/*******************************************************
命令功能
ls命令用来显示当前目录的内容。

命令格式
ls [path]

path为空时,显示当前目录的内容。
path为无效文件名时,显示失败,提示:
ls error: No such directory。
path为有效目录路径时,会显示对应目录下的内容。

使用指南
ls命令显示当前目录的内容。
ls可以显示文件的大小。
proc下ls无法统计文件大小,显示为0。

*******************************************************/
int osShellCmdLs(int argc, const char **argv)
{
  char *fullpath = NULL;
  const char *filename = NULL;
  int ret;
  char *shell_working_directory = OsShellGetWorkingDirtectory();//获取当前工作目录
  if (shell_working_directory == NULL)
    {
      return -1;
    }

  ERROR_OUT_IF(argc > 1PRINTK("ls or ls [DIRECTORY]\n")return -1);

  if (argc == 0)//木有参数时 -> #ls 
    {
      ls(shell_working_directory);//执行ls 当前工作目录
      return 0;
    }

  filename = argv[0];//有参数时 -> #ls ../harmony  or #ls /no such file or directory
  ret = vfs_normalize_path(shell_working_directory, filename, &fullpath);//获取全路径,注意这里带出来fullpath,而fullpath已经在内核空间
  ERROR_OUT_IF(ret < 0set_err(-ret, "ls error")return -1);

  ls(fullpath);//执行 ls 全路径
  free(fullpath);//释放全路径,为啥要释放,因为fullpath已经由内核空间分配

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

task 命令

SHELLCMD_ENTRY(task_shellcmd, CMD_TYPE_EX, "task"1(CmdCallBackFunc)OsShellCmdDumpTask);

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

    if (argc >= 2) { /* 2: The task shell name restricts the parameters */
        goto TASK_HELP;
    }

    if (argc == 1) {
        if (strcmp("-a", argv[0]) == 0) {
            flag |= OS_PROCESS_INFO_ALL;
        } else if (strcmp("-i", argv[0]) == 0) {
            if (!OsShellShowTickRespo()) {
                return LOS_OK;
            }
            goto TASK_HELP;
        } else if (strcmp("-t", argv[0]) == 0) {
            if (!OsShellShowSchedParam()) {
                return LOS_OK;
            }
            goto TASK_HELP;
        } else {
            goto TASK_HELP;
        }
    }

    return OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, flag);

TASK_HELP:
    PRINTK("Unknown option: %s\n", argv[0]);
    PRINTK("usage: task or task -a\n");
    return LOS_NOK;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

cat 命令

SHELLCMD_ENTRY(cat_shellcmd, CMD_TYPE_EX, "cat", XARGS, (CmdCallBackFunc)osShellCmdCat);

/*****************************************************************
cat用于显示文本文件的内容.cat [pathname]
cat weharmony.txt
*****************************************************************/
int osShellCmdCat(int argc, const char **argv)
{
  char *fullpath = NULL;
  int ret;
  unsigned int ca_task;
  struct Vnode *vnode = NULL;
  TSK_INIT_PARAM_S init_param;
  char *shell_working_directory = OsShellGetWorkingDirtectory();//显示当前目录 pwd
  if (shell_working_directory == NULL)
    {
      return -1;
    }

  ERROR_OUT_IF(argc != 1PRINTK("cat [FILE]\n")return -1);

  ret = vfs_normalize_path(shell_working_directory, argv[0]&fullpath);//由相对路径获取绝对路径
  ERROR_OUT_IF(ret < 0set_err(-ret, "cat error")return -1);

  VnodeHold();
  ret = VnodeLookup(fullpath, &vnode, O_RDONLY);
    if (ret != LOS_OK)
      {
        set_errno(-ret);
        perror("cat error");
        VnodeDrop();
        free(fullpath);
        return -1;
      }
    if (vnode->type != VNODE_TYPE_REG)
      {
        set_errno(EINVAL);
        perror("cat error");
        VnodeDrop();
        free(fullpath);
        return -1;
      }
  VnodeDrop();
  (void)memset_s(&init_param, sizeof(init_param)0sizeof(TSK_INIT_PARAM_S));
  init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)osShellCmdDoCatShow;
  init_param.usTaskPrio   = CAT_TASK_PRIORITY;	//优先级10
  init_param.auwArgs[0]   = (UINTPTR)fullpath;	//入口参数
  init_param.uwStackSize  = CAT_TASK_STACK_SIZE;//内核栈大小
  init_param.pcName       = "shellcmd_cat";	//任务名称
  init_param.uwResved     = LOS_TASK_STATUS_DETACHED | OS_TASK_FLAG_SPECIFIES_PROCESS;
  init_param.processID    = 2; /* 2: kProcess */ //内核任务

  ret = (int)LOS_TaskCreate(&ca_task, &init_param);//创建任务显示cat内容

  if (ret != LOS_OK)
    {
      free(fullpath);
    }

  return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

你能看明白这些命令的底层实现吗? 如果看明白了,可能会不由得发出 原来如此 的感叹!

百文说内核 | 抓住主脉络

  • 百文相当于摸出内核的肌肉和器官系统,让人开始丰满有立体感,因是直接从注释源码起步,在加注释过程中,每每有心得处就整理,慢慢形成了以下文章。内容立足源码,常以生活场景打比方尽可能多的将内核知识点置入某种场景,具有画面感,容易理解记忆。说别人能听得懂的话很重要! 百篇博客绝不是百度教条式的在说一堆诘屈聱牙的概念,那没什么意思。更希望让内核变得栩栩如生,倍感亲切。
  • 与代码需不断debug一样,文章内容会存在不少错漏之处,请多包涵,但会反复修正,持续更新,v**.xx 代表文章序号和修改的次数,精雕细琢,言简意赅,力求打造精品内容。
  • 百文在 < 鸿蒙研究站 | 开源中国 | 博客园 | 51cto | csdn | 知乎 | 掘金 > 站点发布,百篇博客系列目录如下。

按功能模块:

基础知识 进程管理 任务管理 内存管理
双向链表
内核概念
源码结构
地址空间
计时单位
优雅的宏
钩子框架
位图管理
POSIX
main函数
调度故事
进程控制块
进程空间
线性区
红黑树
进程管理
Fork进程
进程回收
Shell编辑
Shell解析
任务控制块
并发并行
就绪队列
调度机制
任务管理
用栈方式
软件定时器
控制台
远程登录
协议栈
内存规则
物理内存
内存概念
虚实映射
页表管理
静态分配
TLFS算法
内存池管理
原子操作
圆整对齐
通讯机制 文件系统 硬件架构 内核汇编
通讯总览
自旋锁
互斥锁
快锁使用
快锁实现
读写锁
信号量
事件机制
信号生产
信号消费
消息队列
消息封装
消息映射
共享内存
文件概念
文件故事
索引节点
VFS
文件句柄
根文件系统
挂载机制
管道文件
文件映射
写时拷贝
芯片模式
ARM架构
指令集
协处理器
工作模式
寄存器
多核管理
中断概念
中断管理
编码方式
汇编基础
汇编传参
链接脚本
内核启动
进程切换
任务切换
中断切换
异常接管
缺页中断
编译运行 调测工具
编译过程
编译构建
GN语法
忍者无敌
ELF格式
ELF解析
静态链接
重定位
动态链接
进程映像
应用启动
系统调用
VDSO
模块监控
日志跟踪
系统安全
测试用例

百万注源码 | 处处扣细节

  • 百万汉字注解内核目的是要看清楚其毛细血管,细胞结构,等于在拿放大镜看内核。内核并不神秘,带着问题去源码中找答案是很容易上瘾的,你会发现很多文章对一些问题的解读是错误的,或者说不深刻难以自圆其说,你会慢慢形成自己新的解读,而新的解读又会碰到新的问题,如此层层递进,滚滚向前,拿着放大镜根本不愿意放手。

  • < gitee | github | coding | gitcode > 四大码仓推送 | 同步官方源码。

关注不迷路 | 代码即人生

期间不断得到小伙伴的支持,有学生,有职场新人,也有老江湖,在此一并感谢,大家的支持是前进的动力。尤其每次收到学生的赞助很感慨,后生可敬。 >> 查看捐助名单

据说喜欢 点赞 + 分享 的,后来都成了大神。😃