vnode.c 文件参考

浏览源代码.

函数
int	VnodesInit (void)
static struct Vnode *	GetFromFreeList (void)
	获取空闲节点链表,分配的节点从空闲链表里出 更多...
struct Vnode *	VnodeReclaimLru (void)
	节点批量回收, LRU是Least Recently Used的缩写，即最近最少使用， 更多...
int	VnodeAlloc (struct VnodeOps *vop, struct Vnode **newVnode)
	申请分配一个 vnode 节点,vop为操作节点的驱动程序 更多...
int	VnodeFree (struct Vnode *vnode)
	是否 vnode 节点 更多...
int	VnodeFreeAll (const struct Mount *mount)
	释放mount下所有的索引节点 更多...
BOOL	VnodeInUseIter (const struct Mount *mount)
	mount是否正在被某个索引节点使用 更多...
int	VnodeHold ()
	拿锁,封装互斥量 更多...
int	VnodeDrop ()
	归还锁 更多...
static char *	NextName (char *pos, uint8_t *len)
static int	PreProcess (const char *originPath, struct Vnode **startVnode, char **path)
	处理前的准备 更多...
static struct Vnode *	ConvertVnodeIfMounted (struct Vnode *vnode)
static void	RefreshLRU (struct Vnode *vnode)
	刷新虚拟节点 更多...
static int	ProcessVirtualVnode (struct Vnode *parent, uint32_t flags, struct Vnode **vnode)
static int	Step (char **currentDir, struct Vnode **currentVnode, uint32_t flags)
	一级一级向下找 更多...
int	VnodeLookupAt (const char *path, struct Vnode **result, uint32_t flags, struct Vnode *orgVnode)
	通过路径 查找索引节点.路径和节点是 N:1的关系, 硬链接 更多...
int	VnodeLookup (const char *path, struct Vnode **vnode, uint32_t flags)
	通过路径查询vnode节点 更多...
int	VnodeLookupFullpath (const char *fullpath, struct Vnode **vnode, uint32_t flags)
	根节点内部改变 更多...
static void	ChangeRootInternal (struct Vnode *rootOld, char *dirname)
void	ChangeRoot (struct Vnode *rootNew)
	改变根节点 更多...
static int	VnodeReaddir (struct Vnode *vp, struct fs_dirent_s *dir)
int	VnodeOpendir (struct Vnode *vnode, struct fs_dirent_s *dir)
int	VnodeClosedir (struct Vnode *vnode, struct fs_dirent_s *dir)
int	VnodeCreate (struct Vnode *parent, const char *name, int mode, struct Vnode **vnode)
	创建节点 更多...
int	VnodeDevInit ()
	设备初始化,设备结点：/dev目录下，对应一个设备，如/dev/mmcblk0 更多...
int	VnodeGetattr (struct Vnode *vnode, struct stat *buf)
	buf 接走 vnode 属性 更多...
struct Vnode *	VnodeGetRoot ()
static int	VnodeChattr (struct Vnode *vnode, struct IATTR *attr)
int	VnodeDevLookup (struct Vnode *parentVnode, const char *path, int len, struct Vnode **vnode)
void	VnodeMemoryDump (void)
LIST_HEAD *	GetVnodeFreeList ()
LIST_HEAD *	GetVnodeVirtualList ()
LIST_HEAD *	GetVnodeActiveList ()
int	VnodeClearCache ()

变量
LIST_HEAD	g_vnodeFreeList
	@ver 更多...
LIST_HEAD	g_vnodeVirtualList
LIST_HEAD	g_vnodeActiveList
static int	g_freeVnodeSize = 0
static int	g_totalVnodeSize = 0
static LosMux	g_vnodeMux
	操作链表互斥量 更多...
static struct Vnode *	g_rootVnode = NULL
	根节点 更多...
static struct VnodeOps	g_devfsOps
	设备文件节点操作 更多...

函数说明

ChangeRoot()

void ChangeRoot

(

struct Vnode *

rootNew

)

改变根节点

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

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

函数调用图:

ChangeRootInternal()

static void ChangeRootInternal ( struct Vnode *  rootOld, char *  dirname  )

static

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

{
    int ret;
    struct Mount *mnt = NULL;
    char *name = NULL;
    struct Vnode *node = NULL;
    struct Vnode *nodeInFs = NULL;
    struct PathCache *item = NULL;
    struct PathCache *nextItem = NULL;
    //遍历参数节点孩子节点
    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &rootOld->childPathCaches, struct PathCache, childEntry) {
        name = item->name;
        node = item->childVnode;
 
        if (strcmp(name, dirname)) {
            continue;
        }
        PathCacheFree(item);
 
        ret = VnodeLookup(dirname, &nodeInFs, 0);
        if (ret) {
            PRINTK("%s-%d %s NOT exist in rootfs\n", __FUNCTION__, __LINE__, dirname);
            break;
        }
 
        mnt = node->newMount;
        mnt->vnodeBeCovered = nodeInFs;
 
        nodeInFs->newMount = mnt;
        nodeInFs->flag |= VNODE_FLAG_MOUNT_ORIGIN;
 
        break;
    }
}

函数调用图:

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

ConvertVnodeIfMounted()

static struct Vnode * ConvertVnodeIfMounted ( struct Vnode *  vnode )

static

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

{
    if ((vnode == NULL) || !(vnode->flag & VNODE_FLAG_MOUNT_ORIGIN)) {
        return vnode;
    }
    return vnode->newMount->vnodeCovered;
}

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

GetFromFreeList()

static struct Vnode * GetFromFreeList ( void  )

static

获取空闲节点链表,分配的节点从空闲链表里出

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

{
    if (g_freeVnodeSize <= 0) {
        return NULL;
    }
    struct Vnode *vnode = NULL;
 
    if (LOS_ListEmpty(&g_vnodeFreeList)) {
        PRINT_ERR("get vnode from free list failed, list empty but g_freeVnodeSize = %d!\n", g_freeVnodeSize);
        g_freeVnodeSize = 0;
        return NULL;
    }
 
    vnode = ENTRY_TO_VNODE(LOS_DL_LIST_FIRST(&g_vnodeFreeList));
    LOS_ListDelete(&vnode->actFreeEntry);//从空闲链表上摘出去.
    g_freeVnodeSize--;
    return vnode;
}

函数调用图:

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

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;
}

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

NextName()

static char * NextName ( char *  pos, uint8_t *  len  )

static

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

{
    char *name = NULL;
    while (*pos != 0 && *pos == '/') {
        pos++;
    }
    if (*pos == '\0') {
        return NULL;
    }
    name = (char *)pos;
    while (*pos != '\0' && *pos != '/') {
        pos++;
    }
    *len = pos - name;
    return name;
}

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

PreProcess()

static int PreProcess ( const char *  originPath, struct Vnode **  startVnode, char **  path  )

static

处理前的准备

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

{
    int ret;
    char *absolutePath = NULL;
    //通过相对路径找到绝对路径
    ret = vfs_normalize_path(NULL, originPath, &absolutePath);
    if (ret == LOS_OK) {//成功
        *startVnode = g_rootVnode;//根节点为开始节点
        *path = absolutePath;//返回绝对路径
    }
 
    return ret;
}

函数调用图:

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

ProcessVirtualVnode()

static int ProcessVirtualVnode ( struct Vnode *  parent, uint32_t  flags, struct Vnode **  vnode  )

static

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

{
    int ret = -ENOENT;
    if (flags & V_CREATE) {
        // only create /dev/ vnode
        ret = VnodeAlloc(NULL, vnode);
    }
    if (ret == LOS_OK) {
        (*vnode)->parent = parent;
    }
    return ret;
}

函数调用图:

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

RefreshLRU()

static void RefreshLRU ( struct Vnode *  vnode )

static

刷新虚拟节点

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

{
    if (vnode == NULL || (vnode->type != VNODE_TYPE_REG && vnode->type != VNODE_TYPE_DIR) ||
        vnode->vop == &g_devfsOps || vnode->vop == NULL) {
        return;
    }
    LOS_ListDelete(&(vnode->actFreeEntry));
    LOS_ListTailInsert(&g_vnodeActiveList, &(vnode->actFreeEntry));
}

函数调用图:

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

Step()

static int Step ( char **  currentDir, struct Vnode **  currentVnode, uint32_t  flags  )

static

一级一级向下找

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

