lu/mcu_hi3321_watch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
5812031e11
mcu_hi3321_watch/middleware/utils/fs/fat/os_adapt/fatfs.c
LU 5812031e11 frist commit
2025-05-26 20:15:20 +08:00

2153 lines
54 KiB
C
Raw Blame History

/* ----------------------------------------------------------------------------
* Copyright (c) @CompanyNameMagicTag 2013-2019. 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 CONFIG_FS_FAT
#include "errno.h"
#include "ff.h"
#ifdef CONFIG_FS_DIROP_FAT
#include "dirop_fat.h"
#endif
#include "disk_pri.h"
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
#include "virpart.h"
#include "errcode_fat.h"
#include "virpartff.h"
#endif
#ifdef CONFIG_FS_FAT_CACHE
#include "bcache.h"
#endif
#include "fs/fs.h"
#include "vfs_fs.h"
#define fs_log_err dpal_log_err
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
FAT_VIR_PART FatVirPart = {0};
#endif
PARTITION VolToPart[FF_VOLUMES];
static struct inode *DiskDev[FF_VOLUMES];
char FatLabel[LABEL_LEN];
#define DRIVER_NAME_LEN 8
enum {
FAT_STATUS_UNBIND,
FAT_STATUS_BIND
};
#define BOOT_SECTOR_RESERVED1 65
#define BOOT_SECTOR_NUM 0
#define BOOT_SECTOR_CNT 1
#define BOOT_SECTOR_SIZE 512 /* BPB BIOS Parameter block struct just for FAT32 */
BYTE FatMountStatus = FAT_STATUS_UNBIND;
/* Returns -1 if there is no space to install fatfs driver, else returns >=0 */
static INT fatfs_get_disk(const struct inode *node)
{
INT index;
for (index = 0; index < FF_VOLUMES; index++) {
if (DiskDev[index] == node) {
return index;
}
}
return FAT_ERROR;
}
static INT fatfs_direct_sync(const FATFS *fat)
{
#ifdef CONFIG_FS_FAT_CACHE
los_part *part = get_part((INT)fat->pdrv);
if (part == NULL)
return -ENODEV;
if (OsSdSync(part->disk_id) != ENOERR)
return -EIO;
#endif
return ENOERR;
}
static INT fatfs_sd_sync(unsigned long mountflags, const FATFS *fat)
{
#ifdef CONFIG_FS_FAT_CACHE
if (mountflags != MS_NOSYNC) {
return fatfs_direct_sync(fat);
}
#endif
return ENOERR;
}
INT fatfs_2_vfs(INT result)
{
INT status = ENOERR;
#ifdef CONFIG_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 CONFIG_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 fatfs_bind_check(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;
#if !FF_MULTI_PARTITION
if (part->part_no_mbr > 1)
return -EPERM;
#endif
*partition = part;
return ENOERR;
}
static int fatfs_stat_set(int fd, unsigned char value)
{
BYTE sector_buffer[BOOT_SECTOR_SIZE] = {};
los_part *part = get_part(fd);
QWORD sector = BOOT_SECTOR_NUM;
const UINT count = BOOT_SECTOR_CNT;
INT ret;
if (part->type != EMMC)
sector += part->sector_start;
ret = los_part_read(fd, sector_buffer, sector, count);
if (ret < 0) {
printf("%s read ret=%d\n", __FUNCTION__, ret);
return FR_DISK_ERR;
}
sector_buffer[BOOT_SECTOR_RESERVED1] = value;
ret = los_part_write(fd, sector_buffer, sector, count);
if (ret < 0) {
printf("%s ret=%d\n", __FUNCTION__, ret);
return FR_DISK_ERR;
}
return FR_OK;
}
static int fatfs_stat_get(int fd, unsigned char *value)
{
BYTE sector_buffer[BOOT_SECTOR_SIZE] = {};
los_part *part = get_part(fd);
QWORD sector = BOOT_SECTOR_NUM;
const UINT count = BOOT_SECTOR_CNT;
INT ret;
if (part->type != EMMC)
sector += part->sector_start;
ret = los_part_read(fd, sector_buffer, sector, count);
if (ret < 0) {
printf("%s read ret=%d\n", __FUNCTION__, ret);
return FR_DISK_ERR;
}
*value = sector_buffer[BOOT_SECTOR_RESERVED1];
return FR_OK;
}
int fatfs_bind(struct inode *blkdriver, const void *data, void **handle, const char *relpath)
{
FATFS *fat = NULL;
INT result;
INT index;
INT err;
los_part *part = NULL;
char drive[DRIVER_NAME_LEN];
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
struct inode_search_s desc;
#endif
result = fatfs_bind_check(blkdriver, &part);
if (result != 0)
return result;
err = SetDiskPartName(part, relpath);
if (err != 0)
return -ENOMEM;
index = fatfs_get_disk((struct inode *)NULL);
if (index >= FF_VOLUMES || 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 *)dpal_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;
dpal_free(fat);
goto ERROUT_WITH_DISK;
}
/* 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) {
err = fatfs_2_vfs(result);
goto ERROUT_WITH_MOUNT;
}
DIR *dir = NULL;
dir = (DIR *)dpal_malloc(sizeof(DIR));
if (dir == NULL) {
err = -ENOMEM;
goto ERROUT_WITH_MOUNT;
}
memset(dir, 0, sizeof(DIR));
#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);
dpal_free(dir);
goto ERROUT_WITH_MOUNT;
}
result = f_closedir(dir);
if (result != FR_OK) {
err = fatfs_2_vfs(result);
dpal_free(dir);
goto ERROUT_WITH_MOUNT;
}
#else
fs_log_err("cannot open root directory to check if fatfs is invalid!\n");
#endif
/* mount ok! */
*handle = (void *)fat;
dpal_free(dir);
(void)fatfs_stat_get(part->part_id, &FatMountStatus);
if (FatMountStatus == FAT_STATUS_UNBIND) {
(void)fatfs_stat_set(part->part_id, FAT_STATUS_BIND);
#ifdef CONFIG_FS_FAT_CACHE
if (OsSdSync(part->disk_id) != ENOERR) {
err = -EIO;
goto ERROUT_WITH_MOUNT;
}
#endif
}
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
/* Parent Partition Mount Success, then process virtual partition mount operation */
if (result == FR_OK) {
los_disk *disk = get_disk(part->disk_id);
if (disk->sector_count > UINT_MAX) {
return VIRERR_NOTFIT;
}
if (fat->fs_type != FS_FAT32)
return VIRERR_NOTFIT;
SETUP_SEARCH(&desc, FatVirPart.virtualinfo.devpartpath, false);
result = inode_find(&desc);
RELEASE_SEARCH(&desc);
if (result < 0 || blkdriver != desc.node) {
return VIRERR_NOPARAM;
} else {
result = fatfs_bind_vir_part(fat, index);
if (result != FR_OK && result < VIRERR_BASE) {
return VIRERR_INTER_ERR;
}
}
}
#endif
fat->fsi_check = TRUE;
return fatfs_2_vfs(result);
ERROUT_WITH_MOUNT:
(void)f_mount((FATFS *)NULL, drive, 0);
if (fat->win != NULL) {
dpal_free(fat->win);
fat->win = NULL;
}
dpal_free(fat);
ERROUT_WITH_DISK:
DiskDev[index] = (struct inode *)NULL;
ERROUT:
dpal_free(part->part_name);
part->part_name = NULL;
return err;
}
int fatfs_unbind(void *handle, struct inode **blkdriver)
{
INT index;
FATFS *fat = NULL;
INT result;
los_part *part = NULL;
char drive[DRIVER_NAME_LEN];
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
struct inode_search_s desc;
#endif
fat = (FATFS *)handle;
if (fat == NULL)
return -EINVAL;
index = fatfs_get_vol(fat);
if (index >= FF_VOLUMES || index < 0)
return -EINVAL;
result = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (result < 0)
return -EINVAL;
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
/* Release virtual partition objects before unbind real partition */
result = fatfs_unbind_vir_part(fat);
if (result == FR_OK) {
part = los_part_find(DiskDev[index]);
SETUP_SEARCH(&desc, FatVirPart.virtualinfo.devpartpath, false);
result = inode_find(&desc);
RELEASE_SEARCH(&desc);
if (part == NULL || (result >= 0 && part->dev == desc.node)) {
(void)memset_s(DevPartName, sizeof(DevPartName), 0, sizeof(DevPartName));
(void)memset_s(&FatVirPart.virtualinfo, sizeof(virpartinfo), 0, sizeof(virpartinfo));
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) {
(void)fatfs_stat_set(part->part_id, FatMountStatus);
#ifdef CONFIG_FS_FAT_CACHE
if (OsSdSync(part->disk_id) != ENOERR) {
fs_log_err("OsSdSync failed in %s\n", __FUNCTION__);
}
#endif
if (part->part_name) {
dpal_free(part->part_name);
part->part_name = NULL;
}
}
if (blkdriver != NULL)
*blkdriver = DiskDev[index];
DiskDev[index] = (struct inode *)NULL;
if (fat->win != NULL) {
dpal_free(fat->win);
fat->win = NULL;
}
dpal_free(fat);
return OK;
}
static BYTE fatfs_get_mode(int oflags)
{
BYTE f_mode = FA_READ;
if ((UINT)oflags & O_WRONLY)
f_mode |= FA_WRITE;
if (((UINT)oflags & O_ACCMODE) & O_RDWR)
f_mode |= FA_WRITE;
/* Creates a new file if the file is not existing, otherwise, just open it. */
if ((UINT)oflags & O_CREAT) {
f_mode |= FA_OPEN_ALWAYS;
/* Creates a new file. If the file already exists, the function shall fail. */
if ((UINT)oflags & O_EXCL)
f_mode |= FA_CREATE_NEW;
}
/* Creates a new file. If the file already exists, its length shall be truncated to 0. */
if ((UINT)oflags & O_TRUNC)
f_mode |= FA_CREATE_ALWAYS;
return f_mode;
}
int fatfs_open(struct file *filep, const char *relpath, int oflags, mode_t mode)
{
BYTE f_mode;
char *f_path = NULL;
FATFS *fat = NULL;
FIL *fp = NULL;
FRESULT result;
INT vol, ret;
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 (filep->f_inode->mountflags == MS_RDONLY && oflags != O_RDONLY)
return -EACCES;
fat = (FATFS *)filep->f_inode->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
f_mode = fatfs_get_mode(oflags);
fp = (FIL *)dpal_malloc(sizeof(FIL));
if (fp == NULL) {
dpal_free(f_path);
return -ENOMEM;
}
#if !FF_FS_TINY
fp->buf = NULL;
#endif
result = f_open(fp, f_path, f_mode);
dpal_free(f_path);
if (result != FR_OK) {
/* open failed, release memory and return errno */
goto ERROUT;
}
filep->f_pos = fp->fptr;
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
fs_log_err("f_lseek is not supported, O_APPEND won't take effect!\n");
#endif
}
ret = fatfs_sd_sync(filep->f_inode->mountflags, fat);
if (ret != ENOERR) {
result = FR_DISK_ERR;
(void)f_close(fp);
goto ERROUT;
}
filep->f_priv = fp;
return fatfs_2_vfs(result);
ERROUT:
#if !FF_FS_TINY
if (fp->buf != NULL)
dpal_free(fp->buf);
#endif
dpal_free(fp);
return fatfs_2_vfs(result);
}
int fatfs_close(struct file *filep)
{
FATFS *fat = NULL;
FIL *fp = NULL;
FRESULT result;
INT vol;
INT ret;
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)
dpal_free(fp->buf);
#endif
dpal_free(fp);
ret = fatfs_direct_sync(fat);
if (ret != ENOERR)
printf("WARNNING: sd sync failed, return %d\n", ret);
}
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 byte_read;
fp = (FIL *)(filep->f_priv);
FAT_CHECK(fp);
result = f_read(fp, buffer, buflen, &byte_read);
/* file position should be updated */
filep->f_pos = fp->fptr;
if (result == FR_OK)
return byte_read;
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 byte_write;
if (filep->f_inode->mountflags == MS_RDONLY)
return -EACCES;
FAT_CHECK(fp);
result = f_write(fp, buffer, buflen, &byte_write);
/* file position should be updated */
filep->f_pos = fp->fptr;
if (f_sync(fp) != FR_OK)
fs_log_err("fatfs_write f_sync error \n");
if (result == FR_OK)
return byte_write;
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;
#ifdef CONFIG_FS_FAT_CACHE
los_part *part = NULL;
#endif
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 CONFIG_FS_FAT_CACHE
if (result == FR_OK) {
part = get_part((INT)fat->pdrv);
if (part == NULL)
return -ENODEV;
if (OsSdSync(part->disk_id) != ENOERR) {
return -EIO;
}
}
#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);
if (offset >= FAT32_MAXSZIE || offset <= -FAT32_MAXSZIE)
return -EINVAL;
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 *f_path = 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;
}
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
result = f_unlink(f_path);
dpal_free(f_path);
if (result == FR_OK) {
return fatfs_sd_sync(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;
fat = (FATFS *)mountpt->i_private;
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
oldfspath = (char *)dpal_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) {
dpal_free(oldfspath);
return -EINVAL;
}
result = f_rename(oldfspath, newfspath);
dpal_free(oldfspath);
if (result == FR_OK) {
return fatfs_sd_sync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
static void get_stmtime(struct stat *st, const 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 */
}
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 *f_path = 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;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, path);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
result = f_stat(f_path, &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;
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 | S_IXUSR | S_IXGRP | S_IXOTH;
}
#ifdef __LITEOS__
buf->st_size = (long long)finfo.fsize;
#else
buf->st_size = (off_t)finfo.fsize;
#endif
#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;
buf->st_mtime = 0;
buf->st_size = 0;
#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;
}
dpal_free(f_path);
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 fre_clust;
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;
if (fat->fsi_check == TRUE) {
result = f_setfree(drive, &fre_clust, &fat);
if (result != FR_OK)
return fatfs_2_vfs(result);
fat->fsi_check = FALSE;
}
result = f_getfree(drive, &fre_clust, &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 = fre_clust;
buf->f_bavail = fre_clust;
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 *f_path = 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 */
fs_log_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;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
status = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, pathname);
if (status < 0) {
dpal_free(f_path);
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(f_path, &finfo);
status = fatfs_2_vfs(result);
dpal_free(f_path);
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 *f_path = NULL;
DIR *f_dir = 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;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
/* open directory */
f_dir = (DIR *)dpal_malloc(sizeof(DIR));
if (f_dir == NULL) {
dpal_free(f_path);
return -ENOMEM;
}
result = f_opendir(f_dir, f_path);
dpal_free(f_path);
if (result != FR_OK) {
dpal_free(f_dir);
return fatfs_2_vfs(result);
}
dir->u.fs_dir = (fs_dir_s)f_dir;
return FR_OK;
#else
return -ENOSYS;
#endif
}
int fatfs_closedir(struct inode *mountpt, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
DIR *f_dir = NULL;
FRESULT result;
FAT_CHECK(dir);
f_dir = (DIR *)(dir->u.fs_dir);
FAT_CHECK(f_dir);
result = f_closedir(f_dir);
if (result == FR_OK) {
dpal_free(f_dir);
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 *f_dir = NULL;
FILINFO fno;
FRESULT result;
struct dirent *d = NULL;
FAT_CHECK(dir);
f_dir = (DIR *)(dir->u.fs_dir);
d = &dir->fd_dir;
(void)memset_s(&fno, sizeof(FILINFO), 0, sizeof(FILINFO));
result = f_readdir(f_dir, &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
}
#ifdef CONFIG_FS_DIROP_FAT
int fatfs_readdir_all(DIR_FAT *dir_fat)
{
#if FF_FS_MINIMIZE <= 1
char *fn = NULL;
DIR *f_dir = 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);
f_dir = (DIR *)(dir->u.fs_dir);
d = &dir_fat->stBuf.direntall;
result = f_readdir(f_dir, &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, sizeof(d->d_name) + PATH_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
}
#endif
int fatfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir)
{
#if FF_FS_MINIMIZE <= 1
DIR *f_dir = NULL;
FRESULT result;
FAT_CHECK(dir);
f_dir = (DIR *)(dir->u.fs_dir);
FAT_CHECK(f_dir);
result = f_rewinddir(f_dir);
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 *f_path = 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;
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
result = f_mkdir(f_path);
dpal_free(f_path);
if (result == FR_OK)
return fatfs_sd_sync(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 *f_path = 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;
}
fat = (FATFS *)mountpt->i_private;
FAT_CHECK(fat);
vol = fatfs_get_vol(fat);
if (vol < 0 || vol > FF_VOLUMES)
return -ENOENT;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
result = f_unlink(f_path);
dpal_free(f_path);
if (result == FR_OK) {
return fatfs_sd_sync(mountpt->mountflags, fat);
}
return fatfs_2_vfs(result);
#else
return -ENOSYS;
#endif
}
static INT fatfs_erase(INT option, const 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)
printf("SD card erase error.\n");
}
if (opt != FM_FAT && opt != FM_FAT32)
opt = FM_ANY;
return opt;
}
static INT fatfs_mount_empty(const 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 fatfs_set_partinfo(INT index, los_part *part)
{
los_disk *disk = NULL;
char *mbr_buf = 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;
}
mbr_buf = (char *)memalign(DMA_ALLGN, disk->sector_size);
if (mbr_buf == NULL) {
return -ENOMEM;
}
(void)memset_s(mbr_buf, disk->sector_size, 0, disk->sector_size);
result = los_disk_read(part->disk_id, mbr_buf, 0, 1);
if (result < 0) {
dpal_free(mbr_buf);
return -EIO;
}
part->sector_start = LD_DWORD_DISK(&mbr_buf[PAR_OFFSET + PAR_START_OFFSET]);
part->sector_count = LD_DWORD_DISK(&mbr_buf[PAR_OFFSET + PAR_COUNT_OFFSET]);
part->part_no_mbr = 1;
part->filesystem_type = mbr_buf[PAR_OFFSET + PAR_TYPE_OFFSET];
VolToPart[index].pt = part->part_no_mbr;
VolToPart[index].ps = part->sector_start;
VolToPart[index].pc = part->sector_count;
dpal_free(mbr_buf);
}
return ENOERR;
}
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
static INT fatfs_virpart_mkfs(UINT flag, const struct inode *mmc_node, int option, int index)
{
struct inode_search_s desc;
INT vir_ret;
if (flag != 0)
return VIRERR_NOTMOUNT;
SETUP_SEARCH(&desc, FatVirPart.virtualinfo.devpartpath, false);
vir_ret = inode_find(&desc);
RELEASE_SEARCH(&desc);
if (vir_ret < 0 || desc.node != mmc_node) {
return VIRERR_NOPARAM;
}
(void)fatfs_unbind_vir_part(f_getfatfs(index));
if (option != FM_FAT32)
return VIRERR_NOTFIT;
vir_ret = fatfs_make_vir_part(f_getfatfs(index), index);
if (vir_ret < VIRERR_BASE)
return FR_OK;
return vir_ret;
}
#endif
#define INDEX_LABEL_LEN 15
static INT fatfs_set_label(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) {
dprintf("setlable snprintf_s failed !\n ");
return -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;
struct inode_search_s desc;
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
INT vir_ret = 0;
#endif
los_part *part = NULL;
char drive[DRIVER_NAME_LEN] = {0};
char *work = NULL;
struct inode *mmc_node = NULL;
MKFS_PARM opt;
fat.win = NULL;
/* if device not register in system,it may cause serious error,so return -ENODEV */
SETUP_SEARCH(&desc, dev, false);
result = inode_find(&desc);
if (result < 0) {
RELEASE_SEARCH(&desc);
return -ENODEV; /* "mmc0" driver not ready */
}
mmc_node = desc.node;
part = los_part_find(mmc_node);
if (part == NULL || part->dev == NULL) {
inode_release(mmc_node);
RELEASE_SEARCH(&desc);
return -ENODEV;
}
inode_semtake();
index = fatfs_get_disk(mmc_node);
/* if not mount, find an empty fatfs to mount */
if (index == FAT_ERROR) {
index = fatfs_mount_empty(part, drive, sizeof(drive), &fat);
if (index < 0) {
err = index;
goto ERROUT;
}
DiskDev[index] = mmc_node;
flag |= 1<<1;
} else {
if (f_checkopenlock(index) != FR_OK) { /* format is not allowed when a file or diretory is opened. */
f_checkopenunlock(index);
inode_release(mmc_node);
RELEASE_SEARCH(&desc);
inode_semgive();
return -EBUSY;
}
result = snprintf_s(drive, sizeof(drive), sizeof(drive) - 1, "%d:/", index);
if (result < 0) {
f_checkopenunlock(index);
inode_release(mmc_node);
RELEASE_SEARCH(&desc);
inode_semgive();
return -EINVAL;
}
flag = 0;
}
option = fatfs_erase(option, part);
work = (char *)dpal_malloc(FF_MAX_SS);
if (work == NULL) {
err = -ENOMEM;
goto ERROUT_WITH_MOUNT;
}
if (part->type == EMMC)
option = (UINT)option | FM_SFD;
opt.fmt = option;
opt.n_fat = 1;
opt.sector = sectors;
opt.n_root = 0;
opt.align = 0;
result = f_mkfs(drive, &opt, work, FF_MAX_SS);
dpal_free(work);
if (result != FR_OK) {
err = fatfs_2_vfs(result);
goto ERROUT_WITH_MOUNT;
}
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
los_disk *disk = get_disk(part->disk_id);
if (disk->sector_count > UINT_MAX) {
vir_ret = VIRERR_NOTFIT;
} else{
vir_ret = fatfs_virpart_mkfs(flag, mmc_node, option, index);
}
#endif
result = fatfs_set_label(index);
#ifdef CONFIG_FS_FAT_CACHE
if (result == FR_OK) {
if (OsSdSync(part->disk_id) != ENOERR) {
err = -EIO;
goto ERROUT_WITH_MOUNT;
}
}
#endif
err = fatfs_set_partinfo(index, part);
#ifdef LOSCFG_FS_FAT_UNI_TRIM
if (part->trimManager != NULL) {
UniTrimDeinit(part->trimManager);
part->trimManager = UniTrimInit(part->dev, sectors, part->sector_count);
}
#endif
ERROUT_WITH_MOUNT:
if (flag & (1 << 1)) {
(void)f_mount(NULL, drive, 0); /* unmount the tmp fatfs */
DiskDev[index] = (struct inode *)NULL;
} else if (flag == 0) {
f_checkopenunlock(index);
}
ERROUT:
inode_release(mmc_node);
RELEASE_SEARCH(&desc);
inode_semgive();
if (fat.win != NULL) {
dpal_free(fat.win);
fat.win = NULL;
}
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
if (err == 0)
err = vir_ret;
#endif
return err;
#else
return -ENOSYS;
#endif
}
int fatfs_chattr(struct inode *mountpt, const char *relpath, mode_t mode)
{
#if FF_FS_MINIMIZE == 0 && !FF_FS_READONLY
FRESULT result;
FATFS *fat = NULL;
INT vol, ret;
char *f_path = NULL;
unsigned char attr;
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;
f_path = (char *)dpal_malloc(MAX_LFNAME_LENTH);
if (f_path == NULL)
return -ENOMEM;
ret = snprintf_s(f_path, MAX_LFNAME_LENTH, MAX_LFNAME_LENTH - 1, "%d:%s", vol, relpath);
if (ret < 0) {
dpal_free(f_path);
return -EINVAL;
}
result = f_chmod(f_path, attr, 0xff);
dpal_free(f_path);
if (result == FR_OK)
return fatfs_sd_sync(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 || 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 b_status)
{
if (b_status != FAT_SYSTEM_TIME_ENABLE && b_status != FAT_SYSTEM_TIME_DISABLE)
return -EINVAL;
f_settimestatus(b_status);
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 CONFIG_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 CONFIG_FS_FAT_CACHE
if (res == FR_OK) {
fat = (FATFS *)filep->f_inode->i_private;
FAT_CHECK(fat);
return fatfs_sd_sync(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 CONFIG_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 CONFIG_FS_FAT_CACHE
if (res == FR_OK) {
fat = (FATFS *)filep->f_inode->i_private;
FAT_CHECK(fat);
return fatfs_sd_sync(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 fatfs_timemin(const DIR_FILE dir_file[])
{
INT min = 0;
DWORD tm_min = 0;
MIN((dir_file[0].fno.fdate << DATE_OFFSET | dir_file[0].fno.ftime),
(dir_file[1].fno.fdate << DATE_OFFSET | dir_file[1].fno.ftime), tm_min);
MIN((DWORD)(dir_file[2].fno.fdate << DATE_OFFSET | dir_file[2].fno.ftime), tm_min, tm_min);
if (tm_min == (dir_file[0].fno.fdate << DATE_OFFSET | dir_file[0].fno.ftime)) {
min = 0;
} else if (tm_min == (dir_file[1].fno.fdate << DATE_OFFSET | dir_file[1].fno.ftime)) {
min = 1;
} else if (tm_min == (dir_file[2].fno.fdate << DATE_OFFSET | dir_file[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 *f_dir = NULL;
FILINFO fno;
FRESULT result;
INT count = 0;
INT time_oldest = 0;
DIR dir_backup = {0};
DIR_FILE dir_file[CHECK_FILE_NUM] = {0};
INT loop = CHECK_FILE_NUM;
#ifdef CONFIG_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;
f_dir = (DIR *)(dir->u.fs_dir);
if ((f_dir->obj.fs)->fs_type != FS_FAT32) {
(void)fatfs_closedir(mountpt, dir);
return -EINVAL;
}
do {
(void)memcpy_s(&dir_backup, sizeof(DIR), f_dir, sizeof(DIR));
result = f_readdir(f_dir, &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(&dir_file[0].f_dir, sizeof(DIR), &dir_backup, sizeof(DIR));
(void)memcpy_s(&dir_file[0].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
} else if (count == 1) {
(void)memcpy_s(&dir_file[1].f_dir, sizeof(DIR), &dir_backup, sizeof(DIR));
(void)memcpy_s(&dir_file[1].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
} else if (count == 2) { /* check the latest three files */
(void)memcpy_s(&dir_file[2].f_dir, sizeof(DIR), &dir_backup, sizeof(DIR));
(void)memcpy_s(&dir_file[2].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
time_oldest = fatfs_timemin(dir_file);
} else {
if ((fno.fdate << DATE_OFFSET | fno.ftime) >
(dir_file[time_oldest].fno.fdate << DATE_OFFSET | dir_file[time_oldest].fno.ftime)) {
(void)memcpy_s(&dir_file[time_oldest].f_dir, sizeof(DIR), &dir_backup, sizeof(DIR));
(void)memcpy_s(&dir_file[time_oldest].fno, sizeof(FILINFO), &fno, sizeof(FILINFO));
time_oldest = fatfs_timemin(dir_file);
}
}
count++;
} while (result == FR_OK);
if (count < loop)
loop = count;
ret = fatfs_closedir(mountpt, dir);
if (ret != FR_OK)
return ret;
for (count = 0; count < loop; count++) {
result = f_fcheckfat(&dir_file[count]);
if (result != FR_OK)
return fatfs_2_vfs(result);
}
#ifdef CONFIG_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) {
if (OsSdSync(part->disk_id) != ENOERR) {
return -EIO;
}
}
#endif
return ENOERR;
}
int fatfs_virstatfs(struct inode *mountpt, const char *relpath, struct statfs *buf)
{
#ifdef CONFIG_FS_FAT_VIRTUAL_PARTITION
return fatfs_virstatfs_internel(mountpt, relpath, buf);
#else
return 0;
#endif
}
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
#endif /* CONFIG_FS_FAT */
Reference in New Issue View Git Blame Copy Permalink