随笔、FinSH原理浅析

发布于 2023-01-25 19:44:16 浏览：1758 订阅该版

[tocm]

## 前置条件
[FinSH 简介](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/finsh/finsh?id=finsh-%e7%ae%80%e4%bb%8b)
[RT-Thread 自动初始化机制详解](https://club.rt-thread.org/ask/article/d686458bbba864f4.html)
## 详细分析
一直想弄懂FinSH是怎么扫描内部函数表，并执行相应函数的，看了自动初始化后，终于有了点头绪

![screenshot_FinSH命令执行流程图.png](https://oss-club.rt-thread.org/uploads/20230125/5f6ed29a6914f4e01f075633a8357950.png.webp)
先展开`MSH_CMD_EXPORT (finsh.h，落后版本可能在finsh_api.h)`
源宏定义
```c
#define MSH_CMD_EXPORT(command, desc)   \
    FINSH_FUNCTION_EXPORT_CMD(command, __cmd_##command, desc)

#define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc)      \
	const char __fsym_##cmd##_name[] SECTION(".rodata.name") = #cmd;   \
	const char __fsym_##cmd##_desc[] SECTION(".rodata.name") = #desc;  \
	const struct finsh_syscall __fsym_##cmd SECTION("FSymTab")= \
	{                           \
		__fsym_##cmd##_name,    \
		__fsym_##cmd##_desc,    \
		(syscall_func)&name     \
	};

```
举个例子MSH_CMD_EXPORT(msh_test, this is a msh test)
展开后
```c
FINSH_FUNCTION_EXPORT_CMD(msh_test, __cmd_msh_test, this is a msh test)
/*再展开*/
const char __fsym___cmd_msh_test_name[] SECTION(".rodata.name") = "__cmd_msh_test";
const char __fsym___cmd_msh_test_desc[] SECTION(".rodata.name") = "this is a msh test";
const struct finsh_syscall __fsym___cmd_msh_test SECTION("FSymTab")= 
	{                           
		__fsym___cmd_msh_test_name,/* "__cmd_msh_test" */
		__fsym___cmd_msh_test_desc,/* "this is a msh test" */    
		(syscall_func)&msh_test     
	};
```
再看看`finsh_syscall`和`syscall_func (finsh.h)`
```c
/*函数指针*/
typedef long (*syscall_func)(void);
/* system call table */
struct finsh_syscall
{
    const char*     name;       /* the name of system call */
#if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB)
    const char*     desc;       /* description of system call */
#endif
    syscall_func func;      /* the function address of system call */
};
extern struct finsh_syscall *_syscall_table_begin, *_syscall_table_end;
```
再看看finsh的初始化与线程创建函数`finsh_system_init (shell.c)`，（gcc下）我删减后的（解析都在注释里）
```c
int finsh_system_init(void)
{
    rt_err_t result = RT_EOK;
    rt_thread_t tid;

/* GNU GCC Compiler and TI CCS */
    extern const int __fsymtab_start;
    extern const int __fsymtab_end;
    extern const int __vsymtab_start;
    extern const int __vsymtab_end;
/* 上面四个变量是链接脚本导出的符号，在ROM区，具体如下图 */
/* 初始化全局变量_syscall_table_begin(函数表结构体头)和_syscall_table_end(函数表结构体尾)*/
    finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
/* 导出变量，与导出函数类似 */
    finsh_system_var_init(&__vsymtab_start, &__vsymtab_end);
    /* create or set shell structure */
    /*shell 主要存放控制台相关，此处仅列举几种
	  *shell->line[FINSH_CMD_SIZE]：当前行输入
	  *shell->rx_sem：控制台串口信号量
	  *shell->device:控制台串口设备
	  */
    shell = (struct finsh_shell *)rt_calloc(1, sizeof(struct finsh_shell));

/*创建finsh线程，当信号量被释放后读取串口数据，存储解析*/
    tid = rt_thread_create(FINSH_THREAD_NAME,
                           finsh_thread_entry, RT_NULL,
                           FINSH_THREAD_STACK_SIZE, FINSH_THREAD_PRIORITY, 10);
    /*初始化信号量，再串口中断中释放*/
    rt_sem_init(&(shell->rx_sem), "shrx", 0, 0);
    rt_thread_startup(tid);
    return 0;
}
/*自动初始化*/
INIT_APP_EXPORT(finsh_system_init);
```
上面提到的`finsh_system_function_init`
```c
void finsh_system_function_init(const void *begin, const void *end)
{
    _syscall_table_begin = (struct finsh_syscall *) begin;
    _syscall_table_end = (struct finsh_syscall *) end;
}
```
上面提到的`extern const int __fsymtab_start`等变量在链接脚本中的体现

![screenshot_finsh链接脚本部分.png](https://oss-club.rt-thread.org/uploads/20230125/f0e447ae08f82ad9c1ea4971f15a5d43.png)
再看看finsh线程`finsh_thread_entry (shell.c)`，只看是怎么扫描并执行函数的部分，
同样大量删减后的，解析全在注释里
```c
void finsh_thread_entry(void *parameter)
{
	char ch;
	rt_kprintf(FINSH_PROMPT);/* 输出msh> */
	while (1)
	{
		ch = finsh_getchar();/*阻塞等待信号量释放*/
		.../*大量解析命令部分，不看*/
		msh_exec(shell->line, shell->line_position);/*执行当前行*/
		...
	}
}
```
展开`msh_exec (msh.c)`精简版
```c
int msh_exec(char *cmd, rt_size_t length)
{
	int cmd_ret;
	/* Exec sequence:
     * 1. built-in command
     * 2. module(if enabled)
     * 3. chdir to the directry(if possible)
     */
	_msh_exec_cmd(cmd, length, &cmd_ret);
	return cmd_ret;
}
```
展开`_msh_exec_cmd (msh.c)`完整版
```c
static int _msh_exec_cmd(char *cmd, rt_size_t length, int *retp)
{
    int argc;
    rt_size_t cmd0_size = 0;
    cmd_function_t cmd_func;
    char *argv[RT_FINSH_ARG_MAX];
    RT_ASSERT(cmd);
    RT_ASSERT(retp);
    /* find the size of first command */
    while ((cmd[cmd0_size] != ' ' && cmd[cmd0_size] != '\t') && cmd0_size < length)
        cmd0_size ++;
    if (cmd0_size == 0)
        return -RT_ERROR;
	/* 到前文提到的_syscall_table_begin与和_syscall_table_end之前查找到函数地址 */
    cmd_func = msh_get_cmd(cmd, cmd0_size);
    if (cmd_func == RT_NULL)
        return -RT_ERROR;
	/* 下面是含参部分，没有研究 */
    /* split arguments */
    memset(argv, 0x00, sizeof(argv));
    argc = msh_split(cmd, length, argv);
    if (argc == 0)
        return -RT_ERROR;
	/* 最终执行函数 */
    /* exec this command */
    *retp = cmd_func(argc, argv);
    return 0;
}
```
终于到了最后，展开`msh_get_cmd (msh.c)`
```c
static cmd_function_t msh_get_cmd(char *cmd, int size)
{
    struct finsh_syscall *index;
    cmd_function_t cmd_func = RT_NULL;

for (index = _syscall_table_begin;
            index < _syscall_table_end;
            FINSH_NEXT_SYSCALL(index)) /* 每次自增一个finsh_syscall结构体 */
    {
	    /* MSH_CMD_EXPORT导出的函数名，前六个字符是"__cmd_" */
        if (strncmp(index->name, "__cmd_", 6) != 0) continue;

if (strncmp(&index->name[6], cmd, size) == 0 &&
                index->name[6 + size] == '\0')
        {
	        /* 把前面宏定义保存的函数名去掉__cmd_与控制台读取到的函数名比较
	         * 对了就返回函数地址，自此大功告成！ */
            cmd_func = (cmd_function_t)index->func;
            break;
        }
    }
    return cmd_func;
}
```
大功告成！（嘘，擦汗）
## 总结
- `MSH_CMD_EXPORT(command, desc)`将函数地址，函数名，函数描述保存到`finsh_syscall`结构体
- 再将每个`finsh_syscall`结构体通过`RT_SECTION("FSymTab")`强制保存到ROM空间的`FSymTab`段，并在链接脚本导出`FSymTab`的起始和结束地址`__fsymtab_start和__fsymtab_end`并赋值给`struct finsh_syscall *_syscall_table_begin, *_syscall_table_end`
- 以供FinSH线程`finsh_thread_entry`根据控制台输入的函数名扫描函数表（保存在`_syscall_table_begin`与`_syscall_table_end`之间）并执行相应函数

## 补流程图
(mermaid论坛好像不支持，直接贴图了)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230202/32a41cc374eca0d2975142ba6ca278d1.png.webp)
## 题外话

现在知道了我们导出的函数都是在`finsh_thread_entry`线程执行的，那么如果导出的函数比较大的话FinSH的线程栈就要设大点啦。
还有既然导出的函数会在`finsh_thread_entry`执行，那么我们就可以拦截控制台的串口输入来在控制台实现最入门的串口回显了（大部分都是用MSH导出含参函数，但就是折腾一下）
```c
void msh_test()
{
	rt_device_t uart=rt_device_find(RT_CONSOLE_DEVICE_NAME);
	rt_kprintf("enter msh test\n");
	rt_size_t rsize=0;
	uint8_t ch=0;
	while(1){
		/*串口接收中断时先把数据写入接收FIFO，
		 *再释放信号量，所以这里是从接收FIFO读
		 *没有影响，而finsh线程被阻塞在这里，
		 *所以信号量也不会被finsh持有
		 *总而言之，finsh线程被阻塞在这里(msh_test函数)了，
		 *不会响应任何命令*/
		rsize = rt_device_read(uart, 0, &ch, 1);
		if(rsize){
			if(ch=='q') 
			{
				rt_kprintf("leave msh test\n");
				break;
			}
			rt_device_write(uart,0,&ch,1);
			rt_kprintf("\nrsize:%d\n", rsize);
		}
		rt_thread_mdelay(100);
	}
}
MSH_CMD_EXPORT(msh_test, block finsh)
```

![screenshot_串口回显1.png](https://oss-club.rt-thread.org/uploads/20230125/1375041f5bab8168e07f449bba8b16d8.png)
屏蔽`rt_kprintf("\nrsize:%d\n", rsize);`，经典回显（笑）

![screenshot_串口回显2.png](https://oss-club.rt-thread.org/uploads/20230125/8d655727cb83fa0b0da7d5f2d80e8c18.png.webp)

9 条评论

EPTmachine 2023-01-26

Big Maker

aozima 2023-01-26

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

初级踩坑仔 2023-01-26

这家伙很懒，什么也没写！

crystal266 2023-01-30

嵌入式

bernard 2023-02-06

这家伙很懒，什么也没写！

论坛可以用plantuml来画图了吗？

PO一个，试试效果：

```plantuml
@startuml
hide footbox
participant dfs
participant dfs_file
participant dentry
participant vnode
participant mnt
participant rom
participant devfs
note over mnt: mount virtio-blk0(ext) on path: /mnt
dfs -> mnt: mnt_parent = dfs_mnt_lookup(/mnt)
note over mnt: found mnt(rom)
mnt --> dfs: with mnt_parent
dfs -> dentry: mntpoint_dentry = dfs_dentry_lookup(mnt_parent, /mnt, 0)
activate dentry
dentry -> dentry: dfs_dentry_create(mnt)
dentry -> mnt: dentry->mnt=dfs_mnt_ref(mnt)
note over mnt: mnt(rom),ref_count=4
dentry -> rom: vnode=fs_ops->lookup(dentry)
rom -> vnode: dfs_vnode_create()
rom -> rom: vnode->data = dirent
rom --> dentry: return vnode
deactivate dentry
dentry --> dfs: dentry exist
dfs -> mnt: mnt_child = dfs_mnt_create(path)
dfs -> ext: root_dentry = fs_ops->mount(mnt_child, rwflag, data)
ext -> mnt: dfs_mnt_ref(mnt.name=ext)
note over mnt: mnt(ext),ref_count=2
ext -> ext: dfs_ext_lookup(dentry.name=/)
ext -> vnode: dfs_vnode_create()
ext -> mnt: dfs_mnt_ref(dentry->mnt, name=ext)
note over mnt: mnt(ext),ref_count=3
ext --> dfs: mount OK
dfs -> mnt: dfs_mnt_insert(mnt_parent, mnt_child)
note right of mnt: set mnt->flags as mounted
note over mnt: mnt(ext),ref_count=2
dfs -> dfs_file: dfs_file_open(/mnt, O_DIRECTORY, 0)
dfs_file -> dfs_file: file = dfs_file_create()
dfs_file -> mnt: dfs_mnt_lookup(/mnt)
note over mnt: found mnt(ext)
dfs_file -> dentry: dfs_dentry_lookup(mnt, /mnt)
note over dentry: return root dentry
dentry -> dentry: dfs_dentry_ref(mnt->root(2))
dfs_file -> ext: fops->open(file)
dfs_file --> dfs: return fd = 4
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: dirent.d_name=.
dfs -> dfs_file: dfs_file_stat(/mnt, &stat)
dfs_file -> mnt: dfs_mnt_lookup(/mnt)
note over mnt: found mnt(ext)
dfs_file -> dentry: dentry = dfs_dentry_lookup(mnt, /mnt)
note over dentry: return root dentry
dentry -> dentry: dfs_dentry_ref(mnt->root(3))
dentry --> dfs_file: return dentry
dfs_file -> ext: fs_ops->stat(dentry, buf)
dfs_file -> dentry: dfs_dentry_unref(dentry)
note over dentry: dentry ref_count=2
end
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: dirent.d_name=..
dfs -> dfs_file: dfs_file_stat(/, &stat)
dfs_file -> mnt: dfs_mnt_lookup(/)
note over mnt: found mnt(rom)
dfs_file -> dentry: dentry = dfs_dentry_lookup(mnt, /)
note over dentry: return root dentry
dentry -> dentry: dfs_dentry_ref(mnt->root(3))
dentry --> dfs_file: return dentry
dfs_file -> rom: fs_ops->stat(dentry, buf)
dfs_file -> dentry: dfs_dentry_unref(dentry)
note over dentry: dentry ref_count=2
end
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: dirent.d_name=lost+found
dfs -> dfs_file: dfs_file_stat(/mnt/lost+found, &stat)
dfs_file -> mnt: dfs_mnt_lookup(/mnt/lost+found)
note over mnt: found mnt(ext)
dfs_file -> dentry: dentry = dfs_dentry_lookup(mnt, /mnt/lost+found)
activate dentry
dentry -> dentry: dfs_dentry_create(/lost+found)
dentry -> mnt: dentry->mnt=dfs_mnt_ref(mnt)
note over mnt: mnt(ext),ref_count=3
dentry -> ext: vnode=fs_ops->lookup(dentry)
ext -> vnode: dfs_vnode_create()
ext -> mnt: dfs_mnt_ref(dentry->mnt, name=ext)
note over mnt: mnt(ext),ref_count=4
ext --> dentry: return vnode
deactivate dentry
dentry --> dfs_file: return dentry
dfs_file -> ext: fs_ops->stat(dentry, buf)
dfs_file -> dentry: dfs_dentry_unref(dentry)
dentry -> dentry: free dentry, ref_count=0
dentry -> vnode: dfs_vnode_unref(dentry->vnode)
vnode -> vnode: free vnode, ref_count=0
vnode -> ext: fs_ops->free_vnode
dentry -> mnt: dfs_mnt_unref(dentry->mnt)
note over mnt: mnt(ext),ref_count=3
end
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: dirent.d_name=test
dfs -> dfs_file: dfs_file_stat(/mnt/test, &stat)
dfs_file -> mnt: dfs_mnt_lookup(/mnt/test)
note over mnt: found mnt(ext)
dfs_file -> dentry: dentry = dfs_dentry_lookup(mnt, /mnt/test)
activate dentry
dentry -> dentry: dfs_dentry_create(/test)
dentry -> mnt: dentry->mnt=dfs_mnt_ref(mnt)
note over mnt: mnt(ext),ref_count=4
dentry -> ext: vnode=fs_ops->lookup(dentry)
ext -> vnode: dfs_vnode_create()
ext -> mnt: dfs_mnt_ref(dentry->mnt, name=ext)
note over mnt: mnt(ext),ref_count=5
ext --> dentry: return vnode
deactivate dentry
dentry --> dfs_file: return dentry
dfs_file -> ext: fs_ops->stat(dentry, buf)
dfs_file -> dentry: dfs_dentry_unref(dentry)
dentry -> dentry: free dentry, ref_count=0
dentry -> vnode: dfs_vnode_unref(dentry->vnode)
vnode -> vnode: free vnode, ref_count=0
vnode -> ext: fs_ops->free_vnode
dentry -> mnt: dfs_mnt_unref(dentry->mnt)
note over mnt: mnt(ext),ref_count=4
end
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: dirent.d_name=README.md
dfs -> dfs_file: dfs_file_stat(/mnt/README.md, &stat)
dfs_file -> mnt: dfs_mnt_lookup(/mnt/README.md)
note over mnt: found mnt(ext)
dfs_file -> dentry: dentry = dfs_dentry_lookup(mnt, /mnt/README.md)
activate dentry
dentry -> dentry: dfs_dentry_create(/README.md)
dentry -> mnt: dentry->mnt=dfs_mnt_ref(mnt)
note over mnt: mnt(ext),ref_count=5
dentry -> ext: vnode=fs_ops->lookup(dentry)
ext -> vnode: dfs_vnode_create()
ext -> mnt: dfs_mnt_ref(dentry->mnt, name=ext)
note over mnt: mnt(ext),ref_count=6
ext --> dentry: return vnode
deactivate dentry
dentry --> dfs_file: return dentry
dfs_file -> ext: fs_ops->stat(dentry, buf)
dfs_file -> dentry: dfs_dentry_unref(dentry)
dentry -> dentry: free dentry, ref_count=0
dentry -> vnode: dfs_vnode_unref(dentry->vnode)
vnode -> vnode: free vnode, ref_count=0
vnode -> ext: fs_ops->free_vnode
dentry -> mnt: dfs_mnt_unref(dentry->mnt)
note over mnt: mnt(ext),ref_count=5
end
group foreach_item
dfs -> dfs_file: dfs_file_getdents(fd=4, &dirent)
dfs_file -> ext: fops->getdents()
dfs_file --> dfs: return NULL
end
dfs -> dfs_file: dfs_file_close(fd=4)
dfs_file -> ext: fops->close(file)
dfs_file -> dfs_file: dfs_file_unref(file)
dfs_file -> dentry: dfs_dentry_unref(dentry(/))
note over dentry: dentry ref_count=1
dfs_file --> dfs: return
@enduml
```