vfs_jffs2.c 文件参考

http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-bundles-fs-support-jffs2.html 更多...

浏览源代码.

函数
static void	Jffs2SetVtype (struct jffs2_inode *node, struct Vnode *pVnode)
	设置vnode节点的文件类型 更多...
time_t	Jffs2CurSec (void)
void	Jffs2NodeLock (void)
void	Jffs2NodeUnlock (void)
int	VfsJffs2Bind (struct Mount *mnt, struct Vnode *blkDriver, const void *data)
	VfsJffs2Bind 挂载JFFS2分区 更多...
int	VfsJffs2Unbind (struct Mount *mnt, struct Vnode **blkDriver)
	VfsJffs2Unbind 卸载JFFS2分区 更多...
int	VfsJffs2Lookup (struct Vnode *parentVnode, const char *path, int len, struct Vnode **ppVnode)
int	VfsJffs2Create (struct Vnode *parentVnode, const char *path, int mode, struct Vnode **ppVnode)
	创建一个jffs2 索引节点 更多...
int	VfsJffs2Close (struct file *filep)
ssize_t	VfsJffs2ReadPage (struct Vnode *vnode, char *buffer, off_t off)
ssize_t	VfsJffs2Read (struct file *filep, char *buffer, size_t bufLen)
ssize_t	VfsJffs2WritePage (struct Vnode *vnode, char *buffer, off_t pos, size_t buflen)
ssize_t	VfsJffs2Write (struct file *filep, const char *buffer, size_t bufLen)
off_t	VfsJffs2Seek (struct file *filep, off_t offset, int whence)
int	VfsJffs2Ioctl (struct file *filep, int cmd, unsigned long arg)
int	VfsJffs2Fsync (struct file *filep)
int	VfsJffs2Dup (const struct file *oldFile, struct file *newFile)
int	VfsJffs2Opendir (struct Vnode *pVnode, struct fs_dirent_s *dir)
int	VfsJffs2Readdir (struct Vnode *pVnode, struct fs_dirent_s *dir)
int	VfsJffs2Seekdir (struct Vnode *pVnode, struct fs_dirent_s *dir, unsigned long offset)
int	VfsJffs2Rewinddir (struct Vnode *pVnode, struct fs_dirent_s *dir)
int	VfsJffs2Closedir (struct Vnode *node, struct fs_dirent_s *dir)
int	VfsJffs2Mkdir (struct Vnode *parentNode, const char *dirName, mode_t mode, struct Vnode **ppVnode)
static int	Jffs2Truncate (struct Vnode *pVnode, unsigned int len)
int	VfsJffs2Truncate (struct Vnode *pVnode, off_t len)
int	VfsJffs2Truncate64 (struct Vnode *pVnode, off64_t len)
int	VfsJffs2Chattr (struct Vnode *pVnode, struct IATTR *attr)
int	VfsJffs2Rmdir (struct Vnode *parentVnode, struct Vnode *targetVnode, const char *path)
int	VfsJffs2Link (struct Vnode *oldVnode, struct Vnode *newParentVnode, struct Vnode **newVnode, const char *newName)
int	VfsJffs2Symlink (struct Vnode *parentVnode, struct Vnode **newVnode, const char *path, const char *target)
ssize_t	VfsJffs2Readlink (struct Vnode *vnode, char *buffer, size_t bufLen)
int	VfsJffs2Unlink (struct Vnode *parentVnode, struct Vnode *targetVnode, const char *path)
int	VfsJffs2Rename (struct Vnode *fromVnode, struct Vnode *toParentVnode, const char *fromName, const char *toName)
int	VfsJffs2Stat (struct Vnode *pVnode, struct stat *buf)
int	VfsJffs2Reclaim (struct Vnode *pVnode)
int	VfsJffs2Statfs (struct Mount *mnt, struct statfs *buf)
int	Jffs2MutexCreate (void)
void	Jffs2MutexDelete (void)
	FSMAP_ENTRY (jffs_fsmap, "jffs2", jffs_operations, TRUE, TRUE)

变量
struct VnodeOps	g_jffs2Vops
	jffs2 关于vnode操作接口实现 更多...
struct file_operations_vfs	g_jffs2Fops
	jffs2 关于vfs接口实现 更多...
static LosMux	g_jffs2FsLock
static pthread_mutex_t	g_jffs2NodeLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
struct Vnode *	g_jffs2PartList [CONFIG_MTD_PATTITION_NUM]
const struct MountOps	jffs_operations

详细描述

