vnode.h 文件参考

浏览源代码.

结构体
struct	IATTR
	此结构用于记录 vnode 的属性 更多...
struct	Vnode
	vnode并不包含文件名,因为 vnode和文件名是 1:N 的关系 更多...
struct	VnodeOps

类型定义
typedef LOS_DL_LIST	LIST_HEAD
typedef LOS_DL_LIST	LIST_ENTRY
typedef int	VfsHashCmp(struct Vnode *vnode, void *arg)

枚举
enum	VnodeType {   VNODE_TYPE_UNKNOWN , VNODE_TYPE_REG , VNODE_TYPE_DIR , VNODE_TYPE_BLK ,   VNODE_TYPE_CHR , VNODE_TYPE_BCHR , VNODE_TYPE_FIFO , VNODE_TYPE_LNK }

函数
int	VnodesInit (void)
int	VnodeDevInit (void)
	设备初始化,设备结点：/dev目录下，对应一个设备，如/dev/mmcblk0 更多...
int	VnodeAlloc (struct VnodeOps *vop, struct Vnode **vnode)
	申请分配一个 vnode 节点,vop为操作节点的驱动程序 更多...
int	VnodeFree (struct Vnode *vnode)
	是否 vnode 节点 更多...
int	VnodeLookup (const char *path, struct Vnode **vnode, uint32_t flags)
	通过路径查询vnode节点 更多...
int	VnodeLookupFullpath (const char *fullpath, struct Vnode **vnode, uint32_t flags)
	根节点内部改变 更多...
int	VnodeLookupAt (const char *path, struct Vnode **vnode, uint32_t flags, struct Vnode *orgVnode)
	通过路径 查找索引节点.路径和节点是 N:1的关系, 硬链接 更多...
int	VnodeHold (void)
	拿锁,封装互斥量 更多...
int	VnodeDrop (void)
	归还锁 更多...
void	VnodeRefDec (struct Vnode *vnode)
int	VnodeFreeAll (const struct Mount *mnt)
	释放mount下所有的索引节点 更多...
int	VnodeHashInit (void)
uint32_t	VfsHashIndex (struct Vnode *vnode)
	通过节点获取哈希索引值 更多...
int	VfsHashGet (const struct Mount *mount, uint32_t hash, struct Vnode **vnode, VfsHashCmp *fun, void *arg)
	通过哈希值获取节点信息 更多...
void	VfsHashRemove (struct Vnode *vnode)
	从哈希链表中摘除索引节点 更多...
int	VfsHashInsert (struct Vnode *vnode, uint32_t hash)
	插入哈希表 更多...
void	ChangeRoot (struct Vnode *newRoot)
	改变根节点 更多...
BOOL	VnodeInUseIter (const struct Mount *mount)
	mount是否正在被某个索引节点使用 更多...
struct Vnode *	VnodeGetRoot (void)
void	VnodeMemoryDump (void)
mode_t	GetUmask (void)
	获取用户创建文件掩码 更多...
int	VfsPermissionCheck (uint fuid, uint fgid, mode_t fileMode, int accMode)
int	VfsVnodePermissionCheck (const struct Vnode *node, int accMode)
LIST_HEAD *	GetVnodeFreeList (void)
LIST_HEAD *	GetVnodeActiveList (void)
LIST_HEAD *	GetVnodeVirtualList (void)
int	VnodeClearCache (void)

类型定义说明

LIST_ENTRY

typedef LOS_DL_LIST LIST_ENTRY

在文件 vnode.h 第 40 行定义.

LIST_HEAD

typedef LOS_DL_LIST LIST_HEAD

在文件 vnode.h 第 39 行定义.

VfsHashCmp

typedef int VfsHashCmp(struct Vnode *vnode, void *arg)

哈希比较指针函数,使用方法,例如: int VfsHashGet(const struct Mount *mount, uint32_t hash, struct Vnode **vnode, VfsHashCmp *fn, void *arg) VfsHashCmp *fn 等同于 int *fn, 此时 fn是个指针,指向了一个函数地址 fn(vnode,arg)就是调用这个函数,返回一个int类型的值