{
    int ret;
    uint8_t len = 0;
    struct Vnode *nextVnode = NULL;
    char *nextDir = NULL;
 
    if ((*currentVnode)->type != VNODE_TYPE_DIR) {//必须是目录节点
        return -ENOTDIR;
    }
    nextDir = NextName(*currentDir, &len);//
    if (nextDir == NULL) {
        *currentDir = NULL;
        return LOS_OK;
    }
 
    ret = PathCacheLookup(*currentVnode, nextDir, len, &nextVnode);
    if (ret == LOS_OK) {
        goto STEP_FINISH;
    }
 
    (*currentVnode)->useCount++;
    if (flags & V_DUMMY) {
        ret = ProcessVirtualVnode(*currentVnode, flags, &nextVnode);
    } else {
        if ((*currentVnode)->vop != NULL && (*currentVnode)->vop->Lookup != NULL) {
            ret = (*currentVnode)->vop->Lookup(*currentVnode, nextDir, len, &nextVnode);
        } else {
            ret = -ENOSYS;
        }
    }
    (*currentVnode)->useCount--;
 
    if (ret == LOS_OK) {
        (void)PathCacheAlloc((*currentVnode), nextVnode, nextDir, len);
    }
 
STEP_FINISH:
    nextVnode = ConvertVnodeIfMounted(nextVnode);
    RefreshLRU(nextVnode);
 
    *currentDir = nextDir + len;
    if (ret == LOS_OK) {
        *currentVnode = nextVnode;
    }
 
    return ret;
}

函数调用图:

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

VnodeAlloc()

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

申请分配一个 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;
}

函数调用图:

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

VnodeChattr()

static int VnodeChattr ( struct Vnode *  vnode, struct IATTR *  attr  )

static

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

{
    mode_t tmpMode;
    if (vnode == NULL || attr == NULL) {
        return -EINVAL;
    }
    if (attr->attr_chg_valid & CHG_MODE) {
        tmpMode = attr->attr_chg_mode;
        tmpMode &= ~S_IFMT;
        vnode->mode &= S_IFMT;
        vnode->mode = tmpMode | vnode->mode;
    }
    if (attr->attr_chg_valid & CHG_UID) {
        vnode->uid = attr->attr_chg_uid;
    }
    if (attr->attr_chg_valid & CHG_GID) {
        vnode->gid = attr->attr_chg_gid;
    }
    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;
}

函数调用图:

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

VnodeClosedir()

int VnodeClosedir	(	struct Vnode *	vnode,
		struct fs_dirent_s *	dir
	)

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

{
    (void)vnode;
    (void)dir;
    return LOS_OK;
}

VnodeCreate()

int VnodeCreate	(	struct Vnode *	parent,
		const char *	name,
		int	mode,
		struct Vnode **	vnode
	)

创建节点

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

{
    int ret;
    struct Vnode *newVnode = NULL;
 
    ret = VnodeAlloc(NULL, &newVnode);//分配一个节点
    if (ret != 0) {
        return -ENOMEM;
    }
    //继承老爹的基因.
    newVnode->type = VNODE_TYPE_CHR;//默认是字符设备
    newVnode->vop = parent->vop;//继承父节点 vop 驱动程序(也叫接口实现)
    newVnode->fop = parent->fop;//继承父节点 fop 驱动程序(也叫接口实现)
    newVnode->data = NULL;      //默认值
    newVnode->parent = parent;  //指定父节点
    newVnode->originMount = parent->originMount; //继承父节点挂载信息
    newVnode->uid = parent->uid;    //用户ID
    newVnode->gid = parent->gid;    //用户组ID
    newVnode->mode = mode;
    /* The 'name' here is not full path, but for device we don't depend on this path, it's just a name for DFx.
       When we have devfs, we can get a fullpath. */
    newVnode->filePath = strdup(name);
 
    *vnode = newVnode;
    return 0;
}

函数调用图:

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;
}

函数调用图:

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

VnodeDevLookup()

int VnodeDevLookup	(	struct Vnode *	parentVnode,
		const char *	path,
		int	len,
		struct Vnode **	vnode
	)

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

{
    (void)parentVnode;
    (void)path;
    (void)len;
    (void)vnode;
    /* dev node must in pathCache. */
    return -ENOENT;
}

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 *