http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-bundles-fs-support-jffs2.html

 基本概念
    JFFS2是Journalling Flash File System Version 2（日志文件系统）的缩写，是针对MTD设备的日志型文件系统。

    OpenHarmony内核的JFFS2主要应用于NOR FLASH闪存，其特点是：可读写、支持数据压缩、提供了崩溃/掉电安全保护、
    提供“写平衡”支持等。闪存与磁盘介质有许多差异，直接将磁盘文件系统运行在闪存设备上，会导致性能和安全问题。
    为解决这一问题，需要实现一个特别针对闪存的文件系统，JFFS2就是这样一种文件系统。

 运行机制
    关于JFFS2文件系统的在存储设备上的实际物理布局，及文件系统本身的规格说明，请参考JFFS2的官方规格说明文档。
    https://sourceware.org/jffs2/
    这里仅列举几个对开发者和使用者会有一定影响的JFFS2的重要机制/特征：

    1. Mount机制及速度问题：按照JFFS2的设计，所有的文件会按照一定的规则，切分成大小不等的节点，
        依次存储到flash设备上。在mount流程中，需要获取到所有的这些节点信息并缓存到内存里。
        因此，mount速度和flash设备的大小和文件数量的多少成线性比例关系。这是JFFS2的原生设计问题，
        对于mount速度非常介意的用户，可以在内核编译时开启“Enable JFFS2 SUMMARY”选项，可以极大提升mount的速度。
        这个选项的原理是将mount需要的信息提前存储到flash上，在mount时读取并解析这块内容，使得mount的速度变得相对恒定。
        这个实际是空间换时间的做法，会消耗8%左右的额外空间。
    2. 写平衡的支持：由于flash设备的物理属性，读写都只能基于某个特定大小的“块”进行，为了防止某些特定的块磨损过于严重，
        在JFFS2中需要对写入的块进行“平衡”的管理，保证所有的块的写入次数都是相对平均的，进而保证flash设备的整体寿命。
    3. GC(garbage collection)机制：在JFFS2里发生删除动作，实际的物理空间并不会立即释放，而是由独立的GC线程来做
        空间整理和搬移等GC动作，和所有的GC机制一样，在JFFS2里的GC会对瞬时的读写性能有一定影响。另外，为了有空间能
        被用来做空间整理，JFFS2会对每个分区预留3块左右的空间，这个空间是用户不可见的。
    4. 压缩机制：当前使用的JFFS2，底层会自动的在每次读/写时进行解压/压缩动作，实际IO的大小和用户请求读写的大小
        并不会一样。特别在写入时，不能通过写入大小来和flash剩余空间的大小来预估写入一定会成功或者失败。
    5. 硬链接机制：JFFS2支持硬链接，底层实际占用的物理空间是一份，对于同一个文件的多个硬连接，并不会增加空间的占用；
        反之，只有当删除了所有的硬链接时，实际物理空间才会被释放。
 开发指导
    对于基于JFFS2和nor flash的开发，总体而言，与其他文件系统非常相似，因为都有VFS层来屏蔽了具体文件系统的差异，
    对外接口体现也都是标准的POSIX接口。

    对于整个裸nor flash设备而言，没有集中的地方来管理和记录分区的信息。因此，需要通过其他的配置方式来传递这部分信息
    （当前使用的方式是在烧写镜像的时候，使用bootargs参数配置的），然后在代码中调用相应的接口来添加分区，再进行挂载动作。  

版本

作者

weharmonyos.com | 鸿蒙研究站 | 每天死磕一点点

日期

2021-11-22

在文件 vfs_jffs2.c 中定义.

函数说明

FSMAP_ENTRY()

FSMAP_ENTRY	(	jffs_fsmap	,
		"jffs2"	,
		jffs_operations	,
		TRUE	,
		TRUE
	)

Jffs2CurSec()

time_t Jffs2CurSec

(

void

)

在文件 vfs_jffs2.c 第 130 行定义.

{
    struct timeval tv;
    if (gettimeofday(&tv, NULL))
        return 0;
    return (uint32_t)(tv.tv_sec);
}

函数调用图:

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

Jffs2MutexCreate()

int Jffs2MutexCreate

(

void

)

在文件 vfs_jffs2.c 第 1009 行定义.

{
    if (LOS_MuxInit(&g_jffs2FsLock, NULL) != LOS_OK) {
        PRINT_ERR("%s, LOS_MuxCreate failed\n", __FUNCTION__);
        return -1;
    } else {
        return 0;
    }
}

函数调用图:

Jffs2MutexDelete()

void Jffs2MutexDelete

(

void

)

在文件 vfs_jffs2.c 第 1019 行定义.

{
    (void)LOS_MuxDestroy(&g_jffs2FsLock);
}

函数调用图:

Jffs2NodeLock()

void Jffs2NodeLock

(

void

)

在文件 vfs_jffs2.c 第 138 行定义.

{
    (void)pthread_mutex_lock(&g_jffs2NodeLock);
}

函数调用图:

Jffs2NodeUnlock()

void Jffs2NodeUnlock

(

void

)

在文件 vfs_jffs2.c 第 143 行定义.

{
    (void)pthread_mutex_unlock(&g_jffs2NodeLock);
}

函数调用图:

Jffs2SetVtype()

static void Jffs2SetVtype ( struct jffs2_inode *  node, struct Vnode *  pVnode  )

static

设置vnode节点的文件类型

在文件 vfs_jffs2.c 第 112 行定义.

{
    switch (node->i_mode & S_IFMT) {
        case S_IFREG:
            pVnode->type = VNODE_TYPE_REG; // 普通文件
            break;
        case S_IFDIR:
            pVnode->type = VNODE_TYPE_DIR; // 目录/文件夹
            break;
        case S_IFLNK:
            pVnode->type = VNODE_TYPE_LNK; // 软链接
            break;
        default:
            pVnode->type = VNODE_TYPE_UNKNOWN;
            break;
    }
}

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