在文件 vnode.h 第 228 行定义.

枚举类型说明

VnodeType

enum VnodeType

Linux系统使用struct inode作为数据结构名称。BSD派生的系统，使用vnode名称，其中v表示“virtual file system”
Linux 链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln 命令产生硬链接。

硬连接
    硬连接指通过索引节点来进行连接。在 Linux 的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，
    称为索引节点号(Inode Index)。在 Linux 中，多个文件名指向同一索引节点是存在的。比如：A 是 B 的硬链接（A 和 B 都是文件名），
    则 A 的目录项中的 inode 节点号与 B 的目录项中的 inode 节点号相同，即一个 inode 节点对应两个不同的文件名，两个文件名指向同一个文件，
    A 和 B 对文件系统来说是完全平等的。删除其中任何一个都不会影响另外一个的访问。
    硬连接的作用是允许一个文件拥有多个有效路径名，这样用户就可以建立硬连接到重要文件，以防止“误删”的功能。其原因如上所述，
    因为对应该目录的索引节点有一个以上的连接。只删除一个连接并不影响索引节点本身和其它的连接，只有当最后一个连接被删除后，
    文件的数据块及目录的连接才会被释放。也就是说，文件真正删除的条件是与之相关的所有硬连接文件均被删除。
    # ln 源文件 目标文件
    
软连接
    另外一种连接称之为符号连接（Symbolic Link），也叫软连接。软链接文件有类似于 Windows 的快捷方式。
    它实际上是一个特殊的文件。在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。
    比如：A 是 B 的软链接（A 和 B 都是文件名），A 的目录项中的 inode 节点号与 B 的目录项中的 inode 节点号不相同，
    A 和 B 指向的是两个不同的 inode，继而指向两块不同的数据块。但是 A 的数据块中存放的只是 B 的路径名（可以根据这个找到 B 的目录项）。
    A 和 B 之间是“主从”关系，如果 B 被删除了，A 仍然存在（因为两个是不同的文件），但指向的是一个无效的链接。
    # ln -s 源文文件或目录 目标文件或目录
    
软链接与硬链接最大的不同：文件A指向文件B的文件名，而不是文件B的inode号码，文件B的inode"链接数"不会因此发生变化。    

inode的特殊作用
由于inode号码与文件名分离，这种机制导致了一些Unix/Linux系统特有的现象。
　　1. 有时，文件名包含特殊字符，无法正常删除。这时，直接删除inode节点，就能起到删除文件的作用。
　　2. 移动文件或重命名文件，只是改变文件名，不影响inode号码。
　　3. 打开一个文件以后，系统就以inode号码来识别这个文件，不再考虑文件名。因此，通常来说，系统无法从inode号码得知文件名。
第3点使得软件更新变得简单，可以在不关闭软件的情况下进行更新，不需要重启。因为系统通过inode号码，识别运行中的文件，不通过文件名。
更新的时候，新版文件以同样的文件名，生成一个新的inode，不会影响到运行中的文件。等到下一次运行这个软件的时候，文件名就自动指向新版文件，
旧版文件的inode则被回收。

Vnode types. VNODE_TYPE_UNKNOWN means no type. | 节点类型

枚举值
VNODE_TYPE_UNKNOWN
VNODE_TYPE_REG	unknown type | 未知类型
VNODE_TYPE_DIR	regular file | 正则文件(普通文件)
VNODE_TYPE_BLK	directory | 目录
VNODE_TYPE_CHR	block device | 块设备
VNODE_TYPE_BCHR	char device | 字符设备
VNODE_TYPE_FIFO	block char mix device | 块和字符设备混合
VNODE_TYPE_LNK	pipe | 管道文件