mount

)

释放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;
}

函数调用图:

VnodeGetattr()

int VnodeGetattr	(	struct Vnode *	vnode,
		struct stat *	buf
	)

buf 接走 vnode 属性

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

{
    (void)memset_s(buf, sizeof(struct stat), 0, sizeof(struct stat));
    buf->st_mode = vnode->mode;
    buf->st_uid = vnode->uid;
    buf->st_gid = vnode->gid;
 
    return LOS_OK;
}

VnodeGetRoot()

struct Vnode * VnodeGetRoot

(

void

)

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

{
    return g_rootVnode;
}

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 **	result,
		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));
}

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

VnodeOpendir()

int VnodeOpendir	(	struct Vnode *	vnode,
		struct fs_dirent_s *	dir
	)

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

{
    (void)vnode;
    (void)dir;
    return LOS_OK;
}

VnodeReaddir()

static int VnodeReaddir ( struct Vnode *  vp, struct fs_dirent_s *  dir  )

static

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

{
    int result;
    int cnt = 0;
    off_t i = 0;
    off_t idx;
    unsigned int dstNameSize;
 
    struct PathCache *item = NULL;
    struct PathCache *nextItem = NULL;
 
    if (dir == NULL) {
        return -EINVAL;
    }
 
    LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &vp->childPathCaches, struct PathCache, childEntry) {
        if (i < dir->fd_position) {
            i++;
            continue;
        }
 
        idx = i - dir->fd_position;
 
        dstNameSize = sizeof(dir->fd_dir[idx].d_name);
        result = strncpy_s(dir->fd_dir[idx].d_name, dstNameSize, item->name, item->nameLen);
        if (result != EOK) {
            return -ENAMETOOLONG;
        }
        dir->fd_dir[idx].d_off = i;
        dir->fd_dir[idx].d_reclen = (uint16_t)sizeof(struct dirent);
 
        i++;
        if (++cnt >= dir->read_cnt) {
            break;
        }
    }
 
    dir->fd_position = i;
 
    return cnt;
}

VnodeReclaimLru()

struct Vnode * VnodeReclaimLru

(

void

)

节点批量回收, LRU是Least Recently Used的缩写，即最近最少使用，

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

{
    struct Vnode *item = NULL;
    struct Vnode *nextItem = NULL;
    int releaseCount = 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) || //原来是个mount节点
            (item->flag & VNODE_FLAG_MOUNT_NEW)) {  //是个新mount节点
            continue;
        }
 
        if (VnodeFree(item) == LOS_OK) {//正式回收,其实就是将自己从链表上摘出去,再挂到空闲链表上.
            releaseCount++;
        }
        if (releaseCount >= VNODE_LRU_COUNT) {//一次最多回收量
            break;
        }
    }
 
    if (releaseCount == 0) {//回收失败
        PRINT_ERR("VnodeAlloc failed, vnode size hit max but can't reclaim anymore!\n");
        return NULL;
    }
 
    item = GetFromFreeList();//获取一个空闲节点
    if (item == NULL) {
        PRINT_ERR("VnodeAlloc failed, reclaim and get from free list failed!\n");
    }
    return item;
}

函数调用图:

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

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;
}

函数调用图:

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

变量说明

g_devfsOps

static struct VnodeOps g_devfsOps

static

初始值:

= {
    .Lookup = VnodeDevLookup,
    .Getattr = VnodeGetattr,
    .Readdir = VnodeReaddir,
    .Opendir = VnodeOpendir,
    .Closedir = VnodeClosedir,
    .Create = VnodeCreate,
    .Chattr = VnodeChattr,
}

设备文件节点操作

设备文件系统节点操作

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

g_freeVnodeSize

int g_freeVnodeSize = 0

static

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

g_rootVnode

struct Vnode* g_rootVnode = NULL

static

根节点

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

g_totalVnodeSize

int g_totalVnodeSize = 0

static

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

g_vnodeActiveList

LIST_HEAD g_vnodeActiveList

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

g_vnodeFreeList

LIST_HEAD g_vnodeFreeList

@ver

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

g_vnodeMux

LosMux g_vnodeMux

static

操作链表互斥量

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

g_vnodeVirtualList

LIST_HEAD g_vnodeVirtualList

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