Jffs2Truncate()

static int Jffs2Truncate ( struct Vnode *  pVnode, unsigned int  len  )

static

在文件 vfs_jffs2.c 第 698 行定义.

{
    int ret;
    struct IATTR attr = {0};
 
    attr.attr_chg_size = len;
    attr.attr_chg_valid = CHG_SIZE;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    ret = jffs2_setattr((struct jffs2_inode *)pVnode->data, &attr);
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

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

VfsJffs2Bind()

int VfsJffs2Bind	(	struct Mount *	mnt,
		struct Vnode *	blkDriver,
		const void *	data
	)

VfsJffs2Bind 挂载JFFS2分区

    运行命令：
        OHOS # mount /dev/spinorblk1 /jffs1 jffs2
    将从串口得到如下回应信息，表明挂载成功。
    OHOS # mount /dev/spinorblk1 /jffs1 jffs2
    mount OK
    挂载成功后，用户就能对norflash进行读写操作。  

参数

blkDriver
data
mnt

返回

参见

在文件 vfs_jffs2.c 第 165 行定义.

{
    int ret;
    int partNo;
    mtd_partition *p = NULL;
    struct MtdDev *mtd = NULL;
    struct Vnode *pv = NULL;
    struct jffs2_inode *rootNode = NULL;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    p = (mtd_partition *)((struct drv_data *)blkDriver->data)->priv; //分区结构
    mtd = (struct MtdDev *)(p->mtd_info);//分区信息
 
    /* find a empty mte in partition table */
    if (mtd == NULL || mtd->type != MTD_NORFLASH) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return -EINVAL;
    }
 
    partNo = p->patitionnum;
 
    ret = jffs2_mount(partNo, &rootNode, mnt->mountFlags);
    if (ret != 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
 
    ret = VnodeAlloc(&g_jffs2Vops, &pv);
    if (ret != 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        goto ERROR_WITH_VNODE;
    }
    pv->type = VNODE_TYPE_DIR;  
    pv->data = (void *)rootNode;
    pv->originMount = mnt;
    pv->fop = &g_jffs2Fops;
    mnt->data = p;
    mnt->vnodeCovered = pv;
    pv->uid = rootNode->i_uid;
    pv->gid = rootNode->i_gid;
    pv->mode = rootNode->i_mode;
 
    (void)VfsHashInsert(pv, rootNode->i_ino);
 
    g_jffs2PartList[partNo] = blkDriver;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return 0;
ERROR_WITH_VNODE:
    return ret;
}

函数调用图:

VfsJffs2Chattr()

int VfsJffs2Chattr	(	struct Vnode *	pVnode,
		struct IATTR *	attr
	)

在文件 vfs_jffs2.c 第 724 行定义.

{
    int ret;
    struct jffs2_inode *node = NULL;
 
    if (pVnode == NULL) {
        return -EINVAL;
    }
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = pVnode->data;
    ret = jffs2_setattr(node, attr);
    if (ret == 0) {
        pVnode->uid = node->i_uid;
        pVnode->gid = node->i_gid;
        pVnode->mode = node->i_mode;
    }
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

VfsJffs2Close()

int VfsJffs2Close

(

struct file *

filep

)

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

{
    return 0;
}

VfsJffs2Closedir()

int VfsJffs2Closedir	(	struct Vnode *	node,
		struct fs_dirent_s *	dir
	)

在文件 vfs_jffs2.c 第 655 行定义.

{
    return 0;
}

VfsJffs2Create()

int VfsJffs2Create	(	struct Vnode *	parentVnode,
		const char *	path,
		int	mode,
		struct Vnode **	ppVnode
	)

创建一个jffs2 索引节点

在文件 vfs_jffs2.c 第 314 行定义.

{
    int ret;
    struct jffs2_inode *newNode = NULL;
    struct Vnode *newVnode = NULL;
 
    ret = VnodeAlloc(&g_jffs2Vops, &newVnode);
    if (ret != 0) {
        return -ENOMEM;
    }
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    ret = jffs2_create((struct jffs2_inode *)parentVnode->data, (const unsigned char *)path, mode, &newNode);
    if (ret != 0) {
        VnodeFree(newVnode);
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
 
    newVnode->type = VNODE_TYPE_REG;
    newVnode->fop = parentVnode->fop;
    newVnode->data = newNode;
    newVnode->parent = parentVnode;
    newVnode->originMount = parentVnode->originMount;
    newVnode->uid = newNode->i_uid;
    newVnode->gid = newNode->i_gid;
    newVnode->mode = newNode->i_mode;
 
    (void)VfsHashInsert(newVnode, newNode->i_ino);
 
    *ppVnode = newVnode;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return 0;
}

函数调用图:

VfsJffs2Dup()

int VfsJffs2Dup	(	const struct file *	oldFile,
		struct file *	newFile
	)

在文件 vfs_jffs2.c 第 608 行定义.

{
    PRINT_DEBUG("%s NOT SUPPORT\n", __FUNCTION__);
    return -ENOSYS;
}

VfsJffs2Fsync()

int VfsJffs2Fsync

(

struct file *

filep

)

在文件 vfs_jffs2.c 第 601 行定义.

{
    /* jffs2_write directly write to flash, sync is OK.
        BUT after pagecache enabled, pages need to be flushed to flash */
    return 0;
}

VfsJffs2Ioctl()

int VfsJffs2Ioctl	(	struct file *	filep,
		int	cmd,
		unsigned long	arg
	)

在文件 vfs_jffs2.c 第 595 行定义.

{
    PRINT_DEBUG("%s NOT SUPPORT\n", __FUNCTION__);
    return -ENOSYS;
}

VfsJffs2Link()

int VfsJffs2Link	(	struct Vnode *	oldVnode,
		struct Vnode *	newParentVnode,
		struct Vnode **	newVnode,
		const char *	newName
	)

在文件 vfs_jffs2.c 第 771 行定义.

{
    int ret;
    struct jffs2_inode *oldInode = oldVnode->data;
    struct jffs2_inode *newParentInode = newParentVnode->data;
    struct Vnode *pVnode = NULL;
 
    ret = VnodeAlloc(&g_jffs2Vops, &pVnode);
    if (ret != 0) {
        return -ENOMEM;
    }
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    ret = jffs2_link(oldInode, newParentInode, (const unsigned char *)newName);
    if (ret != 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        VnodeFree(pVnode);
        return ret;
    }
 
    pVnode->type = VNODE_TYPE_REG;
    pVnode->fop = &g_jffs2Fops;
    pVnode->parent = newParentVnode;
    pVnode->originMount = newParentVnode->originMount;
    pVnode->data = oldInode;
    pVnode->uid = oldVnode->uid;
    pVnode->gid = oldVnode->gid;
    pVnode->mode = oldVnode->mode;
 
    *newVnode = pVnode;
    (void)VfsHashInsert(*newVnode, oldInode->i_ino);
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

VfsJffs2Lookup()

int VfsJffs2Lookup	(	struct Vnode *	parentVnode,
		const char *	path,
		int	len,
		struct Vnode **	ppVnode
	)

在文件 vfs_jffs2.c 第 263 行定义.

{
    int ret;
    struct Vnode *newVnode = NULL;
    struct jffs2_inode *node = NULL;
    struct jffs2_inode *parentNode = NULL;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    parentNode = (struct jffs2_inode *)parentVnode->data;//获取私有数据
    node = jffs2_lookup(parentNode, (const unsigned char *)path, len);
    if (!node) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return -ENOENT;
    }
 
    (void)VfsHashGet(parentVnode->originMount, node->i_ino, &newVnode, NULL, NULL);
    if (newVnode) {
        if (newVnode->data == NULL) {
            LOS_Panic("#####VfsHashGet error#####\n");
         }
        newVnode->parent = parentVnode;
        *ppVnode = newVnode;
        LOS_MuxUnlock(&g_jffs2FsLock);
        return 0;
    }
    ret = VnodeAlloc(&g_jffs2Vops, &newVnode);
    if (ret != 0) {
        PRINT_ERR("%s-%d, ret: %x\n", __FUNCTION__, __LINE__, ret);
        (void)jffs2_iput(node);
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
 
    Jffs2SetVtype(node, newVnode);
    newVnode->fop = parentVnode->fop;
    newVnode->data = node;
    newVnode->parent = parentVnode;
    newVnode->originMount = parentVnode->originMount;
    newVnode->uid = node->i_uid;
    newVnode->gid = node->i_gid;
    newVnode->mode = node->i_mode;
 
    (void)VfsHashInsert(newVnode, node->i_ino);
 
    *ppVnode = newVnode;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return 0;
}

函数调用图:

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

VfsJffs2Mkdir()

int VfsJffs2Mkdir	(	struct Vnode *	parentNode,
		const char *	dirName,
		mode_t	mode,
		struct Vnode **	ppVnode
	)

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

{
    int ret;
    struct jffs2_inode *node = NULL;
    struct Vnode *newVnode = NULL;
 
    ret = VnodeAlloc(&g_jffs2Vops, &newVnode);
    if (ret != 0) {
        return -ENOMEM;
    }
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    ret = jffs2_mkdir((struct jffs2_inode *)parentNode->data, (const unsigned char *)dirName, mode, &node);
    if (ret != 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        VnodeFree(newVnode);
        return ret;
    }
 
    newVnode->type = VNODE_TYPE_DIR;
    newVnode->fop = parentNode->fop;
    newVnode->data = node;
    newVnode->parent = parentNode;
    newVnode->originMount = parentNode->originMount;
    newVnode->uid = node->i_uid;
    newVnode->gid = node->i_gid;
    newVnode->mode = node->i_mode;
 
    *ppVnode = newVnode;
 
    (void)VfsHashInsert(newVnode, node->i_ino);
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return 0;
}

函数调用图:

VfsJffs2Opendir()

int VfsJffs2Opendir	(	struct Vnode *	pVnode,
		struct fs_dirent_s *	dir
	)

在文件 vfs_jffs2.c 第 614 行定义.

{
    dir->fd_int_offset = 0;
    return 0;
}

VfsJffs2Read()

ssize_t VfsJffs2Read	(	struct file *	filep,
		char *	buffer,
		size_t	bufLen
	)

在文件 vfs_jffs2.c 第 382 行定义.

{
    struct jffs2_inode *node = NULL;
    struct jffs2_inode_info *f = NULL;
    struct jffs2_sb_info *c = NULL;
    int ret;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)filep->f_vnode->data;
    f = JFFS2_INODE_INFO(node);
    c = JFFS2_SB_INFO(node->i_sb);
 
    off_t pos = min(node->i_size, filep->f_pos);
    off_t len = min(bufLen, (node->i_size - pos));
    ret = jffs2_read_inode_range(c, f, (unsigned char *)buffer, filep->f_pos, len);
    if (ret) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
    node->i_atime = Jffs2CurSec();
    filep->f_pos += len;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return len;
}

函数调用图:

VfsJffs2Readdir()

int VfsJffs2Readdir	(	struct Vnode *	pVnode,
		struct fs_dirent_s *	dir
	)

在文件 vfs_jffs2.c 第 620 行定义.

{
    int ret;
    int i = 0;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    /* set jffs2_d */
    while (i < dir->read_cnt) {
        ret = jffs2_readdir((struct jffs2_inode *)pVnode->data, &dir->fd_position,
                            &dir->fd_int_offset, &dir->fd_dir[i]);
        if (ret) {
            break;
        }
 
        i++;
    }
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return i;
}

函数调用图:

VfsJffs2Readlink()

ssize_t VfsJffs2Readlink	(	struct Vnode *	vnode,
		char *	buffer,
		size_t	bufLen
	)

在文件 vfs_jffs2.c 第 842 行定义.

{
    struct jffs2_inode *inode = NULL;
    struct jffs2_inode_info *f = NULL;
    ssize_t targetLen;
    ssize_t cnt;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    inode = (struct jffs2_inode *)vnode->data;
    f = JFFS2_INODE_INFO(inode);
    targetLen = strlen((const char *)f->target);
    if (bufLen == 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return 0;
    }
 
    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;
    }
    buffer[cnt] = '\0';
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return cnt;
}

函数调用图:

VfsJffs2ReadPage()

ssize_t VfsJffs2ReadPage	(	struct Vnode *	vnode,
		char *	buffer,
		off_t	off
	)

在文件 vfs_jffs2.c 第 355 行定义.

{
    struct jffs2_inode *node = NULL;
    struct jffs2_inode_info *f = NULL;
    struct jffs2_sb_info *c = NULL;
    int ret;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)vnode->data;
    f = JFFS2_INODE_INFO(node);
    c = JFFS2_SB_INFO(node->i_sb);
 
    off_t pos = min(node->i_size, off);
    ssize_t len = min(PAGE_SIZE, (node->i_size - pos));
    ret = jffs2_read_inode_range(c, f, (unsigned char *)buffer, off, len);
    if (ret) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
    node->i_atime = Jffs2CurSec();
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return len;
}

函数调用图:

VfsJffs2Reclaim()

int VfsJffs2Reclaim

(

struct Vnode *

pVnode

)

在文件 vfs_jffs2.c 第 975 行定义.

{
    return 0;
}

VfsJffs2Rename()

int VfsJffs2Rename	(	struct Vnode *	fromVnode,
		struct Vnode *	toParentVnode,
		const char *	fromName,
		const char *	toName
	)

在文件 vfs_jffs2.c 第 898 行定义.

{
    int ret;
    struct Vnode *fromParentVnode = NULL;
    struct Vnode *toVnode = NULL;
    struct jffs2_inode *fromNode = NULL;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    fromParentVnode = fromVnode->parent;
 
    ret = VfsJffs2Lookup(toParentVnode, toName, strlen(toName), &toVnode);
    if (ret == 0) {
        if (toVnode->type == VNODE_TYPE_DIR) {
            ret = VfsJffs2Rmdir(toParentVnode, toVnode, (char *)toName);
        } else {
            ret = VfsJffs2Unlink(toParentVnode, toVnode, (char *)toName);
        }
        if (ret) {
            PRINTK("%s-%d remove newname(%s) failed ret=%d\n", __FUNCTION__, __LINE__, toName, ret);
            LOS_MuxUnlock(&g_jffs2FsLock);
            return ret;
        }
    }
    fromNode = (struct jffs2_inode *)fromVnode->data;
    ret = jffs2_rename((struct jffs2_inode *)fromParentVnode->data, fromNode,
        (const unsigned char *)fromName, (struct jffs2_inode *)toParentVnode->data, (const unsigned char *)toName);
    fromVnode->parent = toParentVnode;
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    if (ret) {
        return ret;
    }
 
    return 0;
}

函数调用图:

VfsJffs2Rewinddir()

int VfsJffs2Rewinddir	(	struct Vnode *	pVnode,
		struct fs_dirent_s *	dir
	)

在文件 vfs_jffs2.c 第 648 行定义.

{
    dir->fd_int_offset = 0;
 
    return 0;
}

VfsJffs2Rmdir()

int VfsJffs2Rmdir	(	struct Vnode *	parentVnode,
		struct Vnode *	targetVnode,
		const char *	path
	)

在文件 vfs_jffs2.c 第 746 行定义.

{
    int ret;
    struct jffs2_inode *parentInode = NULL;
    struct jffs2_inode *targetInode = NULL;
 
    if (!parentVnode || !targetVnode) {
        return -EINVAL;
    }
 
    parentInode = (struct jffs2_inode *)parentVnode->data;
    targetInode = (struct jffs2_inode *)targetVnode->data;
 
    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);
    }
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

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