在文件 vnode.h 第 134 行定义.

               {
    VNODE_TYPE_UNKNOWN,       /*! unknown type | 未知类型*/
    VNODE_TYPE_REG,           /*! regular file | 正则文件(普通文件)*/   
    VNODE_TYPE_DIR,           /*! directory | 目录*/      
    VNODE_TYPE_BLK,           /*! block device | 块设备*/  
    VNODE_TYPE_CHR,           /*! char device | 字符设备*/      
    VNODE_TYPE_BCHR,          /*! block char mix device | 块和字符设备混合*/
    VNODE_TYPE_FIFO,          /*! pipe | 管道文件*/         
    VNODE_TYPE_LNK,           /*! link | 链接,这里的链接指的是上层硬链接概念*/
};

函数说明

ChangeRoot()

void ChangeRoot

(

struct Vnode *

newRoot

)

改变根节点

在文件 vnode.c 第 536 行定义.

{
    struct Vnode *rootOld = g_rootVnode;
    g_rootVnode = rootNew;
    ChangeRootInternal(rootOld, "proc");
    ChangeRootInternal(rootOld, "dev");
}

函数调用图:

GetUmask()

mode_t GetUmask

(

void

)

获取用户创建文件掩码

在文件 vfs_other.c 第 715 行定义.

{
    return OsCurrProcessGet()->umask;
}

函数调用图:

这是这个函数的调用关系图:

GetVnodeActiveList()

LIST_HEAD * GetVnodeActiveList

(

void

)

在文件 vnode.c 第 736 行定义.

{
    return &g_vnodeActiveList;
}

这是这个函数的调用关系图:

GetVnodeFreeList()

LIST_HEAD * GetVnodeFreeList

(

void

)

在文件 vnode.c 第 726 行定义.

{
    return &g_vnodeFreeList;
}

这是这个函数的调用关系图:

GetVnodeVirtualList()

LIST_HEAD * GetVnodeVirtualList

(

void

)

在文件 vnode.c 第 731 行定义.

{
    return &g_vnodeVirtualList;
}

这是这个函数的调用关系图:

VfsHashGet()

int VfsHashGet	(	const struct Mount *	mount,
		uint32_t	hash,
		struct Vnode **	vnode,
		VfsHashCmp *	fun,
		void *	arg
	)

通过哈希值获取节点信息

在文件 vnode_hash.c 第 89 行定义.

{
    struct Vnode *curVnode = NULL;
 
    if (mount == NULL || vnode == NULL) {
        return -EINVAL;
    }
 
    (void)LOS_MuxLock(&g_vnodeHashMux, LOS_WAIT_FOREVER);//先上锁
    LOS_DL_LIST *list = VfsHashBucket(mount, hash);//获取哈希表对应的链表项
    LOS_DL_LIST_FOR_EACH_ENTRY(curVnode, list, struct Vnode, hashEntry) {//遍历链表
        if (curVnode->hash != hash) {//对比哈希值找
            continue;
        }
        if (curVnode->originMount != mount) {//对比原始mount值必须一致
            continue;
        }
        if (fn != NULL && fn(curVnode, arg)) {//哈希值比较函数,fn由具体的文件系统提供.
            continue;
        }
        (void)LOS_MuxUnlock(&g_vnodeHashMux);
        *vnode = curVnode;//找到对应索引节点
        return LOS_OK;
    }
    (void)LOS_MuxUnlock(&g_vnodeHashMux);
    *vnode = NULL;
    return LOS_NOK;
}

函数调用图:

这是这个函数的调用关系图:

VfsHashIndex()

uint32_t VfsHashIndex

(

struct Vnode *

vnode

)

通过节点获取哈希索引值

在文件 vnode_hash.c 第 76 行定义.

{
    if (vnode == NULL) {
        return -EINVAL;
    }
    return (vnode->hash + vnode->originMount->hashseed);//用于定位在哈希表的下标
}

VfsHashInsert()

int VfsHashInsert	(	struct Vnode *	vnode,
		uint32_t	hash
	)

插入哈希表

在文件 vnode_hash.c 第 128 行定义.

