fatfs.h 文件参考

浏览源代码.

函数
int	fatfs_2_vfs (int result)
int	fatfs_lookup (struct Vnode *parent, const char *name, int len, struct Vnode **vpp)
	fat文件系统对 Lookup 接口的实现 更多...
int	fatfs_create (struct Vnode *parent, const char *name, int mode, struct Vnode **vpp)
	创建 fat vnode 节点 更多...
int	fatfs_read (struct file *filep, char *buff, size_t count)
off_t	fatfs_lseek64 (struct file *filep, off64_t offset, int whence)
off64_t	fatfs_lseek (struct file *filep, off_t offset, int whence)
int	fatfs_write (struct file *filep, const char *buff, size_t count)
int	fatfs_fsync (struct file *filep)
int	fatfs_fallocate64 (struct file *filep, int mode, off64_t offset, off64_t len)
int	fatfs_fallocate (struct file *filep, int mode, off_t offset, off_t len)
int	fatfs_truncate64 (struct Vnode *vnode, off64_t len)
int	fatfs_truncate (struct Vnode *vnode, off_t len)
int	fatfs_mount (struct Mount *mount, struct Vnode *device, const void *data)
	fat将分区文件系统挂载 举例: mount /dev/mmcblk0p0 /bin1/vs/sd vfat 更多...
int	fatfs_umount (struct Mount *mount, struct Vnode **device)
int	fatfs_statfs (struct Mount *mount, struct statfs *info)
int	fatfs_stat (struct Vnode *vnode, struct stat *buff)
int	fatfs_chattr (struct Vnode *vnode, struct IATTR *attr)
int	fatfs_opendir (struct Vnode *vnode, struct fs_dirent_s *idir)
int	fatfs_readdir (struct Vnode *vnode, struct fs_dirent_s *idir)
int	fatfs_rewinddir (struct Vnode *vnode, struct fs_dirent_s *dir)
int	fatfs_closedir (struct Vnode *vnode, struct fs_dirent_s *dir)
int	fatfs_rename (struct Vnode *oldvnode, struct Vnode *newparent, const char *oldname, const char *newname)
int	fatfs_mkfs (struct Vnode *device, int sectors, int option)
int	fatfs_mkdir (struct Vnode *parent, const char *name, mode_t mode, struct Vnode **vpp)
int	fatfs_rmdir (struct Vnode *parent, struct Vnode *vp, const char *name)
int	fatfs_unlink (struct Vnode *parent, struct Vnode *vp, const char *name)
int	fatfs_ioctl (struct file *filep, int req, unsigned long arg)
int	fatfs_fscheck (struct Vnode *vnode, struct fs_dirent_s *dir)
FRESULT	find_fat_partition (FATFS *fs, los_part *part, BYTE *format, QWORD *start_sector)
FRESULT	init_fatobj (FATFS *fs, BYTE fmt, QWORD start_sector)
FRESULT	_mkfs (los_part *partition, const MKFS_PARM *opt, BYTE *work, UINT len)

变量
char	FatLabel [LABEL_LEN]

函数说明

_mkfs()

FRESULT _mkfs	(	los_part *	partition,
		const MKFS_PARM *	opt,
		BYTE *	work,
		UINT	len
	)

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

fatfs_2_vfs()

int fatfs_2_vfs

(

int

result

)

在文件 fatfs.c 第 96 行定义.

{
    int status = ENOERR;
 
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
    if (result < 0 || result >= VIRERR_BASE) {
        return result;
    }
#else
    if (result < 0) {
        return result;
    }
#endif
 
    /* FatFs errno to Libc errno */
    switch (result) {
        case FR_OK:
            break;
 
        case FR_NO_FILE:
        case FR_NO_PATH:
            status = ENOENT;
            break;
 
        case FR_NO_FILESYSTEM:
            status = ENOTSUP;
            break;
 
        case FR_INVALID_NAME:
            status = EINVAL;
            break;
 
        case FR_EXIST:
        case FR_INVALID_OBJECT:
            status = EEXIST;
            break;
 
        case FR_DISK_ERR:
        case FR_NOT_READY:
        case FR_INT_ERR:
            status = EIO;
            break;
 
        case FR_WRITE_PROTECTED:
            status = EROFS;
            break;
        case FR_MKFS_ABORTED:
        case FR_INVALID_PARAMETER:
            status = EINVAL;
            break;
 
        case FR_NO_SPACE_LEFT:
            status = ENOSPC;
            break;
        case FR_NO_DIRENTRY:
            status = ENFILE;
            break;
        case FR_NO_EMPTY_DIR:
            status = ENOTEMPTY;
            break;
        case FR_IS_DIR:
            status = EISDIR;
            break;
        case FR_NO_DIR:
            status = ENOTDIR;
            break;
        case FR_NO_EPERM:
        case FR_DENIED:
            status = EPERM;
            break;
        case FR_LOCKED:
        case FR_TIMEOUT:
            status = EBUSY;
            break;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
        case FR_MODIFIED:
            status = -VIRERR_MODIFIED;
            break;
        case FR_CHAIN_ERR:
            status = -VIRERR_CHAIN_ERR;
            break;
        case FR_OCCUPIED:
            status = -VIRERR_OCCUPIED;
            break;
        case FR_NOTCLEAR:
            status = -VIRERR_NOTCLEAR;
            break;
        case FR_NOTFIT:
            status = -VIRERR_NOTFIT;
            break;
        case FR_INVAILD_FATFS:
            status = -VIRERR_INTER_ERR;
            break;
#endif
        default:
            status = -FAT_ERROR;
            break;
    }
 
    return status;
}

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

fatfs_chattr()

int fatfs_chattr	(	struct Vnode *	vnode,
		struct IATTR *	attr
	)

在文件 fatfs.c 第 1494 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    DIR *dp = &(dfp->f_dir);
    FILINFO *finfo = &(dfp->fno);
    BYTE *dir = dp->dir;
    DWORD ftime;
    FRESULT result;
    int ret;
 
    if (finfo->fname[0] == '/') { /* Is root dir of fatfs ? */
        return 0;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        result = FR_TIMEOUT;
        goto ERROR_OUT;
    }
 
    result = move_window(fs, dp->sect);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
 
    if (attr->attr_chg_valid & CHG_MODE) {
        /* FAT only support readonly flag */
        if ((attr->attr_chg_mode & S_IWUSR) == 0 && (finfo->fattrib & AM_RDO) == 0) {
            dir[DIR_Attr] |= AM_RDO;
            finfo->fattrib |= AM_RDO;
            fs->wflag = 1;
        } else if ((attr->attr_chg_mode & S_IWUSR) != 0 && (finfo->fattrib & AM_RDO) != 0) {
            dir[DIR_Attr] &= ~AM_RDO;
            finfo->fattrib &= ~AM_RDO;
            fs->wflag = 1;
        }
        vp->mode = fatfs_get_mode(finfo->fattrib, fs->fs_mode);
    }
 
    if (attr->attr_chg_valid & (CHG_ATIME | CHG_CTIME | CHG_MTIME)) {
        fatfs_chtime(dp, attr);
        ftime = ld_dword(dp->dir + DIR_ModTime);
        finfo->fdate = (WORD)(ftime >> FTIME_DATE_OFFSET);
        finfo->ftime = (WORD)ftime;
    }
 
    result = sync_window(fs);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
 
    unlock_fs(fs, FR_OK);
    return fatfs_sync(vp->originMount->mountFlags, fs);
ERROR_UNLOCK:
    unlock_fs(fs, result);
ERROR_OUT:
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_closedir()

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

在文件 fatfs.c 第 1662 行定义.

{
    DIR *dp = (DIR *)dir->u.fs_dir;
    free(dp);
    dir->u.fs_dir = NULL;
    return 0;
}

函数调用图:

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

fatfs_create()

int fatfs_create	(	struct Vnode *	parent,
		const char *	name,
		int	mode,
		struct Vnode **	vpp
	)

创建 fat vnode 节点

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

{
    return fatfs_create_obj(parent, name, mode, vpp, AM_ARC, NULL);
}

函数调用图:

fatfs_fallocate()

int fatfs_fallocate	(	struct file *	filep,
		int	mode,
		off_t	offset,
		off_t	len
	)

在文件 fatfs.c 第 1010 行定义.

{
    return fatfs_fallocate64(filep, mode, offset, len);
}

函数调用图:

fatfs_fallocate64()

int fatfs_fallocate64	(	struct file *	filep,
		int	mode,
		off64_t	offset,
		off64_t	len
	)

在文件 fatfs.c 第 913 行定义.

{
    FIL *fp = (FIL *)filep->f_priv;
    FATFS *fs = fp->obj.fs;
    struct Vnode *vp = filep->f_vnode;
    FILINFO *finfo = &((DIR_FILE *)(vp->data))->fno;
    FRESULT result;
    int ret;
 
    if (offset < 0 || len <= 0) {
        return -EINVAL;
    }
 
    if (len >= FAT32_MAXSIZE || offset >= FAT32_MAXSIZE ||
        len + offset >= FAT32_MAXSIZE) {
        return -EINVAL;
    }
 
    if (mode != FALLOC_FL_KEEP_SIZE) {
        return -EINVAL;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
    result = f_expand(fp, (FSIZE_t)offset, (FSIZE_t)len, 1);
    if (result == FR_OK) {
        if (finfo->sclst == 0) {
            finfo->sclst = fp->obj.sclust;
        }
        result = f_sync(fp);
    }
    unlock_fs(fs, result);
 
    return -fatfs_2_vfs(result);
}

函数调用图:

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

fatfs_fscheck()

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

在文件 fatfs.c 第 2122 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR *dp = NULL;
    FILINFO *finfo = &(((DIR_FILE *)(vp->data))->fno);
#ifdef LOSCFG_FS_FAT_CACHE
    los_part *part = NULL;
#endif
    FRESULT result;
    int ret;
 
    if (fs->fs_type != FS_FAT32) {
        return -EINVAL;
    }
 
    if ((finfo->fattrib & AM_DIR) == 0) {
        return -ENOTDIR;
    }
 
    ret = fatfs_opendir(vp, dir);
    if (ret < 0) {
        return ret;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        result = FR_TIMEOUT;
        goto ERROR_WITH_DIR;
    }
 
    dp = (DIR *)dir->u.fs_dir;
    dp->obj.id = fs->id;
    result = fscheck(dp);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
 
    unlock_fs(fs, FR_OK);
 
    ret = fatfs_closedir(vp, dir);
    if (ret < 0) {
        return ret;
    }
 
#ifdef LOSCFG_FS_FAT_CACHE
    part = get_part((INT)fs->pdrv);
    if (part != NULL) {
        (void)OsSdSync(part->disk_id);
    }
#endif
 
    return 0;
 
ERROR_UNLOCK:
    unlock_fs(fs, result);
ERROR_WITH_DIR:
    fatfs_closedir(vp, dir);
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_fsync()

int fatfs_fsync

(

struct file *

filep

)

在文件 fatfs.c 第 896 行定义.

{
    FIL *fp = filep->f_priv;
    FATFS *fs = fp->obj.fs;
    FRESULT result;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
 
    result = f_sync(fp);
    unlock_fs(fs, result);
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_ioctl()

int fatfs_ioctl	(	struct file *	filep,
		int	req,
		unsigned long	arg
	)

在文件 fatfs.c 第 2049 行定义.

{
    return -ENOSYS;
}

fatfs_lookup()

int fatfs_lookup	(	struct Vnode *	parent,
		const char *	name,
		int	len,
		struct Vnode **	vpp
	)

fat文件系统对 Lookup 接口的实现

在文件 fatfs.c 第 516 行定义.

{
    struct Vnode *vp = NULL;
    FATFS *fs = (FATFS *)(parent->originMount->data);
    DIR_FILE *dfp;
    DIR *dp = NULL;
    FILINFO *finfo = NULL;
    DWORD hash;
    FRESULT result;
    int ret;
 
    dfp = (DIR_FILE *)zalloc(sizeof(DIR_FILE));
    if (dfp == NULL) {
        ret = ENOMEM;
        goto ERROR_EXIT;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        ret = EBUSY;
        goto ERROR_FREE;
    }
    finfo = &(dfp->fno);
    LOS_ListInit(&finfo->fp_list);
    dp = &(dfp->f_dir);
    dp->obj.fs = fs;
    dp->obj.sclust = ((DIR_FILE *)(parent->data))->fno.sclst;
 
    DEF_NAMBUF;
    INIT_NAMBUF(fs);
    result = create_name(dp, &path);
    if (result != FR_OK) {
        ret = fatfs_2_vfs(result);
        goto ERROR_UNLOCK;
    }
 
    result = dir_find(dp);
    if (result != FR_OK) {
        ret = fatfs_2_vfs(result);
        goto ERROR_UNLOCK;
    }
 
    if (dp->fn[NSFLAG] & NS_NONAME) {
        result = FR_INVALID_NAME;
        ret = fatfs_2_vfs(result);
        goto ERROR_UNLOCK;
    }
 
    get_fileinfo(dp, finfo);
    dp->obj.objsize = 0;
 
    hash = fatfs_hash(dp->sect, dp->dptr, finfo->sclst);
    ret = VfsHashGet(parent->originMount, hash, &vp, fatfs_hash_cmp, dfp);
    if (ret != 0) {
        ret = VnodeAlloc(&fatfs_vops, &vp);
        if (ret != 0) {
            ret = ENOMEM;
            result = FR_NOT_ENOUGH_CORE;
            goto ERROR_UNLOCK;
        }
        vp->parent = parent;
        vp->fop = &fatfs_fops;
        vp->data = dfp;
        vp->originMount = parent->originMount;
        vp->uid = fs->fs_uid;
        vp->gid = fs->fs_gid;
        vp->mode = fatfs_get_mode(finfo->fattrib, fs->fs_mode);
        if (finfo->fattrib & AM_DIR) {
            vp->type = VNODE_TYPE_DIR;
            finfo->fsize = fs->csize * SS(fs);
        } else {
            vp->type = VNODE_TYPE_REG;
        }
 
        ret = VfsHashInsert(vp, hash);
        if (ret != 0) {
            result = FR_INVALID_PARAMETER;
            goto ERROR_UNLOCK;
        }
    } else {
        vp->parent = parent;
        free(dfp); /* hash hit dfp is no needed */
    }
 
    unlock_fs(fs, FR_OK);
    FREE_NAMBUF();
    *vpp = vp;
    return 0;
 
ERROR_UNLOCK:
    unlock_fs(fs, result);
    FREE_NAMBUF();
ERROR_FREE:
    free(dfp);
ERROR_EXIT:
    return -ret;
}

函数调用图:

fatfs_lseek()

off64_t fatfs_lseek	(	struct file *	filep,
		off_t	offset,
		int	whence
	)

在文件 fatfs.c 第 832 行定义.

{
    return (off_t)fatfs_lseek64(filep, offset, whence);
}

函数调用图:

fatfs_lseek64()

off_t fatfs_lseek64	(	struct file *	filep,
		off64_t	offset,
		int	whence
	)

在文件 fatfs.c 第 753 行定义.

{
    FIL *fp = (FIL *)filep->f_priv;
    FATFS *fs = fp->obj.fs;
    struct Vnode *vp = filep->f_vnode;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    FILINFO *finfo = &(dfp->fno);
    struct Mount *mount = vp->originMount;
    FSIZE_t fpos;
    FRESULT result;
    int ret;
 
    switch (whence) {
        case SEEK_CUR:
            offset = filep->f_pos + offset;
            if (offset < 0) {
                return -EINVAL;
            }
            fpos = offset;
            break;
        case SEEK_SET:
            if (offset < 0) {
                return -EINVAL;
            }
            fpos = offset;
            break;
        case SEEK_END:
            offset = (off_t)((long long)finfo->fsize + offset);
            if (offset < 0) {
                return -EINVAL;
            }
            fpos = offset;
            break;
        default:
            return -EINVAL;
    }
 
    if (offset >= FAT32_MAXSIZE) {
        return -EINVAL;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
 
    if (fpos > finfo->fsize) {
        if ((filep->f_oflags & O_ACCMODE) == O_RDONLY) {
            result = FR_DENIED;
            goto ERROR_EXIT;
        }
        if (mount->mountFlags & MS_RDONLY) {
            result = FR_WRITE_PROTECTED;
            goto ERROR_EXIT;
        }
    }
    fp->obj.sclust = finfo->sclst;
    fp->obj.objsize = finfo->fsize;
 
    result = f_lseek(fp, fpos);
    finfo->fsize = fp->obj.objsize;
    finfo->sclst = fp->obj.sclust;
    if (result != FR_OK) {
        goto ERROR_EXIT;
    }
 
    result = f_sync(fp);
    if (result != FR_OK) {
        goto ERROR_EXIT;
    }
    filep->f_pos = fpos;
 
    unlock_fs(fs, FR_OK);
    return fpos;
ERROR_EXIT:
    unlock_fs(fs, result);
    return -fatfs_2_vfs(result);
}

函数调用图:

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

fatfs_mkdir()

int fatfs_mkdir	(	struct Vnode *	parent,
		const char *	name,
		mode_t	mode,
		struct Vnode **	vpp
	)

在文件 fatfs.c 第 1941 行定义.

{
    return fatfs_create_obj(parent, name, mode, vpp, AM_DIR, NULL);
}

函数调用图:

fatfs_mkfs()

int fatfs_mkfs	(	struct Vnode *	device,
		int	sectors,
		int	option
	)

在文件 fatfs.c 第 1885 行定义.

{
    BYTE *work_buff = NULL;
    los_part *part = NULL;
    FRESULT result;
    MKFS_PARM opt = {0};
    int ret;
 
    part = los_part_find(device);
    if (part == NULL || device->data == NULL) {
        return -ENODEV;
    }
 
    if (sectors < 0 || sectors > FAT32_MAX_CLUSTER_SIZE || ((DWORD)sectors & ((DWORD)sectors - 1))) {
        return -EINVAL;
    }
 
    if (option != FMT_FAT && option != FMT_FAT32 && option != FMT_ANY && option != FMT_ERASE) {
        return -EINVAL;
    }
 
    if (part->part_name != NULL) { /* The part is mounted */
        return -EBUSY;
    }
    option = fatfs_erase(part, option);
    work_buff = (BYTE *)zalloc(FF_MAX_SS);
    if (work_buff == NULL) {
        return -ENOMEM;
    }
 
    opt.n_sect = sectors;
    opt.fmt = (BYTE)option;
    result = _mkfs(part, &opt, work_buff, FF_MAX_SS);
    free(work_buff);
    if (result != FR_OK) {
        return -fatfs_2_vfs(result);
    }
 
    result = fatfs_setlabel(part);
    if (result == FR_OK) {
#ifdef LOSCFG_FS_FAT_CACHE
        ret = OsSdSync(part->disk_id);
        if (ret != 0) {
            return -EIO;
        }
#endif
    }
 
    ret = fatfs_set_part_info(part);
    if (ret != 0) {
        return -EIO;
    }
 
    return -fatfs_2_vfs(result);
}

函数调用图:

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

fatfs_mount()

int fatfs_mount	(	struct Mount *	mount,
		struct Vnode *	device,
		const void *	data
	)

fat将分区文件系统挂载 举例: mount /dev/mmcblk0p0 /bin1/vs/sd vfat

在文件 fatfs.c 第 1103 行定义.

{
    struct Vnode *vp = NULL;
    FATFS *fs = NULL;
    DIR_FILE *dfp = NULL;
    los_part *part = NULL;
    QWORD start_sector;
    BYTE fmt;
    DWORD hash;
    FRESULT result;
    int ret;
 
    ret = fat_bind_check(blk_device, &part);//通过节点获取分区信息
    if (ret != 0) {
        goto ERROR_EXIT;
    }
 
    ret = SetDiskPartName(part, "vfat");
    if (ret != 0) {
        ret = EIO;
        goto ERROR_EXIT;
    }
 
    fs = (FATFS *)zalloc(sizeof(FATFS));
    if (fs == NULL) {
        ret = ENOMEM;
        goto ERROR_PARTNAME;
    }
 
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
    fs->vir_flag = FS_PARENT;
    fs->parent_fs = fs;
    fs->vir_amount = DISK_ERROR;
    fs->vir_avail = FS_VIRDISABLE;
#endif
 
    ret = ff_cre_syncobj(0, &fs->sobj);
    if (ret == 0) { /* create sync object failed */
        ret = EINVAL;
        goto ERROR_WITH_FS;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        ret = EBUSY;
        goto ERROR_WITH_MUX;
    }
 
    fs->fs_type = 0;
    fs->pdrv = part->part_id;
 
#if FF_MAX_SS != FF_MIN_SS  /* Get sector size (multiple sector size cfg only) */
    if (disk_ioctl(fs->pdrv, GET_SECTOR_SIZE, &(fs->ssize)) != RES_OK) {
        ret = EIO;
        goto ERROR_WITH_LOCK;
    }
    if (fs->ssize > FF_MAX_SS || fs->ssize < FF_MIN_SS || (fs->ssize & (fs->ssize - 1))) {
        ret = EIO;
        goto ERROR_WITH_LOCK;
    }
#endif
 
    fs->win = (BYTE *)ff_memalloc(SS(fs));
    if (fs->win == NULL) {
        ret = ENOMEM;
        goto ERROR_WITH_LOCK;
    }
 
    result = find_fat_partition(fs, part, &fmt, &start_sector);
    if (result != FR_OK) {
        ret = fatfs_2_vfs(result);
        goto ERROR_WITH_FSWIN;
    }
 
    result = init_fatobj(fs, fmt, start_sector);
    if (result != FR_OK) {
        ret = fatfs_2_vfs(result);
        goto ERROR_WITH_FSWIN;
    }
 
    fs->fs_uid = mnt->vnodeBeCovered->uid;
    fs->fs_gid = mnt->vnodeBeCovered->gid;
    fs->fs_dmask = GetUmask();
    fs->fs_fmask = GetUmask();
    fs->fs_mode = mnt->vnodeBeCovered->mode & (S_IRWXU | S_IRWXG | S_IRWXO);
 
    dfp = (DIR_FILE *)zalloc(sizeof(DIR_FILE));
    if (dfp == NULL) {
        ret = ENOMEM;
        goto ERROR_WITH_FSWIN;
    }
 
    dfp->f_dir.obj.fs = fs;
    dfp->f_dir.obj.sclust = 0; /* set start clust 0, root */
    dfp->f_dir.obj.attr = AM_DIR;
    dfp->f_dir.obj.objsize = 0; /* dir size is 0 */
    dfp->fno.fsize = 0;
    dfp->fno.fdate = 0;
    dfp->fno.ftime = 0;
    dfp->fno.fattrib = AM_DIR;
    dfp->fno.sclst = 0;
    dfp->fno.fsize = fs->csize * SS(fs);
    dfp->fno.fname[0] = '/'; /* Mark as root dir */
    dfp->fno.fname[1] = '\0';
    LOS_ListInit(&(dfp->fno.fp_list));
 
    ret = VnodeAlloc(&fatfs_vops, &vp);
    if (ret != 0) {
        ret = ENOMEM;
        goto ERROR_WITH_FSWIN;
    }
 
    mnt->data = fs;
    mnt->vnodeCovered = vp;
 
    vp->parent = mnt->vnodeBeCovered;
    vp->fop = &fatfs_fops;
    vp->data = dfp;
    vp->originMount = mnt;
    vp->uid = fs->fs_uid;
    vp->gid = fs->fs_gid;
    vp->mode = mnt->vnodeBeCovered->mode;
    vp->type = VNODE_TYPE_DIR;
 
    hash = fatfs_hash(0, 0, 0);
    ret = VfsHashInsert(vp, hash);
    if (ret != 0) {
        ret = -ret;
        goto ERROR_WITH_LOCK;
    }
    unlock_fs(fs, FR_OK);
 
    return 0;
 
ERROR_WITH_FSWIN:
    ff_memfree(fs->win);
ERROR_WITH_LOCK:
    unlock_fs(fs, FR_OK);
ERROR_WITH_MUX:
    ff_del_syncobj(&fs->sobj);
ERROR_WITH_FS:
    free(fs);
ERROR_PARTNAME:
    if (part->part_name) {
        free(part->part_name);
        part->part_name = NULL;
    }
ERROR_EXIT:
    return -ret;
}

函数调用图:

fatfs_opendir()

int fatfs_opendir	(	struct Vnode *	vnode,
		struct fs_dirent_s *	idir
	)

在文件 fatfs.c 第 1554 行定义.

{
    FATFS *fs = vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    FILINFO *finfo = &(dfp->fno);
    DIR *dp;
    DWORD clst;
    FRESULT result;
    int ret;
 
    dp = (DIR*)zalloc(sizeof(DIR));
    if (dp == NULL) {
        return -ENOMEM;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
    clst = finfo->sclst;
    dp->obj.fs = fs;
    dp->obj.sclust = clst;
 
    result = dir_sdi(dp, 0);
    if (result != FR_OK) {
        free(dp);
        unlock_fs(fs, result);
        return -fatfs_2_vfs(result);
    }
    unlock_fs(fs, result);
    idir->u.fs_dir = dp;
 
    return 0;
}

函数调用图:

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

fatfs_read()

int fatfs_read	(	struct file *	filep,
		char *	buff,
		size_t	count
	)

在文件 fatfs.c 第 697 行定义.

{
    FIL *fp = (FIL *)filep->f_priv;
    FATFS *fs = fp->obj.fs;
    struct Vnode *vp = filep->f_vnode;
    FILINFO *finfo = &((DIR_FILE *)(vp->data))->fno;
    size_t rcount;
    FRESULT result;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
    fp->obj.objsize = finfo->fsize;
    fp->obj.sclust = finfo->sclst;
    result = f_read(fp, buff, count, &rcount);
    if (result != FR_OK) {
        goto EXIT;
    }
    filep->f_pos = fp->fptr;
EXIT:
    unlock_fs(fs, result);
    return rcount;
}

fatfs_readdir()

int fatfs_readdir	(	struct Vnode *	vnode,
		struct fs_dirent_s *	idir
	)

在文件 fatfs.c 第 1589 行定义.

{
    FATFS *fs = vp->originMount->data;
    FILINFO fno;
    DIR* dp = (DIR*)idir->u.fs_dir;
    struct dirent *dirp = NULL;
    FRESULT result;
    int ret, i;
 
    ret = lock_fs(fs);
    if (ret == FALSE) { /* Lock fs failed */
        return -EBUSY;
    }
    DEF_NAMBUF;
    INIT_NAMBUF(fs);
    for (i = 0; i < idir->read_cnt; i++) {
        /* using dir_read_massive to promote performance */
        result = dir_read_massive(dp, 0);
        if (result == FR_NO_FILE) {
            break;
        } else if (result != FR_OK) {
            goto ERROR_UNLOCK;
        }
        get_fileinfo(dp, &fno);
        /* 0x00 for end of directory and 0xFF for directory is empty */
        if (fno.fname[0] == 0x00 || fno.fname[0] == (TCHAR)0xFF) {
            break;
        }
 
        dirp = &(idir->fd_dir[i]);
        if (fno.fattrib & AM_DIR) { /* is dir */
            dirp->d_type = DT_DIR;
        } else {
            dirp->d_type = DT_REG;
        }
        if (strncpy_s(dirp->d_name, sizeof(dirp->d_name), fno.fname, strlen(fno.fname)) != EOK) {
            result = FR_NOT_ENOUGH_CORE;
            goto ERROR_UNLOCK;
        }
        result = dir_next(dp, 0);
        if (result != FR_OK && result != FR_NO_FILE) {
            goto ERROR_UNLOCK;
        }
        idir->fd_position++;
        idir->fd_dir[i].d_off = idir->fd_position;
        idir->fd_dir[i].d_reclen = (uint16_t)sizeof(struct dirent);
    }
    unlock_fs(fs, FR_OK);
    FREE_NAMBUF();
    return i;
ERROR_UNLOCK:
    unlock_fs(fs, result);
    FREE_NAMBUF();
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_rename()

int fatfs_rename	(	struct Vnode *	oldvnode,
		struct Vnode *	newparent,
		const char *	oldname,
		const char *	newname
	)

在文件 fatfs.c 第 1698 行定义.

{
    FATFS *fs = (FATFS *)(old_vnode->originMount->data);
    DIR_FILE *dfp_old = (DIR_FILE *)old_vnode->data;
    DIR *dp_old = &(dfp_old->f_dir);
    FILINFO *finfo_old = &(dfp_old->fno);
    DIR_FILE *dfp_new = NULL;
    DIR* dp_new = NULL;
    FILINFO* finfo_new = NULL;
    DWORD clust;
    FRESULT result;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) { /* Lock fs failed */
        return -EBUSY;
    }
 
    dfp_new = (DIR_FILE *)zalloc(sizeof(DIR_FILE));
    if (dfp_new == NULL) {
        result = FR_NOT_ENOUGH_CORE;
        goto ERROR_UNLOCK;
    }
    dp_new = &(dfp_new->f_dir);
    finfo_new = &(dfp_new->fno);
 
    dp_new->obj.sclust = ((DIR_FILE *)(new_parent->data))->fno.sclst;
    dp_new->obj.fs = fs;
 
    /* Find new path */
    DEF_NAMBUF;
    INIT_NAMBUF(fs);
    result = create_name(dp_new, &newname);
    if (result != FR_OK) {
        goto ERROR_FREE;
    }
    result = dir_find(dp_new);
    if (result == FR_OK) { /* new path name exist */
        get_fileinfo(dp_new, finfo_new);
        result = rename_check(dp_new, finfo_new, dp_old, finfo_old);
        if (result != FR_OK) {
            goto ERROR_FREE;
        }
        result = dir_remove(dp_old);
        if (result != FR_OK) {
            goto ERROR_FREE;
        }
        clust = finfo_new->sclst;
        if (clust != 0) { /* remove the new path cluster chain if exists */
            result = remove_chain(&(dp_new->obj), clust, 0);
            if (result != FR_OK) {
                goto ERROR_FREE;
            }
        }
    } else { /* new path name not exist */
        result = dir_remove(dp_old);
        if (result != FR_OK) {
            goto ERROR_FREE;
        }
        result = dir_register(dp_new);
        if (result != FR_OK) {
            goto ERROR_FREE;
        }
    }
 
    /* update new dir entry with old info */
    result = update_dir(dp_new, finfo_old);
    if (result != FR_OK) {
        goto ERROR_FREE;
    }
    result = dir_read(dp_new, 0);
    if (result != FR_OK) {
        goto ERROR_FREE;
    }
    dp_new->blk_ofs = dir_ofs(dp_new);
    get_fileinfo(dp_new, finfo_new);
 
    dfp_new->fno.fp_list.pstNext = dfp_old->fno.fp_list.pstNext;
    dfp_new->fno.fp_list.pstPrev = dfp_old->fno.fp_list.pstPrev;
    ret = memcpy_s(dfp_old, sizeof(DIR_FILE), dfp_new, sizeof(DIR_FILE));
    if (ret != 0) {
        result = FR_NOT_ENOUGH_CORE;
        goto ERROR_FREE;
    }
    free(dfp_new);
    unlock_fs(fs, FR_OK);
    FREE_NAMBUF();
    return fatfs_sync(old_vnode->originMount->mountFlags, fs);
 
ERROR_FREE:
    free(dfp_new);
ERROR_UNLOCK:
    unlock_fs(fs, result);
    FREE_NAMBUF();
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_rewinddir()

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

在文件 fatfs.c 第 1645 行定义.

{
    DIR *dp = (DIR *)dir->u.fs_dir;
    FATFS *fs = dp->obj.fs;
    FRESULT result;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
 
    result = dir_sdi(dp, 0);
    unlock_fs(fs, result);
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_rmdir()

int fatfs_rmdir	(	struct Vnode *	parent,
		struct Vnode *	vp,
		const char *	name
	)

在文件 fatfs.c 第 1946 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    FILINFO *finfo = &(dfp->fno);
    DIR *dp = &(dfp->f_dir);
    DIR dir_sub;
    FRESULT result = FR_OK;
    int ret;
 
    if (finfo->fattrib & AM_ARC) {
        result = FR_NO_DIR;
        goto ERROR_OUT;
    }
 
    DEF_NAMBUF;
    INIT_NAMBUF(fs);
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        result = FR_TIMEOUT;
        goto ERROR_OUT;
    }
    dir_sub.obj.fs = fs;
    dir_sub.obj.sclust = finfo->sclst;
    result = dir_sdi(&dir_sub, 0);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    result = dir_read(&dir_sub, 0);
    if (result == FR_OK) {
        result = FR_NO_EMPTY_DIR;
        goto ERROR_UNLOCK;
    }
    result = dir_remove(dp); /* remove directory entry */
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    /* Directory entry contains at least one cluster */
    result = remove_chain(&(dp->obj), finfo->sclst, 0);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
 
    unlock_fs(fs, FR_OK);
    FREE_NAMBUF();
    return fatfs_sync(vp->originMount->mountFlags, fs);
 
ERROR_UNLOCK:
    unlock_fs(fs, result);
    FREE_NAMBUF();
ERROR_OUT:
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_stat()

int fatfs_stat	(	struct Vnode *	vnode,
		struct stat *	buff
	)

在文件 fatfs.c 第 1439 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    FILINFO *finfo = &(dfp->fno);
    time_t time;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return EBUSY;
    }
 
    sp->st_dev = fs->pdrv;
    sp->st_mode = vp->mode;
    sp->st_nlink = 1;
    sp->st_uid = fs->fs_uid;
    sp->st_gid = fs->fs_gid;
    sp->st_size = finfo->fsize;
    sp->st_blksize = fs->csize * SS(fs);
    if (finfo->fattrib & AM_ARC) {
        sp->st_blocks = finfo->fsize ? ((finfo->fsize - 1) / SS(fs) / fs->csize + 1) : 0;
    } else {
        sp->st_blocks = fs->csize;
    }
    time = fattime_transfer(finfo->fdate, finfo->ftime);
    sp->st_mtime = time;
 
    /* Adapt to kstat member "long tv_sec" */
    sp->__st_mtim32.tv_sec = (long)time;
 
    unlock_fs(fs, FR_OK);
    return 0;
}

函数调用图:

fatfs_statfs()

int fatfs_statfs	(	struct Mount *	mount,
		struct statfs *	info
	)

在文件 fatfs.c 第 1339 行定义.

{
    FATFS *fs = (FATFS *)mnt->data;
    DWORD nclst = 0;
    FRESULT result = FR_OK;
    int ret;
 
    info->f_type = MSDOS_SUPER_MAGIC;
#if FF_MAX_SS != FF_MIN_SS
    info->f_bsize = fs->ssize * fs->csize;
#else
    info->f_bsize = FF_MIN_SS * fs->csize;
#endif
    info->f_blocks = fs->n_fatent;
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
    /* free cluster is unavailable, update it */
    if (fs->free_clst == DISK_ERROR) {
        result = fat_count_free_entries(&nclst, fs);
    }
    info->f_bfree = fs->free_clst;
    info->f_bavail = fs->free_clst;
    unlock_fs(fs, result);
 
#if FF_USE_LFN
    /* Maximum length of filenames */
    info->f_namelen = FF_MAX_LFN;
#else
    /* Maximum length of filenames: 8 is the basename length, 1 is the dot, 3 is the extension length */
    info->f_namelen = (8 + 1 + 3);
#endif
    info->f_fsid.__val[0] = MSDOS_SUPER_MAGIC;
    info->f_fsid.__val[1] = 1;
    info->f_frsize = SS(fs) * fs->csize;
    info->f_files = 0;
    info->f_ffree = 0;
    info->f_flags = mnt->mountFlags;
 
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_truncate()

int fatfs_truncate	(	struct Vnode *	vnode,
		off_t	len
	)

在文件 fatfs.c 第 1058 行定义.

{
    return fatfs_truncate64(vp, len);
}

函数调用图:

fatfs_truncate64()

int fatfs_truncate64	(	struct Vnode *	vnode,
		off64_t	len
	)

在文件 fatfs.c 第 1015 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    DIR *dp = &(dfp->f_dir);
    FILINFO *finfo = &(dfp->fno);
    FFOBJID object;
    FRESULT result = FR_OK;
    int ret;
 
    if (len < 0 || len >= FAT32_MAXSIZE) {
        return -EINVAL;
    }
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        result = FR_TIMEOUT;
        goto ERROR_OUT;
    }
    if (len == finfo->fsize) {
        unlock_fs(fs, FR_OK);
        return 0;
    }
 
    object.fs = fs;
    result = realloc_cluster(finfo, &object, (FSIZE_t)len);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    finfo->fsize = (FSIZE_t)len;
 
    result = update_dir(dp, finfo);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    unlock_fs(fs, FR_OK);
    return fatfs_sync(vp->originMount->mountFlags, fs);
ERROR_UNLOCK:
    unlock_fs(fs, result);
ERROR_OUT:
    return -fatfs_2_vfs(result);
}

函数调用图:

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

fatfs_umount()

int fatfs_umount	(	struct Mount *	mount,
		struct Vnode **	device
	)

在文件 fatfs.c 第 1254 行定义.

{
    struct Vnode *device;
    FATFS *fs = (FATFS *)mnt->data;
    los_part *part;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
 
    part = get_part(fs->pdrv);
    if (part == NULL) {
        unlock_fs(fs, FR_OK);
        return -ENODEV;
    }
    device = part->dev;
    if (device == NULL) {
        unlock_fs(fs, FR_OK);
        return -ENODEV;
    }
#ifdef LOSCFG_FS_FAT_CACHE
    ret = OsSdSync(part->disk_id);
    if (ret != 0) {
        unlock_fs(fs, FR_DISK_ERR);
        return -EIO;
    }
#endif
    if (part->part_name != NULL) {
        free(part->part_name);
        part->part_name = NULL;
    }
 
    struct drv_data *dd = device->data;
    if (dd->ops == NULL) {
        unlock_fs(fs, FR_OK);
        return ENODEV;
    }
 
    const struct block_operations *bops = dd->ops;
    if (bops != NULL && bops->close != NULL) {
        bops->close(*blkdriver);
    }
 
    if (fs->win != NULL) {
        ff_memfree(fs->win);
    }
 
    unlock_fs(fs, FR_OK);
 
    ret = ff_del_syncobj(&fs->sobj);
    if (ret == FALSE) {
        return -EINVAL;
    }
    free(fs);
 
    *blkdriver = device;
 
    return 0;
}

函数调用图:

fatfs_unlink()

int fatfs_unlink	(	struct Vnode *	parent,
		struct Vnode *	vp,
		const char *	name
	)

在文件 fatfs.c 第 2008 行定义.

{
    FATFS *fs = (FATFS *)vp->originMount->data;
    DIR_FILE *dfp = (DIR_FILE *)vp->data;
    FILINFO *finfo = &(dfp->fno);
    DIR *dp = &(dfp->f_dir);
    FRESULT result = FR_OK;
    int ret;
 
    if (finfo->fattrib & AM_DIR) {
        result = FR_IS_DIR;
        goto ERROR_OUT;
    }
    ret = lock_fs(fs);
    if (ret == FALSE) {
        result = FR_TIMEOUT;
        goto ERROR_OUT;
    }
    result = dir_remove(dp); /* remove directory entry */
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    if (finfo->sclst != 0) { /* if cluster chain exists */
        result = remove_chain(&(dp->obj), finfo->sclst, 0);
        if (result != FR_OK) {
            goto ERROR_UNLOCK;
        }
    }
    result = sync_fs(fs);
    if (result != FR_OK) {
        goto ERROR_UNLOCK;
    }
    unlock_fs(fs, FR_OK);
    return fatfs_sync(vp->originMount->mountFlags, fs);
 
ERROR_UNLOCK:
    unlock_fs(fs, result);
ERROR_OUT:
    return -fatfs_2_vfs(result);
}

函数调用图:

fatfs_write()

int fatfs_write	(	struct file *	filep,
		const char *	buff,
		size_t	count
	)

在文件 fatfs.c 第 858 行定义.

{
    FIL *fp = (FIL *)filep->f_priv;
    FATFS *fs = fp->obj.fs;
    struct Vnode *vp = filep->f_vnode;
    FILINFO *finfo = &(((DIR_FILE *)vp->data)->fno);
    size_t wcount;
    FRESULT result;
    int ret;
 
    ret = lock_fs(fs);
    if (ret == FALSE) {
        return -EBUSY;
    }
    fp->obj.objsize = finfo->fsize;
    fp->obj.sclust = finfo->sclst;
    result = f_write(fp, buff, count, &wcount);
    if (result != FR_OK) {
        goto ERROR_EXIT;
    }
 
    finfo->fsize = fp->obj.objsize;
    finfo->sclst = fp->obj.sclust;
    result = f_sync(fp);
    if (result != FR_OK) {
        goto ERROR_EXIT;
    }
    update_filbuff(finfo, fp, buff);
 
    filep->f_pos = fp->fptr;
 
    unlock_fs(fs, FR_OK);
    return wcount;
ERROR_EXIT:
    unlock_fs(fs, result);
    return -fatfs_2_vfs(result);
}

函数调用图:

find_fat_partition()

FRESULT find_fat_partition	(	FATFS *	fs,
		los_part *	part,
		BYTE *	format,
		QWORD *	start_sector
	)

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

init_fatobj()

FRESULT init_fatobj	(	FATFS *	fs,
		BYTE	fmt,
		QWORD	start_sector
	)

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

变量说明

FatLabel

char FatLabel[LABEL_LEN]

extern

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