VfsJffs2Seek()

off_t VfsJffs2Seek	(	struct file *	filep,
		off_t	offset,
		int	whence
	)

在文件 vfs_jffs2.c 第 559 行定义.

{
    struct jffs2_inode *node = NULL;
    loff_t filePos;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)filep->f_vnode->data;
    filePos = filep->f_pos;
 
    switch (whence) {
        case SEEK_SET:
            filePos = offset;
            break;
 
        case SEEK_CUR:
            filePos += offset;
            break;
 
        case SEEK_END:
            filePos = node->i_size + offset;
            break;
 
        default:
            LOS_MuxUnlock(&g_jffs2FsLock);
            return -EINVAL;
    }
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    if (filePos < 0)
        return -EINVAL;
 
    return filePos;
}

函数调用图:

VfsJffs2Seekdir()

int VfsJffs2Seekdir	(	struct Vnode *	pVnode,
		struct fs_dirent_s *	dir,
		unsigned long	offset
	)

在文件 vfs_jffs2.c 第 643 行定义.

{
    return 0;
}

VfsJffs2Stat()

int VfsJffs2Stat	(	struct Vnode *	pVnode,
		struct stat *	buf
	)

在文件 vfs_jffs2.c 第 934 行定义.

{
    struct jffs2_inode *node = NULL;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)pVnode->data;
    switch (node->i_mode & S_IFMT) {
        case S_IFREG:
        case S_IFDIR:
        case S_IFLNK:
            buf->st_mode = node->i_mode;
            break;
 
        default:
            buf->st_mode = DT_UNKNOWN;
            break;
    }
 
    buf->st_dev = 0;
    buf->st_ino = node->i_ino;
    buf->st_nlink = node->i_nlink;
    buf->st_uid = node->i_uid;
    buf->st_gid = node->i_gid;
    buf->st_size = node->i_size;
    buf->st_blksize = BLOCK_SIZE;
    buf->st_blocks = buf->st_size / buf->st_blksize;
    buf->st_atime = node->i_atime;
    buf->st_mtime = node->i_mtime;
    buf->st_ctime = node->i_ctime;
 
    /* Adapt to kstat member long tv_sec */
    buf->__st_atim32.tv_sec = (long)node->i_atime;
    buf->__st_mtim32.tv_sec = (long)node->i_mtime;
    buf->__st_ctim32.tv_sec = (long)node->i_ctime;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return 0;
}