{
    if (vnode == NULL) {
        return -EINVAL;
    }
    (void)LOS_MuxLock(&g_vnodeHashMux, LOS_WAIT_FOREVER);
    vnode->hash = hash;//设置节点哈希值
    LOS_ListHeadInsert(VfsHashBucket(vnode->originMount, hash), &vnode->hashEntry);//通过节点hashEntry 挂入哈希表对于索引链表中
    (void)LOS_MuxUnlock(&g_vnodeHashMux);
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

VfsHashRemove()

void VfsHashRemove

(

struct Vnode *

vnode

)

从哈希链表中摘除索引节点

在文件 vnode_hash.c 第 118 行定义.

{
    if (vnode == NULL) {
        return;
    }
    (void)LOS_MuxLock(&g_vnodeHashMux, LOS_WAIT_FOREVER);
    LOS_ListDelete(&vnode->hashEntry);//直接把自己摘掉就行了
    (void)LOS_MuxUnlock(&g_vnodeHashMux);
}

函数调用图:

VfsPermissionCheck()

int VfsPermissionCheck	(	uint	fuid,
		uint	fgid,
		mode_t	fileMode,
		int	accMode
	)

这是这个函数的调用关系图:

VfsVnodePermissionCheck()

int VfsVnodePermissionCheck	(	const struct Vnode *	node,
		int	accMode
	)

在文件 vfs_other.c 第 80 行定义.

{
    uint fuid = node->uid;
    uint fgid = node->gid;
    uint fileMode = node->mode;
    return VfsPermissionCheck(fuid, fgid, fileMode, accMode);
}

函数调用图:

这是这个函数的调用关系图:

VnodeAlloc()

int VnodeAlloc	(	struct VnodeOps *	vop,
		struct Vnode **	vnode
	)

申请分配一个 vnode 节点,vop为操作节点的驱动程序

在文件 vnode.c 第 166 行定义.

{
    struct Vnode* vnode = NULL;
 
    VnodeHold();
    vnode = GetFromFreeList();
    if ((vnode == NULL) && g_totalVnodeSize < LOSCFG_MAX_VNODE_SIZE) {
        vnode = (struct Vnode*)zalloc(sizeof(struct Vnode));
        g_totalVnodeSize++;
    }
 
    if (vnode == NULL) {//没有分配到节点
        vnode = VnodeReclaimLru();//执行回收算法,释放节点
    }
 
    if (vnode == NULL) {//回收也没有可用节点
        *newVnode = NULL;
        VnodeDrop();
        return -ENOMEM;//分配失败,返回
    }
 
    vnode->type = VNODE_TYPE_UNKNOWN;   //节点默认类型,未知
    LOS_ListInit((&(vnode->parentPathCaches)));//后续可能要当爸爸,做好准备
    LOS_ListInit((&(vnode->childPathCaches)));//后续可能要当儿子,做好准备
    LOS_ListInit((&(vnode->hashEntry)));      //用它挂到全局哈希表上
    LOS_ListInit((&(vnode->actFreeEntry)));     //用它挂到全局正使用节点链表上
 
    if (vop == NULL) {//
        LOS_ListAdd(&g_vnodeVirtualList, &(vnode->actFreeEntry));//挂到虚拟设备
        vnode->vop = &g_devfsOps;
    } else {//如果已有指定的文件系统(FAT),直接绑定
        LOS_ListTailInsert(&g_vnodeActiveList, &(vnode->actFreeEntry));
        vnode->vop = vop;
    }
    LOS_ListInit(&vnode->mapping.page_list);
    LOS_SpinInit(&vnode->mapping.list_lock);
    (VOID)LOS_MuxInit(&vnode->mapping.mux_lock, NULL);
    vnode->mapping.host = vnode;
 
    VnodeDrop();
 
    *newVnode = vnode;
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

VnodeClearCache()

int VnodeClearCache

(

void

)

在文件 vnode.c 第 741 行定义.

{
    struct Vnode *item = NULL;
    struct Vnode *nextItem = NULL;
    int count = 0;
 
    VnodeHold();
    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_vnodeActiveList, struct Vnode, actFreeEntry) {
        if ((item->useCount > 0) ||
            (item->flag & VNODE_FLAG_MOUNT_ORIGIN) ||
            (item->flag & VNODE_FLAG_MOUNT_NEW)) {
            continue;
        }
 
        if (VnodeFree(item) == LOS_OK) {
            count++;
        }
    }
    VnodeDrop();
 
    return count;
}

函数调用图:

这是这个函数的调用关系图:

VnodeDevInit()

int VnodeDevInit

(

void

)

设备初始化,设备结点：/dev目录下，对应一个设备，如/dev/mmcblk0

在文件 vnode.c 第 627 行定义.

{
    struct Vnode *devNode = NULL;
    struct Mount *devMount = NULL;
 
    int retval = VnodeLookup("/dev", &devNode, V_CREATE | V_DUMMY);
    if (retval != LOS_OK) {
        PRINT_ERR("VnodeDevInit failed error %d\n", retval);
        return retval;
    }
    devNode->mode = DEV_VNODE_MODE | S_IFDIR; // 40755(chmod 755)
    devNode->type = VNODE_TYPE_DIR; //设备根节点目录
 
    devMount = MountAlloc(devNode, NULL);//分配一个mount节点
    if (devMount == NULL) {
        PRINT_ERR("VnodeDevInit failed mount point alloc failed.\n");
        return -ENOMEM;
    }
    devMount->vnodeCovered = devNode;
    devMount->vnodeBeCovered->flag |= VNODE_FLAG_MOUNT_ORIGIN;
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

VnodeDrop()

int VnodeDrop

(

void

)

归还锁

在文件 vnode.c 第 292 行定义.

{
    int ret = LOS_MuxUnlock(&g_vnodeMux);
    if (ret != LOS_OK) {
        PRINT_ERR("VnodeDrop unlock failed !\n");
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

VnodeFree()

int VnodeFree

(

struct Vnode *

vnode

)

是否 vnode 节点

在文件 vnode.c 第 212 行定义.

{
    if (vnode == NULL) {
        return LOS_OK;
    }
 
    VnodeHold();//拿互斥锁
    if (vnode->useCount > 0) {//还有引用数,或者叫链接数.这里的链接数指的是还有硬链接没删除的情况
        VnodeDrop();
        return -EBUSY;//返回设备或资源忙着呢.
    }
 
    VnodePathCacheFree(vnode);//节点和父亲,孩子告别
    LOS_ListDelete(&(vnode->hashEntry));//将自己从当前哈希链表上摘出来,此时vnode通过hashEntry挂在 g_vnodeHashEntrys
    LOS_ListDelete(&vnode->actFreeEntry);//将自己从当前链表摘出来,此时vnode通过actFreeEntry挂在 g_vnodeCurrList
 
    if (vnode->vop->Reclaim) {//资源的回收操作
        vnode->vop->Reclaim(vnode);//先回收资源
    }
 
    if (vnode->filePath) {
        free(vnode->filePath);
    }
    if (vnode->vop == &g_devfsOps) {//对设备文件的回收
        /* for dev vnode, just free it */
        free(vnode->data);//
        free(vnode);
        g_totalVnodeSize--;
    } else {
        /* for normal vnode, reclaim it to g_VnodeFreeList */
        (void)memset_s(vnode, sizeof(struct Vnode), 0, sizeof(struct Vnode));
        LOS_ListAdd(&g_vnodeFreeList, &vnode->actFreeEntry);//actFreeEntry换个地方挂,从活动链接换到空闲链表上. 
        g_freeVnodeSize++;//空闲链表节点数量增加
    }
    VnodeDrop();//释放互斥锁
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

VnodeFreeAll()

int VnodeFreeAll

(

const struct Mount *

mnt

)

释放mount下所有的索引节点

在文件 vnode.c 第 251 行定义.

{
    struct Vnode *vnode = NULL;
    struct Vnode *nextVnode = NULL;
    int ret;
 
    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(vnode, nextVnode, &g_vnodeActiveList, struct Vnode, actFreeEntry) {
        if ((vnode->originMount == mount) && !(vnode->flag & VNODE_FLAG_MOUNT_NEW)) {//找到装载点,且这个装载点没有被新使用
            ret = VnodeFree(vnode);//释放节点,@note_thinking 是不是树杈被释放后,树叶也默认被释放了?
            if (ret != LOS_OK) {
                return ret;
            }
        }
    }
 
    return LOS_OK;
}

函数调用图:

VnodeGetRoot()

struct Vnode * VnodeGetRoot

(

void

)

在文件 vnode.c 第 660 行定义.

{
    return g_rootVnode;
}

VnodeHashInit()

int VnodeHashInit

(

void

)

在文件 vnode_hash.c 第 44 行定义.

{
    int ret;
    for (int i = 0; i < g_vnodeHashSize; i++) {//遍历初始化 128个双向链表
        LOS_ListInit(&g_vnodeHashEntrys[i]);
    }
 
    ret = LOS_MuxInit(&g_vnodeHashMux, NULL);
    if (ret != LOS_OK) {
        PRINT_ERR("Create mutex for vnode hash list fail, status: %d", ret);
        return ret;
    }
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

VnodeHold()

int VnodeHold

(

void

)

拿锁,封装互斥量

在文件 vnode.c 第 283 行定义.

{
    int ret = LOS_MuxLock(&g_vnodeMux, LOS_WAIT_FOREVER);
    if (ret != LOS_OK) {
        PRINT_ERR("VnodeHold lock failed !\n");
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

VnodeInUseIter()

BOOL VnodeInUseIter

(

const struct Mount *

mount

)

mount是否正在被某个索引节点使用

在文件 vnode.c 第 269 行定义.

{
    struct Vnode *vnode = NULL;
 
    LOS_DL_LIST_FOR_EACH_ENTRY(vnode, &g_vnodeActiveList, struct Vnode, actFreeEntry) {//遍历活动链表
        if (vnode->originMount == mount) {//找到一致挂载点
            if ((vnode->useCount > 0) || (vnode->flag & VNODE_FLAG_MOUNT_ORIGIN)) {//还在被使用
                return TRUE;
            }
        }
    }
    return FALSE;
}

VnodeLookup()

int VnodeLookup	(	const char *	path,
		struct Vnode **	vnode,
		uint32_t	flags
	)

通过路径查询vnode节点

在文件 vnode.c 第 491 行定义.

{
    return VnodeLookupAt(path, vnode, flags, NULL);
}

函数调用图:

这是这个函数的调用关系图:

VnodeLookupAt()

int VnodeLookupAt	(	const char *	path,
		struct Vnode **	vnode,
		uint32_t	flags,
		struct Vnode *	orgVnode
	)

通过路径 查找索引节点.路径和节点是 N:1的关系, 硬链接

在文件 vnode.c 第 412 行定义.

{
    int ret;
    int vnodePathLen;
    char *vnodePath = NULL;
    struct Vnode *startVnode = NULL;
    char *normalizedPath = NULL;
 
    if (orgVnode != NULL) {
        startVnode = orgVnode;
        normalizedPath = strdup(path);
        if (normalizedPath == NULL) {
            PRINT_ERR("[VFS]lookup failed, strdup err\n");
            ret = -EINVAL;
            goto OUT_FREE_PATH;
        }
    } else {
        ret = PreProcess(path, &startVnode, &normalizedPath);
        if (ret != LOS_OK) {
            PRINT_ERR("[VFS]lookup failed, invalid path err = %d\n", ret);
            goto OUT_FREE_PATH;
        }
    }
 
    if (normalizedPath[1] == '\0' && normalizedPath[0] == '/') {
        *result = g_rootVnode;//啥也不说了,还找啥呀,直接返回根节点
        free(normalizedPath);
        return LOS_OK;
    }
 
    char *currentDir = normalizedPath;
    struct Vnode *currentVnode = startVnode;
 
    while (*currentDir != '\0') {
        ret = Step(&currentDir, &currentVnode, flags);
        if (currentDir == NULL || *currentDir == '\0') {
            // return target or parent vnode as result
            *result = currentVnode;
            if (currentVnode->filePath == NULL) {
                currentVnode->filePath = normalizedPath;
            } else {
                free(normalizedPath);
            }
            return ret;
        } else if (VfsVnodePermissionCheck(currentVnode, EXEC_OP)) {
            ret = -EACCES;
            goto OUT_FREE_PATH;
        }
 
        if (ret != LOS_OK) {
            // no such file, lookup failed
            goto OUT_FREE_PATH;
        }
        if (currentVnode->filePath == NULL) {
            vnodePathLen = currentDir - normalizedPath;
            vnodePath = malloc(vnodePathLen + 1);
            if (vnodePath == NULL) {
                ret = -ENOMEM;
                goto OUT_FREE_PATH;
            }
            ret = strncpy_s(vnodePath, vnodePathLen + 1, normalizedPath, vnodePathLen);
            if (ret != EOK) {
                ret = -ENAMETOOLONG;
                free(vnodePath);
                goto OUT_FREE_PATH;
            }
            currentVnode->filePath = vnodePath;
            currentVnode->filePath[vnodePathLen] = 0;
        }
    }
 
OUT_FREE_PATH:
    if (normalizedPath) {
        free(normalizedPath);
    }
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

VnodeLookupFullpath()

int VnodeLookupFullpath	(	const char *	fullpath,
		struct Vnode **	vnode,
		uint32_t	flags
	)

根节点内部改变

在文件 vnode.c 第 496 行定义.

{
    return VnodeLookupAt(fullpath, vnode, flags, g_rootVnode);
}

函数调用图:

VnodeMemoryDump()

void VnodeMemoryDump

(

void

)

在文件 vnode.c 第 706 行定义.

{
    struct Vnode *item = NULL;
    struct Vnode *nextItem = NULL;
    int vnodeCount = 0;
    //遍历链表
    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_vnodeActiveList, struct Vnode, actFreeEntry) {
        if ((item->useCount > 0) ||
            (item->flag & VNODE_FLAG_MOUNT_ORIGIN) ||
            (item->flag & VNODE_FLAG_MOUNT_NEW)) {//有效节点
            continue;
        }
 
        vnodeCount++;//统计数量
    }
 
    PRINTK("Vnode number = %d\n", vnodeCount);
    PRINTK("Vnode memory size = %d(B)\n", vnodeCount * sizeof(struct Vnode));
}

这是这个函数的调用关系图:

VnodeRefDec()

void VnodeRefDec

(

struct Vnode *

vnode

)

VnodesInit()

int VnodesInit

(

void

)

#ifndef S_IRUSR #define S_ISUID 04000 #define S_ISGID 02000 #define S_ISVTX 01000 #define S_IRUSR 0400 #define S_IWUSR 0200 #define S_IXUSR 0100 #define S_IRWXU 0700 #define S_IRGRP 0040 #define S_IWGRP 0020 #define S_IXGRP 0010 #define S_IRWXG 0070 #define S_IROTH 0004 #define S_IWOTH 0002 #define S_IXOTH 0001 #define S_IRWXO 0007 #endif

在文件 vnode.c 第 91 行定义.

{
    int retval = LOS_MuxInit(&g_vnodeMux, NULL);//初始化操作vnode链表的互斥量
    if (retval != LOS_OK) {
        PRINT_ERR("Create mutex for vnode fail, status: %d", retval);
        return retval;
    }
 
    LOS_ListInit(&g_vnodeFreeList);     //初始化空闲的节点链表
    LOS_ListInit(&g_vnodeVirtualList);  //初始化虚拟节点链表
    LOS_ListInit(&g_vnodeActiveList);   //初始化活动虚拟节点链表
    retval = VnodeAlloc(NULL, &g_rootVnode);//分配根节点
    if (retval != LOS_OK) {
        PRINT_ERR("VnodeInit failed error %d\n", retval);
        return retval;
    }
    g_rootVnode->mode = S_IRWXU | S_IRWXG | S_IRWXO | S_IFDIR;// 40777 (chmod 777)
    g_rootVnode->type = VNODE_TYPE_DIR;//节点类型为目录
    g_rootVnode->filePath = "/";
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图: