p71924506
/
kernel_liteos_a
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
kernel_liteos_a/fs/fat/os_adapt/fatfs.c

2420 lines
59 KiB
C
Raw Normal View History

add OpenHarmony 1.0 baseline
2020-09-08 10:21:39 +08:00
/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "fatfs.h"
#ifdef LOSCFG_FS_FAT
#include <string.h>
#include <sys/mount.h>
#include "errno.h"
#include "ff.h"
#include "dirop_fat.h"
#include "disk_pri.h"
#include "los_tables.h"
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#include "virpart.h"
#include "errcode_fat.h"
#include "virpartff.h"
#endif
#ifdef LOSCFG_FS_FAT_CACHE
#include "bcache.h"
#endif
#include "los_config.h"
#include "los_vm_filemap.h"
#include "los_process_pri.h"
#include "capability_type.h"
#include "capability_api.h"
#include "fs_other.h"
#include "los_strncpy_from_user.h"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
FAT_VIR_PART g_fatVirPart = {0};
static pthread_mutex_t fatfsVirtMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static void FatfsVirtLock(void)
{
(void)pthread_mutex_lock(&fatfsVirtMutex);
}
static void FatfsVirtUnlock(void)
{
(void)pthread_mutex_unlock(&fatfsVirtMutex);
}
#endif
PARTITION VolToPart[FF_VOLUMES];
static struct inode *DiskDev[FF_VOLUMES];
char FatLabel[LABEL_LEN];
#define DRIVER_NAME_LEN 8
/* Returns -1 if there is no space to install fatfs driver, else returns >=0 */
static INT FatGetDisk(struct inode *node)
{
INT index;
for (index = 0; index < FF_VOLUMES; index++) {
if (DiskDev[index] == node) {
return index;
}
}
return FAT_ERROR;
}
static INT FatfsSdSync(unsigned long mountflags, FATFS *fat)
{
#ifdef LOSCFG_FS_FAT_CACHE
los_part *part = NULL;
if (mountflags != MS_NOSYNC) {
part = get_part((INT)fat->pdrv);
if (part == NULL) {
return -ENODEV;
}
(void)OsSdSync(part->disk_id);
}
#endif
return ENOERR;
}
INT fatfs_2_vfs(INT result)
{
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:
case FR_NO_FILESYSTEM:
status = -ENOENT;
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:
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;
}
static int FatfsBindCheck(struct inode *blkdriver, los_part **partition)
{
los_part *part = NULL;
if (blkdriver == NULL || blkdriver->u.i_bops == NULL) {
return -ENODEV;
}
if (blkdriver->u.i_bops->open != NULL && blkdriver->u.i_bops->open(blkdriver) != 0) {
return -ENODEV;
}
part = los_part_find(blkdriver);
if (part == NULL) {
return -ENODEV;
}
if (part->part_name != NULL) {
return -EACCES;
}
#ifndef FF_MULTI_PARTITION
if (part->part_no_mbr > 1) {
return -EPERM;
}
#endif
*partition = part;
return ENOERR;
}
struct FatfsMountOpts {
uid_t FsUid;
gid_t FsGid;
unsigned short FsDmask;
unsigned short FsFmask;
};
struct MatchOption {
int opt;
const char *pattern;
};
typedef struct MatchOption MatchTable[];
enum {
OptionUid,
OptionGid,
OptionUmask,
OptionDmask,
OptionFmask,
OptionErr,
};
static const MatchTable FatFsTokens = {
{OptionUid, "uid=%u"},
{OptionGid, "gid=%u"},
{OptionUmask, "umask=%o"},
{OptionDmask, "dmask=%o"},
{OptionFmask, "fmask=%o"},
{OptionErr, NULL},
};
static int MatchOption(char *s, const MatchTable table, char **args)
{
struct MatchOption opt = {0};
const char *p = NULL;
char *meta = NULL;
for (unsigned int i = 0; i < (sizeof(FatFsTokens) / sizeof(struct MatchOption)); i++) {
opt = table[i];
p = opt.pattern;
if (p == NULL) {
continue;
}
meta = strchr(table[i].pattern, '%');
if ((meta == NULL) || (strncmp(p, s, meta - p) != 0)) {
continue;
}
*args = s + (meta - p);
break;
}
return opt.opt;
}
static void FatParseOptions(char *data, struct FatfsMountOpts *opts)
{
char *args = NULL;
int opt;
char *p = NULL;
if ((data == NULL) || (opts == NULL)) {
return;
}
opts->FsUid = OsCurrUserGet()->effUserID;
opts->FsGid = OsCurrUserGet()->effGid;
opts->FsDmask = GetUmask();
opts->FsFmask = GetUmask();
while ((p = strsep((char**)&data, ",")) != NULL) {
if (!*p)
continue;
opt = MatchOption(p, FatFsTokens, &args);
if (args == NULL) {
continue;
}
switch (opt) {
case OptionUid:
opts->FsUid = strtoul(args, NULL, 0);
break;
case OptionGid:
opts->FsGid = strtoul(args, NULL, 0);
break;
case OptionUmask:
opts->FsDmask = opts->FsFmask = strtoul(args, NULL, 8); /* 8: octal formats */
break;
case OptionDmask:
opts->FsDmask = strtoul(args, NULL, 8); /* 8: octal formats */
break;
case OptionFmask:
opts->FsFmask = strtoul(args, NULL, 8); /* 8: octal formats */
break;
default:
PRINTK("Not Match\n");
break;
}
}
return;
}
int fatfs_bind(struct inode *blkdriver, const void *data, void **handle, const char *relpath)
{
FATFS *fat = NULL;
INT result;
BYTE index;
INT err;
los_part *part = NULL;
char drive[DRIVER_NAME_LEN];
struct FatfsMountOpts opts = {0};
struct inode_search_s desc;
FAR struct inode *inode;
FatParseOptions((char *)data, &opts);
result = FatfsBindCheck(blkdriver, &part);
if (result != 0)
return result;
err = SetDiskPartName(part, relpath);
if (err != 0)
return -ENOMEM;
index = (BYTE)FatGetDisk((struct inode *)NULL);
if (index >= FF_VOLUMES || (INT8)index < 0) {
err = -EBUSY;
goto ERROUT;
}
VolToPart[index].di = part->disk_id;
VolToPart[index].pd = part->part_id;
VolToPart[index].pt = part->part_no_mbr;
VolToPart[index].ps = part->sector_start;
VolToPart[index].pc = part->sector_count;
fat = (FATFS *)zalloc(sizeof(FATFS));
if (fat == NULL) {
err = -ENOMEM;
goto ERROUT_WITH_DISK;
}
result = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (result < 0) {
err = -EINVAL;
free(fat);
goto ERROUT_WITH_DISK;
}
fat->fs_uid = opts.FsUid;
fat->fs_gid = opts.FsGid;
fat->fs_dmask = opts.FsDmask;
fat->fs_fmask = opts.FsFmask;
/* save blockdriver inode : driver will use in f_mount */
DiskDev[index] = blkdriver;
/* mount fatfs, mmc always 0 logic driver */
result = f_mount(fat, drive, 1);
if (result == FR_OK) {
DIR *dir = NULL;
dir = (DIR *)malloc(sizeof(DIR));
if (dir == NULL) {
err = -ENOMEM;
goto ERROUT_WITH_MOUNT;
}
#if FF_FS_MINIMIZE <= 1
/* open the root directory, returns error if fatfs is invalid */
result = f_opendir(dir, drive);
if (result != FR_OK) {
err = fatfs_2_vfs(result);
free(dir);
goto ERROUT_WITH_MOUNT;
}
result = f_closedir(dir);
if (result != FR_OK) {
err = fatfs_2_vfs(result);
free(dir);
goto ERROUT_WITH_MOUNT;
}
#else
PRINT_ERR("cannot open root directory to check if fatfs is invalid!\n");
#endif
/* mount ok! */
*handle = (void *)fat;
free(dir);
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
/* Parent Partition Mount Success, then process virtual partition mount operation */
if (result == FR_OK) {
if (fat->fs_type != FS_FAT32)
return VIRERR_NOTFIT;
SETUP_SEARCH(&desc, g_fatVirPart.virtualinfo.devpartpath, false);
result = inode_find(&desc);
if (result < 0)
return VIRERR_NOPARAM;
inode = desc.node;
if (blkdriver != inode) {
return VIRERR_NOPARAM;
} else {
FatfsVirtLock();
result = FatFsBindVirPart(fat, index);
FatfsVirtUnlock();
if (result != FR_OK && result < VIRERR_BASE) {
result = VIRERR_INTER_ERR;
}
}
}
#endif
return fatfs_2_vfs(result);
} else {
err = fatfs_2_vfs(result);
}
ERROUT_WITH_MOUNT:
(void)f_mount((FATFS *)NULL, drive, 0);
if (fat->win != NULL)
free(fat->win);
free(fat);
ERROUT_WITH_DISK:
DiskDev[index] = (struct inode *)NULL;
ERROUT:
free(part->part_name);
part->part_name = NULL;
return err;
}
int fatfs_unbind(void *handle, struct inode **blkdriver)
{
BYTE index;
FATFS *fat = NULL;
INT result;
los_part *part = NULL;
char drive[DRIVER_NAME_LEN];
struct inode_search_s desc;
FAR struct inode *inode;
fat = (FATFS *)handle;
if (fat == NULL)
return -EINVAL;
index = (BYTE)fatfs_get_vol(fat);
if (index >= FF_VOLUMES || (INT8)index < 0)
return -EINVAL;
result = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (result < 0)
return -EINVAL;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
/* Release virtual partition objects before unbind real partition */
SETUP_SEARCH(&desc, g_fatVirPart.virtualinfo.devpartpath, false);
FatfsVirtLock();
result = FatFsUnbindVirPart(fat);
FatfsVirtLock();
if (result == FR_OK) {
part = los_part_find(DiskDev[index]);
(void)inode_find(&desc);
inode = desc.node;
if (part == NULL || part->dev == inode) {
(void)memset_s(g_devPartName, sizeof(g_devPartName), 0, sizeof(g_devPartName));
(void)memset_s(&g_fatVirPart.virtualinfo, sizeof(virpartinfo), 0, sizeof(virpartinfo));
g_fatVirPart.isparamset = FALSE;
}
} else {
return fatfs_2_vfs(result);
}
#endif
result = f_mount((FATFS *)NULL, drive, 0);
if (result != FR_OK)
return fatfs_2_vfs(result);
VolToPart[index].di = 0;
VolToPart[index].pd = 0;
VolToPart[index].pt = 0;
VolToPart[index].ps = 0;
VolToPart[index].pc = 0;
part = los_part_find(DiskDev[index]);
if (part != NULL && part->part_name) {
free(part->part_name);
part->part_name = NULL;
}
if (blkdriver != NULL)
*blkdriver = DiskDev[index];
DiskDev[index] = (struct inode *)NULL;
if (fat->win != NULL) {
free(fat->win);
fat->win = NULL;
}
if (fat != NULL) {
free(fat);
fat = NULL;
}
return OK;
}
static BYTE FatFsGetMode(int oflags, int *accMode)
{
BYTE fmode = FA_READ;
*accMode = READ_OP;
if ((UINT)oflags & O_WRONLY) {
fmode |= FA_WRITE;
*accMode |= WRITE_OP;
}
if (((UINT)oflags & O_ACCMODE) & O_RDWR) {
fmode |= FA_WRITE;
*accMode |= WRITE_OP;
}
/* Creates a new file if the file is not existing, otherwise, just open it. */
if ((UINT)oflags & O_CREAT) {
fmode |= FA_OPEN_ALWAYS;
*accMode |= WRITE_OP;
/* Creates a new file. If the file already exists, the function shall fail. */
if ((UINT)oflags & O_EXCL)
fmode |= FA_CREATE_NEW;
}
/* Creates a new file. If the file already exists, its length shall be truncated to 0. */
if ((UINT)oflags & O_TRUNC) {
fmode |= FA_CREATE_ALWAYS;
*accMode |= WRITE_OP;
}
return fmode;
}
#define FAT_USER_SHIFT 6
#define FAT_GROUP_SHIFT 3
#define FAT_NO_PERM 1
#define FAT_PERM 0
static unsigned int FatFsCheckPermission(struct inode *mountpt, bool dirFlag, int accMode)
{
FATFS *fat = NULL;
unsigned short umask;
uint uid = OsCurrUserGet()->effUserID;
uint gid = OsCurrUserGet()->effGid;
mode_t fileMode = mountpt->i_mode;
fat = (FATFS *)mountpt->i_private;
if (fat == NULL) {
umask = GetUmask();
} else if (dirFlag) {
umask = fat->fs_dmask;
} else {
umask = fat->fs_fmask;
}
fileMode &= (~umask);
if (uid == mountpt->i_uid) {
fileMode >>= FAT_USER_SHIFT;
} else if (LOS_CheckInGroups(mountpt->i_gid)) {
fileMode >>= FAT_GROUP_SHIFT;
}
fileMode &= (READ_OP | WRITE_OP | EXEC_OP);
if ((accMode & fileMode) == accMode) {
return FAT_PERM;
}
fileMode = 0;
if (S_ISDIR(mountpt->i_mode)) {
if ((accMode & EXEC_OP) && (IsCapPermit(CAP_DAC_READ_SEARCH))) {
fileMode |= EXEC_OP;
}
} else {
if ((accMode & EXEC_OP) && (IsCapPermit(CAP_DAC_EXECUTE))
&& (mountpt->i_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
fileMode |= EXEC_OP;
}
}
if ((accMode & WRITE_OP) && IsCapPermit(CAP_DAC_WRITE)) {
fileMode |= WRITE_OP;
}
if ((accMode & READ_OP) && IsCapPermit(CAP_DAC_READ_SEARCH)) {
fileMode |= READ_OP;
}
if ((accMode & fileMode) == accMode) {
return FAT_PERM;
}
PRINTK("%s, %d, permission check fail,uid %d, gid %d, mode %d%d%d, accMode %d, cuid %d, cgid %d\n",
__FUNCTION__, __LINE__, mountpt->i_uid, mountpt->i_gid,
(mountpt->i_mode >> FAT_USER_SHIFT) & (READ_OP | WRITE_OP | EXEC_OP),
(mountpt->i_mode >> FAT_GROUP_SHIFT) & (READ_OP | WRITE_OP | EXEC_OP),
(mountpt->i_mode) & (READ_OP | WRITE_OP | EXEC_OP), accMode, uid, gid);
return FAT_NO_PERM;
}
static bool oflag_convert_and_check(FAR struct file *filep, int oflags)
{
unsigned int acc_mode = 0;
if (((unsigned int)oflags & O_ACCMODE) == O_RDONLY)
acc_mode |= READ_OP;
if ((unsigned int)oflags & O_WRONLY)
acc_mode |= WRITE_OP;
if ((unsigned int)oflags & O_RDWR)
acc_mode |= READ_OP | WRITE_OP;
if ((unsigned int)oflags & O_CREAT)
acc_mode |= WRITE_OP;
if ((unsigned int)oflags & O_TRUNC)
acc_mode |= WRITE_OP;
if ((unsigned int)oflags & O_EXCL)
acc_mode |= WRITE_OP;
if ((unsigned int)oflags & O_APPEND)
acc_mode |= WRITE_OP;
if ((unsigned int)oflags & O_EXECVE)
acc_mode |= EXEC_OP;
if ((filep->f_inode->mountflags == MS_RDONLY) && ((acc_mode & WRITE_OP) != 0))
return false;
return true;
}
int fatfs_open(struct file *filep, const char *relpath, int oflags, mode_t mode)
{
BYTE fmode;
char *filePath = NULL;
FATFS *fat = NULL;
FIL *fp = NULL;
FRESULT result;
INT vol, ret;
int accMode;
if (filep == NULL || filep->f_inode == NULL || filep->f_inode->i_private == NULL || relpath == NULL) {
return -EINVAL;
}
if ((UINT)oflags & O_DIRECTORY) {
return -EACCES;
}
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (oflag_convert_and_check(filep, oflags) != true) {
return -EACCES;
}
fat = (FATFS *)filep->f_inode->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
fmode = FatFsGetMode(oflags, &accMode);
if (FatFsCheckPermission(filep->f_inode, false, accMode)) {
free(filePath);
return -EACCES;
}
fp = (FIL *)malloc(sizeof(FIL));
if (fp == NULL) {
free(filePath);
return -ENOMEM;
}
#if !FF_FS_TINY
fp->buf = NULL;
#endif
result = f_open(fp, filePath, fmode);
free(filePath);
if (result == FR_OK) {
filep->f_pos = fp->fptr;
filep->f_priv = fp;
if ((UINT)oflags & O_APPEND) {
#if FF_FS_MINIMIZE <= 2
/* seek to the end of file */
(void)f_lseek(fp, fp->obj.objsize);
filep->f_pos = fp->fptr;
#else
PRINT_ERR("f_lseek is not supported, O_APPEND won't take effect!\n");
#endif
}
} else {
/* open failed, release memory and return errno */
#if !FF_FS_TINY
if (fp->buf != NULL) {
free(fp->buf);
}
#endif
free(fp);
return fatfs_2_vfs(result);
}
return FatfsSdSync(filep->f_inode->mountflags, fat);
}
int fatfs_close(struct file *filep)
{
FATFS *fat = NULL;
FIL *fp = NULL;
FRESULT result;
INT vol;
if (filep == NULL || filep->f_inode == NULL || filep->f_inode->i_private == NULL) {
return -EINVAL;
}
fat = (FATFS *)filep->f_inode->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
result = f_close(fp);
if (result == FR_OK) {
/* close succeed, release memory */
#if !FF_FS_TINY
if (fp->buf != NULL)
free(fp->buf);
#endif
free(fp);
return FatfsSdSync(filep->f_inode->mountflags, fat);
}
return fatfs_2_vfs(result);
}
int fatfs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
return -ENOSYS;
}
ssize_t fatfs_read(struct file *filep, char *buffer, size_t buflen)
{
FIL *fp = NULL;
FRESULT result;
UINT byteRead;
fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
result = f_read(fp, buffer, buflen, &byteRead);
/* file position should be updated */
filep->f_pos = fp->fptr;
if (result == FR_OK)
return byteRead;
return fatfs_2_vfs(result);
}
ssize_t fatfs_write(struct file *filep, const char *buffer, size_t buflen)
{
#if !FF_FS_READONLY
FIL *fp = (FIL *)(filep->f_priv);
FRESULT result;
UINT byteWrite;
if (filep->f_inode->mountflags == MS_RDONLY)
return -EACCES;
FAT_CHECK(fp);
result = f_write(fp, buffer, buflen, &byteWrite);
/* file position should be updated */
filep->f_pos = fp->fptr;
if (f_sync(fp) != FR_OK)
PRINT_ERR("fatfs_write f_sync error \n");
if (result == FR_OK)
return byteWrite;
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_sync(struct file *filep)
{
#if !FF_FS_READONLY
FATFS *fat = NULL;
FIL *fp = NULL;
FRESULT result;
INT vol;
if (filep == NULL || filep->f_inode == NULL || filep->f_inode->i_private == NULL)
return -EINVAL;
if (filep->f_inode->mountflags == MS_RDONLY)
return -EACCES;
fat = (FATFS *)filep->f_inode->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
result = f_sync(fp);
#ifdef LOSCFG_FS_FAT_CACHE
los_part *part = NULL;
if (result == FR_OK) {
part = get_part((INT)fat->pdrv);
if (part == NULL)
return -ENODEV;
(void)OsSdSync(part->disk_id);
}
#endif
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_dup(FAR const struct file *oldp, FAR struct file *newp)
{
return -ENOSYS;
}
off_t fatfs_seek(struct file *filep, off_t offset, int whence)
{
#if FF_FS_MINIMIZE <= 2
FRESULT result;
FIL *fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
switch (whence) {
case SEEK_SET: /* The offset is set to offset bytes. */
break;
case SEEK_CUR: /* The offset is set to its current location plus offset bytes. */
offset += (off_t)filep->f_pos;
break;
case SEEK_END: /* The offset is set to the size of the file plus offset bytes. */
offset += fp->obj.objsize;
break;
default:
return -EINVAL;
}
if (offset < 0) {
return -EINVAL;
}
result = f_lseek(fp, offset);
if (result == FR_OK) {
/* return current position */
filep->f_pos = (off_t)fp->fptr;
return (off_t)fp->fptr;
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
loff_t fatfs_seek64(struct file *filep, loff_t offset, int whence)
{
#if FF_FS_MINIMIZE <= 2
FRESULT result;
FIL *fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
switch (whence) {
case SEEK_SET: /* The offset is set to offset bytes. */
break;
case SEEK_CUR: /* The offset is set to its current location plus offset bytes. */
offset += filep->f_pos;
break;
case SEEK_END: /* The offset is set to the size of the file plus offset bytes. */
offset += (loff_t)fp->obj.objsize;
break;
default:
return -EINVAL;
}
if (offset < 0)
return -EINVAL;
result = f_lseek(fp, offset);
if (result == FR_OK) {
/* return current position */
filep->f_pos = (loff_t)fp->fptr;
return (loff_t)fp->fptr;
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_unlink(struct inode *mountpt, const char *relpath)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FATFS *fat = NULL;
FRESULT result;
INT ret, vol;
char *filePath = NULL;
struct stat st;
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH)
return -ENAMETOOLONG;
if (mountpt->mountflags == MS_RDONLY)
return -EACCES;
ret = fatfs_stat(mountpt, relpath, &st);
if (ret != FR_OK)
return ret;
switch (st.st_mode & S_IFMT) {
case S_IFREG:
break;
case S_IFDIR:
return -EISDIR;
default:
/* unknown file type */
return FAT_ERROR;
}
if (FatFsCheckPermission(mountpt, false, WRITE_OP | EXEC_OP)) {
return -EACCES;
}
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL)
return -ENOMEM;
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
result = f_unlink(filePath);
free(filePath);
if (result == FR_OK) {
return FatfsSdSync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_rename(struct inode *mountpt, const char *oldpath, const char *newpath)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FATFS *fat = NULL;
FRESULT result;
char *oldfspath = NULL;
const char *newfspath = NULL;
INT vol;
size_t oldlen, newlen, len;
INT ret;
if (strlen(oldpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (mountpt->mountflags == MS_RDONLY)
return -EACCES;
oldlen = strlen(oldpath);
newlen = strlen(newpath);
if (!oldlen || !newlen) {
return -EPERM;
}
len = oldlen < newlen ? oldlen : newlen;
if (!strncmp(oldpath, newpath, len) && (oldpath[len] == '/' || newpath[len] == '/')) {
return -EPERM;
}
if (FatFsCheckPermission(mountpt, false, WRITE_OP | EXEC_OP)) {
return -EACCES;
}
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
oldfspath = (char *)malloc(MAX_LFNAME_LENTH);
if (oldfspath == NULL) {
return -ENOMEM;
}
newfspath = newpath;
ret = snprintf_s(oldfspath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, oldpath);
if (ret < 0) {
free(oldfspath);
return -EINVAL;
}
result = f_rename(oldfspath, newfspath);
free(oldfspath);
if (result == FR_OK) {
return FatfsSdSync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
static void get_stmtime(struct stat *st, FILINFO *finfo)
{
struct tm ftm;
INT year, mon, day, hour, min, sec;
WORD mtime;
mtime = finfo->fdate;
day = mtime & 0x1F; /* bit[4:0] Day(1..31) */
mtime >>= 5;
mon = mtime & 0x0F; /* bit[8:5] Month(1..12) */
mtime >>= 4;
year = (mtime & 0x7F) + 1980; /* bit[15:9] Year since 1980(0..127) */
mtime = finfo->ftime;
sec = (mtime & 0x1F) * 2; /* bit[4:0] Second/2(0..29) */
mtime >>= 5;
min = mtime & 0x3F; /* bit[10:5] Minute(0..59) */
mtime >>= 6;
hour = mtime & 0x1F; /* bit[15:11] Hour(0..23) */
(void)memset_s(&ftm, sizeof(ftm), 0, sizeof(ftm));
ftm.tm_year = year - 1900; /* Years since 1900 */
ftm.tm_mon = mon - 1; /* Months since January: 0-11 */
ftm.tm_mday = day; /* Day: 1-31 */
ftm.tm_hour = hour; /* Hours: 0-23 */
ftm.tm_min = min; /* Minutes: 0-59 */
ftm.tm_sec = sec; /* Seconds: 0-59 */
st->st_mtime = mktime(&ftm);
}
int fatfs_stat(struct inode *mountpt, const char *path, struct stat *buf)
{
#if FF_FS_MINIMIZE == 0
FILINFO finfo;
FRESULT result;
FATFS *fat = NULL;
INT vol, ret;
char *filePath = NULL;
if (mountpt == NULL || mountpt->i_private == NULL) {
return -EINVAL;
}
if (strlen(path) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, path);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
result = f_stat(filePath, &finfo);
(void)memset_s((void *)buf, sizeof(struct stat), 0, sizeof(struct stat));
if (result == FR_OK) {
buf->st_dev = 0;
buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
S_IWUSR | S_IWGRP | S_IWOTH |
S_IXUSR | S_IXGRP | S_IXOTH;
if (finfo.fattrib & AM_RDO) {
buf->st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
}
if (finfo.fattrib & AM_DIR) {
buf->st_mode &= ~S_IFREG;
buf->st_mode |= S_IFDIR;
buf->st_mode &= ~fat->fs_dmask;
} else {
buf->st_mode &= ~fat->fs_fmask;
}
if (!(mountpt->mountflags & MS_NOSUID)) {
buf->st_uid = fat->fs_uid;
buf->st_gid = fat->fs_gid;
}
buf->st_size = (long long)finfo.fsize;
#if FF_MAX_SS != FF_MIN_SS
buf->st_blksize = (unsigned long)fat->ssize * fat->csize;
#else
buf->st_blksize = (unsigned long)FF_MIN_SS * fat->csize;
#endif
buf->st_blocks = (unsigned long long)(buf->st_size + buf->st_blksize - 1) / buf->st_blksize;
get_stmtime(buf, &finfo);
}
if (result == FR_INVALID_NAME) { /* root directoy */
buf->st_dev = 0;
buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
S_IWUSR | S_IWGRP | S_IWOTH;
buf->st_mode &= ~S_IFREG;
buf->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
if (mountpt->mountflags & MS_RDONLY) {
buf->st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
}
buf->st_mode &= ~fat->fs_dmask;
buf->st_mtime = 0;
buf->st_size = 0;
if (!(mountpt->mountflags & MS_NOSUID)) {
buf->st_uid = fat->fs_uid;
buf->st_gid = fat->fs_gid;
}
#if FF_MAX_SS != FF_MIN_SS
buf->st_blksize = (unsigned long)fat->ssize * fat->csize;
#else
buf->st_blksize = (unsigned long)FF_MIN_SS * fat->csize;
#endif
buf->st_blocks = (unsigned long long)(buf->st_size + buf->st_blksize - 1) / buf->st_blksize;
result = FR_OK;
}
free(filePath);
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
#define VOL_NAME_LEN 4
int fatfs_statfs(struct inode *mountpt, struct statfs *buf)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
char drive[VOL_NAME_LEN];
DWORD freClust;
FATFS *fat = NULL;
FRESULT result;
INT vol, ret;
FAT_CHECK(mountpt);
FAT_CHECK(buf);
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
ret = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:", vol);
if (ret < 0) {
return -EINVAL;
}
result = f_getfree(drive, &freClust, &fat);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
(void)memset_s((void *)buf, sizeof(struct statfs), 0, sizeof(struct statfs));
buf->f_type = MSDOS_SUPER_MAGIC;
buf->f_bfree = freClust;
buf->f_bavail = freClust;
buf->f_blocks = fat->n_fatent - 2; /* Cluster #0 and #1 is for VBR, reserve sectors and fat */
#if FF_MAX_SS != FF_MIN_SS
buf->f_bsize = fat->ssize * fat->csize;
#else
buf->f_bsize = FF_MIN_SS * fat->csize;
#endif
#if FF_USE_LFN
/* Maximum length of filenames */
buf->f_namelen = FF_MAX_LFN;
#else
/* Maximum length of filenames: 8 is the basename length, 1 is the dot, 3 is the extension length */
buf->f_namelen = (8 + 1 + 3);
#endif
return 0;
#else
return -ENOSYS;
#endif
}
int fatfs_utime(struct inode *mountpt, const char *pathname, const struct tm * set_tm)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FILINFO finfo;
FRESULT result;
FATFS *fat = NULL;
INT vol, status;
char *filePath = NULL;
if (mountpt == NULL || mountpt->i_private == NULL) {
return -EINVAL;
}
if (strlen(pathname) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (set_tm->tm_year < 80) { /* year must be lager than 1980 */
PRINT_ERR("modetime must be lager than 1980-1-1\n");
return -EINVAL;
}
if (mountpt->mountflags == MS_RDONLY) {
return -EACCES;
}
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
status = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, pathname);
if (status < 0) {
free(filePath);
return -EINVAL;
}
/*
* transform set_tm to be the format what we want,
* and write in fatfs through f_utime to set modified
* time.
*/
/* fdate: bit[15:9] Year since 1980(0..127), bit[8:5] Month(0..11), bit[4:0] Day(1..31) */
finfo.fdate = (WORD)(((set_tm->tm_year - 80) << 9) | (set_tm->tm_mon + 1) << 5 | set_tm->tm_mday);
/* ftime: bit[15:11] Hour(0..23), bit[10:5] Minute(0..59), bit[4:0] Second/2(0..29) */
finfo.ftime = (WORD)(set_tm->tm_hour << 11 | set_tm->tm_min << 5 | set_tm->tm_sec >> 1);
result = f_utime(filePath, &finfo);
status = fatfs_2_vfs(result);
free(filePath);
return status;
#else
return -ENOSYS;
#endif
}
int fatfs_opendir(struct inode *mountpt, const char *relpath, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
char *filePath = NULL;
DIR *fdir = NULL;
FATFS *fat = NULL;
FRESULT result;
INT vol, ret;
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
FAT_CHECK(dir);
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
/* open directory */
fdir = (DIR *)malloc(sizeof(DIR));
if (fdir == NULL) {
free(filePath);
return -ENOMEM;
}
result = f_opendir(fdir, filePath);
free(filePath);
if (result != FR_OK) {
free(fdir);
return fatfs_2_vfs(result);
}
dir->u.fs_dir = (fs_dir_s)fdir;
return FR_OK;
#else
return -ENOSYS;
#endif
}
int fatfs_closedir(struct inode *mountpt, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
DIR *fdir = NULL;
FRESULT result;
FAT_CHECK(dir);
fdir = (DIR *)(dir->u.fs_dir);
FAT_CHECK(fdir);
result = f_closedir(fdir);
if (result == FR_OK) {
free(fdir);
return FR_OK;
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
DIR *fdir = NULL;
FILINFO fno;
FRESULT result;
struct dirent *d = NULL;
FAT_CHECK(dir);
fdir = (DIR *)(dir->u.fs_dir);
d = &dir->fd_dir;
(void)memset_s(&fno, sizeof(FILINFO), 0, sizeof(FILINFO));
result = f_readdir(fdir, &fno);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
/*
* 0x00:Reached end of directory.
* 0xFF:The directory is empty.
*/
if (fno.fname[0] == 0 || fno.fname[0] == (TCHAR)0xFF) {
return -ENOENT;
}
if (fno.fattrib & AM_DIR) {
d->d_type = DT_DIR;
} else {
d->d_type = DT_REG;
}
d->d_reclen = (WORD)sizeof(struct dirent);
if (strncpy_s(d->d_name, sizeof(d->d_name), fno.fname, strlen(fno.fname)) != EOK) {
return -ENAMETOOLONG;
}
d->d_off = dir->fd_position;
return ENOERR;
#else
return -ENOSYS;
#endif
}
int fatfs_readdir_all(DIR_FAT *dir_fat)
{
#if FF_FS_MINIMIZE <= 1
char *fn = NULL;
DIR *fdir = NULL;
FILINFO fno;
FRESULT result;
struct fs_dirent_s *dir = NULL;
struct fat_direntall *d = NULL;
INT ret;
INT year, mon, day, hour, min, sec;
WORD tmp;
FAT_CHECK(dir_fat);
dir = (struct fs_dirent_s *)dir_fat->stDirStream.dp;
FAT_CHECK(dir);
fdir = (DIR *)(dir->u.fs_dir);
d = &dir_fat->stBuf.direntall;
result = f_readdir(fdir, &fno);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
/*
* 0x00:Reached end of directory.
* 0xFF:The directory is empty.
*/
if (fno.fname[0] == 0 || fno.fname[0] == (TCHAR)0xFF) {
return -ENOENT;
}
fn = fno.fname;
if (fno.fattrib & AM_DIR) {
d->d_type = DT_DIR;
} else {
d->d_type = DT_REG;
}
#ifdef _DIRENT_HAVE_D_NAMLEN
d->d_namlen = (BYTE)strlen(fn);
#endif
d->d_reclen = (WORD)(sizeof(struct fat_direntall) + strlen(fn));
ret = strncpy_s(d->d_name, NAME_MAX, fn, strlen(fn));
if (ret != EOK) {
return -ENAMETOOLONG;
}
#ifdef _DIRENT_HAVE_D_OFF
d->d_off++;
#endif
d->d_size = fno.fsize;
/* get st_mtime. */
tmp = fno.fdate;
day = tmp & 0x1F; /* bit[4:0] Day(1..31) */
tmp >>= 5;
mon = tmp & 0x0F; /* bit[8:5] Month(1..12) */
tmp >>= 4;
year = tmp & 0x7F; /* bit[15:9] Year since 1980(0..127) */
tmp = fno.ftime;
sec = (tmp & 0x1F) * 2; /* bit[4:0] Second/2(0..29) */
tmp >>= 5;
min = tmp & 0x3F; /* bit[10:5] Minute(0..59) */
tmp >>= 6;
hour = tmp & 0x1F; /* bit[15:11] Hour(0..23) */
d->d_createtime[0] = year;
d->d_createtime[1] = mon;
d->d_createtime[2] = day;
d->d_createtime[3] = hour;
d->d_createtime[4] = min;
d->d_createtime[5] = sec;
return ENOERR;
#else
return -ENOSYS;
#endif
}
int fatfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
DIR *fdir = NULL;
FRESULT result;
FAT_CHECK(dir);
fdir = (DIR *)(dir->u.fs_dir);
FAT_CHECK(fdir);
result = f_rewinddir(fdir);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
return FR_OK;
#else
return -ENOSYS;
#endif
}
int fatfs_mkdir(struct inode *mountpt, const char *relpath, mode_t mode)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
char *filePath = NULL;
FATFS *fat = NULL;
FRESULT result;
INT vol, ret;
if (mountpt->mountflags == MS_RDONLY) {
return -EACCES;
}
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (FatFsCheckPermission(mountpt, true, WRITE_OP | EXEC_OP)) {
return -EACCES;
}
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
result = f_mkdir(filePath);
free(filePath);
if (result == FR_OK) {
return FatfsSdSync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_rmdir(struct inode *mountpt, const char *relpath)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
char *filePath = NULL;
FATFS *fat = NULL;
FRESULT result;
INT ret, vol;
struct stat st;
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (mountpt->mountflags == MS_RDONLY) {
return -EACCES;
}
ret = fatfs_stat(mountpt, relpath, &st);
if (ret != FR_OK) {
return ret;
}
switch (st.st_mode & S_IFMT) {
case S_IFDIR:
break;
case S_IFREG:
return -ENOTDIR;
default:
/* unknown file type */
return FAT_ERROR;
}
if (FatFsCheckPermission(mountpt, true, WRITE_OP | EXEC_OP)) {
return -EACCES;
}
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
result = f_unlink(filePath);
free(filePath);
if (result == FR_OK) {
return FatfsSdSync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
static INT FatFsErase(INT option, los_part *part)
{
INT opt = option;
if ((UINT)opt & FMT_ERASE) {
opt = (UINT)opt & (~FMT_ERASE);
if (EraseDiskByID(part->disk_id, part->sector_start, part->sector_count) != 0) {
PRINTK("SD card erase error.\n");
}
}
if (opt != FM_FAT && opt != FM_FAT32) {
opt = FM_ANY;
}
return opt;
}
static INT FatFsMountEmpty(los_part *part, char *drive, INT len, FATFS *fat)
{
INT result, index;
index = fatfs_get_vol((FATFS *)NULL);
if (index == FAT_ERROR) {
return -EEXIST; /* can't find empty fatfs */
}
VolToPart[index].di = part->disk_id;
VolToPart[index].pd = part->part_id;
VolToPart[index].pt = part->part_no_mbr;
VolToPart[index].ps = part->sector_start;
VolToPart[index].pc = part->sector_count;
result = snprintf_s(drive, len, len - 1, "%d:/", index);
if (result < 0) {
return -EINVAL;
}
result = f_mount(fat, drive, 0);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
return index;
}
#define DMA_ALLGN 64
static INT FatFsSetPartInfo(INT index, los_part *part)
{
los_disk *disk = NULL;
char *mbrBuf = NULL;
INT result;
/* if there is no mbr before, the partition info needs to be changed after formatting. */
if ((part->type != EMMC) && (part->part_no_mbr == 0)) {
disk = get_disk(part->disk_id);
if (disk == NULL) {
return -EIO;
}
mbrBuf = (char *)memalign(DMA_ALLGN, disk->sector_size);
if (mbrBuf == NULL) {
return -ENOMEM;
}
(void)memset_s(mbrBuf, disk->sector_size, 0, disk->sector_size);
result = los_disk_read(part->disk_id, mbrBuf, 0, 1);
if (result < 0) {
free(mbrBuf);
return -EIO;
}
part->sector_start = LD_DWORD_DISK(&mbrBuf[PAR_OFFSET + PAR_START_OFFSET]);
part->sector_count = LD_DWORD_DISK(&mbrBuf[PAR_OFFSET + PAR_COUNT_OFFSET]);
part->part_no_mbr = 1;
part->filesystem_type = mbrBuf[PAR_OFFSET + PAR_TYPE_OFFSET];
VolToPart[index].pt = part->part_no_mbr;
VolToPart[index].ps = part->sector_start;
VolToPart[index].pc = part->sector_count;
free(mbrBuf);
}
return ENOERR;
}
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
static INT FatFsVirPartMkFs(UINT flag, struct inode *mmcNode, int option, int index)
{
INT virRet;
struct inode_search_s desc;
FAR struct inode *inode;
if (flag != 0) {
return VIRERR_NOTMOUNT;
}
SETUP_SEARCH(&desc, g_fatVirPart.virtualinfo.devpartpath, false);
(void)inode_find(&desc);
inode = desc.node;
if (inode != mmcNode) {
return VIRERR_NOPARAM;
}
inode_release(inode);
(void)FatFsUnbindVirPart(f_getfatfs(index));
if (option != FM_FAT32) {
return VIRERR_NOTFIT;
}
virRet = FatFsMakeVirPart(f_getfatfs(index), index);
if (virRet < VIRERR_BASE) {
return FR_OK;
}
return virRet;
}
#endif
#define INDEX_LABEL_LEN 15
static INT FatFsSetLabel(int index)
{
INT result = FR_OK;
#if FF_USE_LABEL
char label[INDEX_LABEL_LEN] = {0};
result = snprintf_s(label, sizeof(label), sizeof(label) - 1, "%d:%s", index, FatLabel);
if (result < 0) {
result = -EINVAL;
}
result = f_setlabel(label);
if (result != FR_OK) {
dprintf("Set sd card volume label failed !\n ");
}
#endif
return result;
}
/*
* return : 0 : OK; -ENODEV : "/dev/mmc0" driver not ready
* sectors : 0~128 0:auto seclect; 1:512Byte; 2:1KB; 4 : 2KB; 128:64KB; if secotrs > 128,auto seclect;
*/
int fatfs_mkfs(const char *dev, int sectors, int option)
{
#if FF_USE_MKFS && !FF_FS_READONLY
INT result, index, err;
FATFS fat = {0};
UINT flag = 0;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
INT virRet = 0;
#endif
los_part *part = NULL;
char drive[DRIVER_NAME_LEN] = {0};
char *work = NULL;
struct inode *mmcNode = NULL;
struct inode_search_s desc;
fat.win = NULL;
/* if device not register in system,it may cause serious error,so return -ENODEV */
SETUP_SEARCH(&desc, dev, false);
(void)inode_find(&desc);
mmcNode = desc.node;
if (mmcNode == NULL)
return -ENODEV; /* "mmc0" driver not ready */
part = los_part_find(mmcNode);
if (part == NULL || part->dev == NULL) {
inode_release(mmcNode);
return -ENODEV;
}
index = FatGetDisk(mmcNode);
/* if not mount, find an empty fatfs to mount */
if (index == FAT_ERROR) {
index = FatFsMountEmpty(part, drive, sizeof(drive), &fat);
if (index < 0) {
err = index;
goto ERROUT;
}
DiskDev[index] = mmcNode;
flag |= 1<<1;
} else {
if (f_checkopenlock(index) != FR_OK) { /* format is not allowed when a file or diretory is opened. */
inode_release(mmcNode);
return -EBUSY;
}
result = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (result < 0) {
inode_release(mmcNode);
return -EINVAL;
}
flag = 0;
}
option = FatFsErase(option, part);
work = (char *)malloc(FF_MAX_SS);
if (work == NULL) {
err = -ENOMEM;
goto ERROUT_WITH_MOUNT;
}
if (part->type == EMMC)
option = (UINT)option | FM_SFD;
result = f_mkfs(drive, option, sectors, work, FF_MAX_SS);
free(work);
if (result != FR_OK) {
err = fatfs_2_vfs(result);
goto ERROUT_WITH_MOUNT;
}
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
FatfsVirtLock();
virRet = FatFsVirPartMkFs(flag, mmcNode, option, index);
FatfsVirtUnlock();
#endif
result = FatFsSetLabel(index);
#ifdef LOSCFG_FS_FAT_CACHE
if (result == FR_OK) {
err = OsSdSync(part->disk_id);
if (err < 0) {
err = -EIO;
goto ERROUT_WITH_MOUNT;
}
}
#endif
err = FatFsSetPartInfo(index, part);
ERROUT_WITH_MOUNT:
if (flag & (1 << 1)) {
(void)f_mount(NULL, drive, 0); /* unmount the tmp fatfs */
DiskDev[index] = (struct inode *)NULL;
}
ERROUT:
inode_release(mmcNode);
if (fat.win != NULL)
free(fat.win);
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (err == 0)
err = virRet;
#endif
return err;
#else
return -ENOSYS;
#endif
}
int fatfs_chattr(struct inode *mountpt, const char *relpath, struct IATTR *fattr)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FRESULT result;
FATFS *fat = NULL;
INT vol, ret;
char *filePath = NULL;
unsigned char attr;
mode_t mode = 0;
if (mountpt == NULL || mountpt->i_private == NULL) {
return -EINVAL;
}
if (strlen(relpath) > MAX_LFNAME_LENTH - VOLUME_CHAR_LENGTH) {
return -ENAMETOOLONG;
}
if (mountpt->mountflags == MS_RDONLY) {
return -EACCES;
}
attr = mode & (AM_RDO | AM_HID | AM_SYS | AM_ARC);
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
filePath = (char *)malloc(MAX_LFNAME_LENTH);
if (filePath == NULL) {
return -ENOMEM;
}
ret = snprintf_s(filePath, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
free(filePath);
return -EINVAL;
}
result = f_chmod(filePath, attr, 0xff);
free(filePath);
if (result == FR_OK) {
return FatfsSdSync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
int fatfs_getlabel(void *handle, char *label)
{
#if FF_USE_LABEL
BYTE index;
FATFS *fat = NULL;
FRESULT result;
los_part *part = NULL;
char drive[DRIVER_NAME_LEN];
DWORD *vsn = NULL;
INT ret;
if (label == NULL) {
return -EFAULT;
}
fat = (FATFS *)handle;
if (fat == NULL) {
return -EINVAL;
}
index = (BYTE)fatfs_get_vol(fat);
if (index >= FF_VOLUMES || (INT8)index < 0) {
return -EINVAL;
}
part = los_part_find(DiskDev[index]);
if (part == NULL) {
return -ENODEV;
}
ret = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (ret < 0) {
return -EINVAL;
}
result = f_getlabel(drive, label, vsn);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
return OK;
#else
return -ENOSYS;
#endif
}
int fatfs_fallocate(FAR struct file *filep, int mode, off_t offset, off_t len)
{
#if FF_USE_EXPAND && !FF_FS_READONLY
FIL *fp = (FIL *)(filep->f_priv);
FRESULT res;
FAT_CHECK(fp);
if (len <= 0 || offset < 0) {
return -EINVAL;
}
if (mode != FALLOC_FL_KEEP_SIZE) {
return -EINVAL;
}
if (filep->f_inode->mountflags == MS_RDONLY) {
return -EACCES;
}
res = f_expand(fp, (FSIZE_t)offset, (FSIZE_t)len, FALLOC_FL_KEEP_SIZE);
if (res == FR_OK) {
res = f_sync(fp);
}
return fatfs_2_vfs(res);
#else
return -ENOSYS;
#endif
}
int fatfs_fallocate64(FAR struct file *filep, int mode, off64_t offset, off64_t len)
{
#if FF_USE_EXPAND && !FF_FS_READONLY
FIL *fp = (FIL *)(filep->f_priv);
FRESULT res;
FAT_CHECK(fp);
if (len >= FAT32_MAXSZIE || len <= 0 || offset >= FAT32_MAXSZIE || offset < 0) {
return -EINVAL;
}
if (mode != FALLOC_FL_KEEP_SIZE) {
return -EINVAL;
}
if (filep->f_inode->mountflags == MS_RDONLY) {
return -EACCES;
}
res = f_expand(fp, (FSIZE_t)offset, (FSIZE_t)len, FALLOC_FL_KEEP_SIZE);
if (res == FR_OK) {
res = f_sync(fp);
}
return fatfs_2_vfs(res);
#else
return -ENOSYS;
#endif
}
int los_set_systime_status(BOOL bStatus)
{
if (bStatus != FAT_SYSTEM_TIME_ENABLE && bStatus != FAT_SYSTEM_TIME_DISABLE) {
return -EINVAL;
}
f_settimestatus(bStatus);
return FR_OK;
}
int fatfs_truncate(FAR struct file *filep, off_t length)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FIL *fp = (FIL *)(filep->f_priv);
FRESULT res = FR_OK;
UINT count;
DWORD n, fclust;
#ifdef LOSCFG_FS_FAT_CACHE
FATFS *fat = NULL;
#endif
if (filep->f_inode->mountflags == MS_RDONLY) {
return -EACCES;
}
FAT_CHECK(fp);
if (length < 0) {
return -EINVAL;
}
res = f_getclustinfo(fp, &fclust, &count);
if (res != FR_OK) {
return fatfs_2_vfs(res);
}
if (count == 0xFFFFFFFF) {
return -EPERM;
}
n = (DWORD)(fp->obj.fs)->csize * SS(fp->obj.fs); /* Cluster size */
if ((unsigned long)length > count * n) {
#if FF_USE_EXPAND
res = f_expand(fp, 0, (FSIZE_t)(length), FALLOC_FL_KEEP_SIZE);
#else
return -ENOSYS;
#endif
} else if ((unsigned long)length < n * count) {
res = f_truncate(fp, (FSIZE_t)length);
}
fp->obj.objsize = length; /* Set file size to length */
fp->flag |= 0x40; /* Set modified flag */
if (res == FR_OK) {
res = f_sync(fp);
}
#ifdef LOSCFG_FS_FAT_CACHE
if (res == FR_OK) {
fat = (FATFS *)filep->f_inode->i_private;
FAT_CHECK(fat);
return FatfsSdSync(filep->f_inode->mountflags, fat);
}
#endif
return fatfs_2_vfs(res);
#else
return -ENOSYS;
#endif
}
int fatfs_truncate64(FAR struct file *filep, off64_t length)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FIL *fp = (FIL *)(filep->f_priv);
FRESULT res = FR_OK;
UINT count;
DWORD n, fclust;
#ifdef LOSCFG_FS_FAT_CACHE
FATFS *fat = NULL;
#endif
FAT_CHECK(fp);
if (filep->f_inode->mountflags == MS_RDONLY) {
return -EACCES;
}
if (length >= FAT32_MAXSZIE || length < 0) {
return -EINVAL;
}
res = f_getclustinfo(fp, &fclust, &count);
if (res != FR_OK) {
return fatfs_2_vfs(res);
}
if (count == 0xFFFFFFFF) {
return -EPERM;
}
n = (DWORD)(fp->obj.fs)->csize * SS(fp->obj.fs); /* Cluster size */
if (length > (off64_t)count * n) {
#if FF_USE_EXPAND
res = f_expand(fp, 0, (FSIZE_t)(length), FALLOC_FL_KEEP_SIZE);
#else
return -ENOSYS;
#endif
} else if (length < (off64_t)count * n) {
res = f_truncate(fp, (FSIZE_t)length);
}
fp->obj.objsize = length; /* Set file size to length */
fp->flag |= 0x40; /* Set modified flag */
if (res == FR_OK) {
res = f_sync(fp);
}
#ifdef LOSCFG_FS_FAT_CACHE
if (res == FR_OK) {
fat = (FATFS *)filep->f_inode->i_private;
FAT_CHECK(fat);
return FatfsSdSync(filep->f_inode->mountflags, fat);
}
#endif
return fatfs_2_vfs(res);
#else
return -ENOSYS;
#endif
}
#define DATE_OFFSET 16
#define CHECK_FILE_NUM 3
static INT FatFsTimeMin(DIR_FILE dirFile[])
{
INT min = 0;
DWORD timeMin = 0;
MIN((dirFile[0].fno.fdate << DATE_OFFSET | dirFile[0].fno.ftime),
(dirFile[1].fno.fdate << DATE_OFFSET | dirFile[1].fno.ftime), timeMin);
MIN((DWORD)(dirFile[2].fno.fdate << DATE_OFFSET | dirFile[2].fno.ftime), timeMin, timeMin);
if (timeMin == (dirFile[0].fno.fdate << DATE_OFFSET | dirFile[0].fno.ftime)) {
min = 0;
} else if (timeMin == (dirFile[1].fno.fdate << DATE_OFFSET | dirFile[1].fno.ftime)) {
min = 1;
} else if (timeMin == (dirFile[2].fno.fdate << DATE_OFFSET | dirFile[2].fno.ftime)) {
min = 2; /* check the latest three files */
}
return min;
}
int fatfs_fscheck(struct inode *mountpt, const char *relpath, struct fs_dirent_s *dir)
{
DIR *fdir = NULL;
FILINFO fno;
FRESULT result;
INT count = 0;
INT timeOldest = 0;
DIR dirBackup = {0};
DIR_FILE dirFile[CHECK_FILE_NUM] = {0};
INT loop = 0;
#ifdef LOSCFG_FS_FAT_CACHE
FATFS *fat = NULL;
los_part *part = NULL;
INT vol;
#endif
INT ret;
if (mountpt->mountflags == MS_RDONLY) {
return -EACCES;
}
FAT_CHECK(dir);
ret = fatfs_opendir(mountpt, relpath, dir);
if (ret != FR_OK) {
return ret;
}
fdir = (DIR *)(dir->u.fs_dir);
if ((fdir->obj.fs)->fs_type != FS_FAT32) {
(void)fatfs_closedir(mountpt, dir);
return -EINVAL;
}
do {
(void)memcpy_s(&dirBackup, sizeof(DIR), fdir, sizeof(DIR));
result = f_readdir(fdir, &fno);
if (result != FR_OK) {
break;
}
if ((fno.fname[0] == 0 || fno.fname[0] == (TCHAR)0xFF)) {
break;
}
if (fno.fattrib == AM_DIR) {
continue;
}
if (count == 0) {
(void)memcpy_s(&dirFile[0].f_dir, sizeof(DIR), &dirBackup, sizeof(DIR));
(void)memcpy_s(&dirFile[0].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
} else if (count == 1) {
(void)memcpy_s(&dirFile[1].f_dir, sizeof(DIR), &dirBackup, sizeof(DIR));
(void)memcpy_s(&dirFile[1].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
} else if (count == 2) { /* check the latest three files */
(void)memcpy_s(&dirFile[2].f_dir, sizeof(DIR), &dirBackup, sizeof(DIR));
(void)memcpy_s(&dirFile[2].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
timeOldest = FatFsTimeMin(dirFile);
} else {
if ((fno.fdate << DATE_OFFSET | fno.ftime) >
(dirFile[timeOldest].fno.fdate << DATE_OFFSET | dirFile[timeOldest].fno.ftime)) {
(void)memcpy_s(&dirFile[timeOldest].f_dir, sizeof(DIR), &dirBackup, sizeof(DIR));
(void)memcpy_s(&dirFile[timeOldest].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
timeOldest = FatFsTimeMin(dirFile);
}
}
count++;
} while (result == FR_OK);
if (count >= CHECK_FILE_NUM) {
loop = CHECK_FILE_NUM;
} else {
loop = count;
}
ret = fatfs_closedir(mountpt, dir);
if (ret != FR_OK) {
return ret;
}
for (count = 0; count < loop; count++) {
result = f_fcheckfat(&dirFile[count]);
if (result != FR_OK) {
return fatfs_2_vfs(result);
}
}
#ifdef LOSCFG_FS_FAT_CACHE
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES) {
return -ENOENT;
}
part = get_part((INT)fat->pdrv);
if (part != NULL) {
(void)OsSdSync(part->disk_id);
}
#endif
return ENOERR;
}
int fatfs_virstatfs(struct inode *mountpt, const char *relpath, struct statfs *buf)
{
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
return fatfs_virstatfs_internel(mountpt, relpath, buf);
#else
return 0;
#endif
}
const struct mountpt_operations fat_operations = {
fatfs_open, /* open */
fatfs_close, /* close */
fatfs_read, /* read */
fatfs_write, /* write */
fatfs_seek, /* seek */
fatfs_ioctl, /* ioctl */
OsVfsFileMmap, /* mmap */
fatfs_sync, /* sync */
fatfs_dup, /* dup */
NULL, /* fstat */
fatfs_truncate, /* truncate */
fatfs_opendir, /* opendir */
fatfs_closedir, /* closedir */
fatfs_readdir, /* readdir */
fatfs_rewinddir, /* rewinddir */
fatfs_bind, /* bind */
fatfs_unbind, /* unbind */
fatfs_statfs, /* statfs */
fatfs_virstatfs, /* virstatfs */
fatfs_unlink, /* unlinke */
fatfs_mkdir, /* mkdir */
fatfs_rmdir, /* rmdir */
fatfs_rename, /* rename */
fatfs_stat, /* stat */
fatfs_utime, /* utime */
fatfs_chattr, /* chattr */
fatfs_seek64, /* seek64 */
fatfs_getlabel, /* getlabel */
fatfs_fallocate, /* fallocate */
fatfs_fallocate64, /* fallocate64 */
fatfs_truncate64, /* truncate64 */
fatfs_fscheck, /* fscheck */
NULL, /* map_pages */
NULL, /* readpage */
NULL, /* writepage */
};
FSMAP_ENTRY(fat_fsmap, "vfat", fat_operations, FALSE, TRUE);
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
#endif /* LOSCFG_FS_FAT */