函数调用图:

VfsJffs2Statfs()

int VfsJffs2Statfs	(	struct Mount *	mnt,
		struct statfs *	buf
	)

在文件 vfs_jffs2.c 第 980 行定义.

{
    unsigned long freeSize;
    struct jffs2_sb_info *c = NULL;
    struct jffs2_inode *rootNode = NULL;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    rootNode = (struct jffs2_inode *)mnt->vnodeCovered->data;
    c = JFFS2_SB_INFO(rootNode->i_sb);
 
    freeSize = c->free_size + c->dirty_size;
    buf->f_type = JFFS2_SUPER_MAGIC;
    buf->f_bsize = PAGE_SIZE;
    buf->f_blocks = (((uint64_t)c->nr_blocks) * c->sector_size) / PAGE_SIZE;
    buf->f_bfree = freeSize / PAGE_SIZE;
    buf->f_bavail = buf->f_bfree;
    buf->f_namelen = NAME_MAX;
    buf->f_fsid.__val[0] = JFFS2_SUPER_MAGIC;
    buf->f_fsid.__val[1] = 1;
    buf->f_frsize = BLOCK_SIZE;
    buf->f_files = 0;
    buf->f_ffree = 0;
    buf->f_flags = mnt->mountFlags;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return 0;
}

函数调用图:

VfsJffs2Symlink()

int VfsJffs2Symlink	(	struct Vnode *	parentVnode,
		struct Vnode **	newVnode,
		const char *	path,
		const char *	target
	)

在文件 vfs_jffs2.c 第 807 行定义.

{
    int ret;
    struct jffs2_inode *inode = NULL;
    struct Vnode *pVnode = NULL;
 
    ret = VnodeAlloc(&g_jffs2Vops, &pVnode);
    if (ret != 0) {
        return -ENOMEM;
    }
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
    ret = jffs2_symlink((struct jffs2_inode *)parentVnode->data, &inode, (const unsigned char *)path, target);
    if (ret != 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        VnodeFree(pVnode);
        return ret;
    }
 
    pVnode->type = VNODE_TYPE_LNK;
    pVnode->fop = &g_jffs2Fops;
    pVnode->parent = parentVnode;
    pVnode->originMount = parentVnode->originMount;
    pVnode->data = inode;
    pVnode->uid = inode->i_uid;
    pVnode->gid = inode->i_gid;
    pVnode->mode = inode->i_mode;
 
    *newVnode = pVnode;
    (void)VfsHashInsert(*newVnode, inode->i_ino);
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

VfsJffs2Truncate()

int VfsJffs2Truncate	(	struct Vnode *	pVnode,
		off_t	len
	)

在文件 vfs_jffs2.c 第 712 行定义.

{
    int ret = Jffs2Truncate(pVnode, (unsigned int)len);
    return ret;
}

函数调用图:

VfsJffs2Truncate64()

int VfsJffs2Truncate64	(	struct Vnode *	pVnode,
		off64_t	len
	)

在文件 vfs_jffs2.c 第 718 行定义.

{
    int ret = Jffs2Truncate(pVnode, (unsigned int)len);
    return ret;
}

函数调用图:

VfsJffs2Unbind()

int VfsJffs2Unbind	(	struct Mount *	mnt,
		struct Vnode **	blkDriver
	)

VfsJffs2Unbind 卸载JFFS2分区

    调用int umount(const char *target)函数卸载分区，只需要正确给出挂载点即可。
   运行命令：
   OHOS # umount /jffs1
   将从串口得到如下回应信息，表明卸载成功。
    OHOS # umount /jffs1
    umount ok

参数

blkDriver
mnt

返回

参见

在文件 vfs_jffs2.c 第 234 行定义.

{
    int ret;
    mtd_partition *p = NULL;
    int partNo;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    p = (mtd_partition *)mnt->data;
    if (p == NULL) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return -EINVAL;
    }
 
    partNo = p->patitionnum;
    ret = jffs2_umount((struct jffs2_inode *)mnt->vnodeCovered->data);
    if (ret) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
 
    free(p->mountpoint_name);
    p->mountpoint_name = NULL;
    *blkDriver = g_jffs2PartList[partNo];
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return 0;
}

函数调用图:

VfsJffs2Unlink()

int VfsJffs2Unlink	(	struct Vnode *	parentVnode,
		struct Vnode *	targetVnode,
		const char *	path
	)

在文件 vfs_jffs2.c 第 872 行定义.

{
    int ret;
    struct jffs2_inode *parentInode = NULL;
    struct jffs2_inode *targetInode = NULL;
 
    if (!parentVnode || !targetVnode) {
        PRINTK("%s-%d parentVnode=%x, targetVnode=%x\n", __FUNCTION__, __LINE__, parentVnode, targetVnode);
        return -EINVAL;
    }
 
    parentInode = (struct jffs2_inode *)parentVnode->data;
    targetInode = (struct jffs2_inode *)targetVnode->data;
 
    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);
    }
 
    LOS_MuxUnlock(&g_jffs2FsLock);
    return ret;
}

函数调用图:

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

VfsJffs2Write()

ssize_t VfsJffs2Write	(	struct file *	filep,
		const char *	buffer,
		size_t	bufLen
	)

在文件 vfs_jffs2.c 第 463 行定义.

{
    struct jffs2_inode *node = NULL;
    struct jffs2_inode_info *f = NULL;
    struct jffs2_sb_info *c = NULL;
    struct jffs2_raw_inode ri = {0};
    struct IATTR attr = {0};
    int ret;
    off_t pos;
    uint32_t writtenLen;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)filep->f_vnode->data;
    f = JFFS2_INODE_INFO(node);
    c = JFFS2_SB_INFO(node->i_sb);
    pos = filep->f_pos;
 
#ifdef LOSCFG_KERNEL_SMP
    struct super_block *sb = node->i_sb;
    UINT16 gcCpuMask = LOS_TaskCpuAffiGet(sb->s_gc_thread);
    UINT32 curTaskId = LOS_CurTaskIDGet();
    UINT16 curCpuMask = LOS_TaskCpuAffiGet(curTaskId);
    if (curCpuMask != gcCpuMask) {
        if (curCpuMask != LOSCFG_KERNEL_CPU_MASK) {
            (void)LOS_TaskCpuAffiSet(sb->s_gc_thread, curCpuMask);
        } else {
            (void)LOS_TaskCpuAffiSet(curTaskId, gcCpuMask);
        }
    }
#endif
    if (pos < 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return -EINVAL;
    }
 
    ri.ino = cpu_to_je32(f->inocache->ino);
    ri.mode = cpu_to_jemode(node->i_mode);
    ri.uid = cpu_to_je16(node->i_uid);
    ri.gid = cpu_to_je16(node->i_gid);
    ri.atime = ri.ctime = ri.mtime = cpu_to_je32(Jffs2CurSec());
 
    if (pos > node->i_size) {
        int err;
        attr.attr_chg_valid = CHG_SIZE;
        attr.attr_chg_size = pos;
        err = jffs2_setattr(node, &attr);
        if (err) {
            LOS_MuxUnlock(&g_jffs2FsLock);
            return err;
        }
    }
    ri.isize = cpu_to_je32(node->i_size);
 
    ret = jffs2_write_inode_range(c, f, &ri, (unsigned char *)buffer, pos, bufLen, &writtenLen);
    if (ret) {
        pos += writtenLen;
 
        node->i_mtime = node->i_ctime = je32_to_cpu(ri.mtime);
        if (pos > node->i_size)
            node->i_size = pos;
 
        filep->f_pos = pos;
 
        LOS_MuxUnlock(&g_jffs2FsLock);
 
        return ret;
    }
 
    if (writtenLen != bufLen) {
        pos += writtenLen;
 
        node->i_mtime = node->i_ctime = je32_to_cpu(ri.mtime);
        if (pos > node->i_size)
            node->i_size = pos;
 
        filep->f_pos = pos;
 
        LOS_MuxUnlock(&g_jffs2FsLock);
 
        return -ENOSPC;
    }
 
    pos += bufLen;
 
    node->i_mtime = node->i_ctime = je32_to_cpu(ri.mtime);
    if (pos > node->i_size)
        node->i_size = pos;
 
    filep->f_pos = pos;
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return writtenLen;
}

函数调用图:

VfsJffs2WritePage()

ssize_t VfsJffs2WritePage	(	struct Vnode *	vnode,
		char *	buffer,
		off_t	pos,
		size_t	buflen
	)

在文件 vfs_jffs2.c 第 410 行定义.

{
    struct jffs2_inode *node = NULL;
    struct jffs2_inode_info *f = NULL;
    struct jffs2_sb_info *c = NULL;
    struct jffs2_raw_inode ri = {0};
    struct IATTR attr = {0};
    int ret;
    uint32_t writtenLen;
 
    LOS_MuxLock(&g_jffs2FsLock, (uint32_t)JFFS2_WAITING_FOREVER);
 
    node = (struct jffs2_inode *)vnode->data;
    f = JFFS2_INODE_INFO(node);
    c = JFFS2_SB_INFO(node->i_sb);
 
    if (pos < 0) {
        LOS_MuxUnlock(&g_jffs2FsLock);
        return -EINVAL;
    }
 
    ri.ino = cpu_to_je32(f->inocache->ino);
    ri.mode = cpu_to_jemode(node->i_mode);
    ri.uid = cpu_to_je16(node->i_uid);
    ri.gid = cpu_to_je16(node->i_gid);
    ri.atime = ri.ctime = ri.mtime = cpu_to_je32(Jffs2CurSec());
 
    if (pos > node->i_size) {
        int err;
        attr.attr_chg_valid = CHG_SIZE;
        attr.attr_chg_size = pos;
        err = jffs2_setattr(node, &attr);
        if (err) {
            LOS_MuxUnlock(&g_jffs2FsLock);
            return err;
        }
    }
    ri.isize = cpu_to_je32(node->i_size);
 
    ret = jffs2_write_inode_range(c, f, &ri, (unsigned char *)buffer, pos, buflen, &writtenLen);
    if (ret) {
        node->i_mtime = node->i_ctime = je32_to_cpu(ri.mtime);
        LOS_MuxUnlock(&g_jffs2FsLock);
        return ret;
    }
 
    node->i_mtime = node->i_ctime = je32_to_cpu(ri.mtime);
 
    LOS_MuxUnlock(&g_jffs2FsLock);
 
    return (ssize_t)writtenLen;
}

函数调用图:

变量说明

g_jffs2Fops

struct file_operations_vfs g_jffs2Fops

初始值:

= {
    .read = VfsJffs2Read,
    .write = VfsJffs2Write,
    .mmap = OsVfsFileMmap,
    .seek = VfsJffs2Seek,
    .close = VfsJffs2Close,
    .fsync = VfsJffs2Fsync,
}

jffs2 关于vfs接口实现

在文件 vfs_jffs2.c 第 105 行定义.

g_jffs2FsLock

LosMux g_jffs2FsLock

static

在文件 vfs_jffs2.c 第 107 行定义.

g_jffs2NodeLock

pthread_mutex_t g_jffs2NodeLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP

static

在文件 vfs_jffs2.c 第 109 行定义.

g_jffs2PartList

struct Vnode* g_jffs2PartList[CONFIG_MTD_PATTITION_NUM]

jffs2 分区列表

在文件 vfs_jffs2.c 第 110 行定义.

g_jffs2Vops

struct VnodeOps g_jffs2Vops

初始值:

= {
    .Lookup = VfsJffs2Lookup,
    .Create = VfsJffs2Create,
    .ReadPage = VfsJffs2ReadPage,
    .WritePage = VfsJffs2WritePage,
    .Rename = VfsJffs2Rename,
    .Mkdir = VfsJffs2Mkdir,
    .Getattr = VfsJffs2Stat,
    .Opendir = VfsJffs2Opendir,
    .Readdir = VfsJffs2Readdir,
    .Closedir = VfsJffs2Closedir,
    .Rewinddir = VfsJffs2Rewinddir,
    .Unlink = VfsJffs2Unlink,
    .Rmdir = VfsJffs2Rmdir,
    .Chattr = VfsJffs2Chattr,
    .Reclaim = VfsJffs2Reclaim,
    .Truncate = VfsJffs2Truncate,
    .Truncate64 = VfsJffs2Truncate64,
    .Link = VfsJffs2Link,
    .Symlink = VfsJffs2Symlink,
    .Readlink = VfsJffs2Readlink,
}

jffs2 关于vnode操作接口实现

在文件 vfs_jffs2.c 第 104 行定义.

jffs_operations

const struct MountOps jffs_operations

初始值:

= {
    .Mount = VfsJffs2Bind,      
    .Unmount = VfsJffs2Unbind,  
    .Statfs = VfsJffs2Statfs,
}

在文件 vfs_jffs2.c 第 1024 行定义.