1424 lines
32 KiB
C
Executable File
1424 lines
32 KiB
C
Executable File
/*
|
|
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
|
* Copyright (c) 2020-2021 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 "ff.h"
|
|
#if FF_USE_EXPAND
|
|
#define _GNU_SOURCE
|
|
#endif
|
|
#include "fatfs.h"
|
|
#include "errno.h"
|
|
#include "limits.h"
|
|
#include "pthread.h"
|
|
#include "time.h"
|
|
#include "securec.h"
|
|
#include "los_compiler.h"
|
|
#include "los_debug.h"
|
|
#include "cmsis_os.h"
|
|
|
|
#define FS_SUCCESS 0
|
|
#define FS_FAILURE (-1)
|
|
/* the max name length of different parts should not bigger than 32 */
|
|
#define FS_DRIVE_NAME_MAX_LEN 32
|
|
|
|
#ifndef FAT_MAX_OPEN_DIRS
|
|
#define FAT_MAX_OPEN_DIRS 8
|
|
#endif /* FAT_MAX_OPEN_DIRS */
|
|
|
|
#ifndef FS_LOCK_TIMEMOUT_SEC
|
|
#define FS_LOCK_TIMEMOUT_SEC 15
|
|
#endif /* FS_LOCK_TIMEMOUT_SEC */
|
|
|
|
#define PART_NAME 0x0
|
|
#define VOLUME_NAME 0x1
|
|
#define PATH_NAME 0x2
|
|
#define NAME_MASK 0x3
|
|
|
|
typedef struct {
|
|
UINT8 useFlag;
|
|
FIL fil;
|
|
} FatHandleStruct;
|
|
|
|
static FatHandleStruct g_handle[FAT_MAX_OPEN_FILES] = {0};
|
|
static DIR g_dir[FAT_MAX_OPEN_DIRS] = {0};
|
|
static FATFS g_fatfs[FF_VOLUMES] = {0};
|
|
static UINT8 g_workBuffer[FF_MAX_SS];
|
|
static UINT32 g_fileNum = 0;
|
|
static UINT32 g_dirNum = 0;
|
|
static struct dirent g_retValue;
|
|
static pthread_mutex_t g_fsMutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
static const char * const g_volPath[FF_VOLUMES] = {FF_VOLUME_STRS};
|
|
static BOOL g_volWriteEnable[FF_VOLUMES] = {FALSE};
|
|
|
|
static int FsLock(void)
|
|
{
|
|
INT32 ret = 0;
|
|
struct timespec absTimeout = {0};
|
|
if (osKernelGetState() != osKernelRunning) {
|
|
return ret;
|
|
}
|
|
ret = clock_gettime(CLOCK_REALTIME, &absTimeout);
|
|
if (ret != 0) {
|
|
PRINTK("clock gettime err 0x%x!\r\n", errno);
|
|
return errno;
|
|
}
|
|
absTimeout.tv_sec += FS_LOCK_TIMEMOUT_SEC;
|
|
ret = pthread_mutex_timedlock(&g_fsMutex, &absTimeout);
|
|
return ret;
|
|
}
|
|
|
|
static void FsUnlock(void)
|
|
{
|
|
if (osKernelGetState() != osKernelRunning) {
|
|
return;
|
|
}
|
|
(void)pthread_mutex_unlock(&g_fsMutex);
|
|
}
|
|
|
|
static bool IsValidFd(int fd)
|
|
{
|
|
if ((fd < 0) || (fd >= FAT_MAX_OPEN_FILES) || (g_handle[fd].useFlag == 0)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static int FsChangeDrive(const char *path)
|
|
{
|
|
INT32 res;
|
|
CHAR tmpPath[FS_DRIVE_NAME_MAX_LEN] = { "/" }; /* the max name length of different parts is 16 */
|
|
errno_t retErr;
|
|
UINT16 pathLen;
|
|
pathLen = strlen((char const *)path);
|
|
/* make sure the path begin with "/", the path like /xxx/yyy/... */
|
|
if (pathLen >= (FS_DRIVE_NAME_MAX_LEN - 1)) {
|
|
/* 2: except first flag "/" and last end flag */
|
|
pathLen = FS_DRIVE_NAME_MAX_LEN - 2;
|
|
}
|
|
|
|
retErr = strncpy_s(tmpPath + 1, (FS_DRIVE_NAME_MAX_LEN - 1), (char const *)path, pathLen);
|
|
if (retErr != EOK) {
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
res = f_chdrive(tmpPath);
|
|
if (res != FR_OK) {
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
static int FsPartitionMatch(const char *path, int flag)
|
|
{
|
|
INT32 ret;
|
|
UINT32 index;
|
|
CHAR tmpName[FF_MAX_LFN] = {0};
|
|
|
|
if (path == NULL) {
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
switch ((UINT32)flag & NAME_MASK) {
|
|
case VOLUME_NAME:
|
|
ret = sscanf_s(path, "/%[^/]", tmpName, FF_MAX_LFN);
|
|
if (ret <= 0) {
|
|
return FS_FAILURE;
|
|
}
|
|
break;
|
|
case PATH_NAME:
|
|
ret = sscanf_s(path, "%[^/]", tmpName, FF_MAX_LFN);
|
|
if (ret <= 0) {
|
|
return FS_FAILURE;
|
|
}
|
|
break;
|
|
case PART_NAME:
|
|
default:
|
|
ret = strcpy_s(tmpName, FF_MAX_LFN, path);
|
|
if (ret != EOK) {
|
|
return FS_FAILURE;
|
|
}
|
|
}
|
|
|
|
for (index = 0; index < FF_VOLUMES; index++) {
|
|
if (strcmp(tmpName, g_volPath[index]) == 0) {
|
|
return index;
|
|
}
|
|
}
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
static int Remount(const char *path, unsigned long mountflags)
|
|
{
|
|
INT32 index;
|
|
|
|
index = FsPartitionMatch(path, PART_NAME);
|
|
if (index == FS_FAILURE) {
|
|
PRINTK("Wrong volume path!\r\n");
|
|
errno = ENOENT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
/* remount is not allowed when the device is not mounted. */
|
|
if (g_fatfs[index].fs_type == 0) {
|
|
errno = EINVAL;
|
|
return FS_FAILURE;
|
|
}
|
|
g_volWriteEnable[index] = (mountflags & MS_RDONLY) ? FALSE : TRUE;
|
|
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
static bool FsCheckByPath(const char *path)
|
|
{
|
|
INT32 index;
|
|
|
|
index = FsPartitionMatch(path, PATH_NAME);
|
|
if (index == FS_FAILURE) {
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
return g_volWriteEnable[index];
|
|
}
|
|
|
|
static bool FsCheckByID(int id)
|
|
{
|
|
INT32 index;
|
|
|
|
for (index = 0; index < FF_VOLUMES; index++) {
|
|
if (g_fatfs[index].id == id) {
|
|
return g_volWriteEnable[index];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static unsigned int FatFsGetMode(int oflags)
|
|
{
|
|
UINT32 fmode = FA_READ;
|
|
|
|
if ((UINT32)oflags & O_WRONLY) {
|
|
fmode |= FA_WRITE;
|
|
}
|
|
|
|
if (((UINT32)oflags & O_ACCMODE) & O_RDWR) {
|
|
fmode |= FA_WRITE;
|
|
}
|
|
/* Creates a new file if the file is not existing, otherwise, just open it. */
|
|
if ((UINT32)oflags & O_CREAT) {
|
|
fmode |= FA_OPEN_ALWAYS;
|
|
/* Creates a new file. If the file already exists, the function shall fail. */
|
|
if ((UINT32)oflags & O_EXCL) {
|
|
fmode |= FA_CREATE_NEW;
|
|
}
|
|
}
|
|
/* Creates a new file. If the file already exists, its length shall be truncated to 0. */
|
|
if ((UINT32)oflags & O_TRUNC) {
|
|
fmode |= FA_CREATE_ALWAYS;
|
|
}
|
|
|
|
return fmode;
|
|
}
|
|
|
|
static int FatfsErrno(int result)
|
|
{
|
|
INT32 status = 0;
|
|
|
|
if (result < 0) {
|
|
return result;
|
|
}
|
|
|
|
/* 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;
|
|
default:
|
|
status = result;
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int fatfs_mount(const char *source, const char *target,
|
|
const char *filesystemtype, unsigned long mountflags,
|
|
const void *data)
|
|
{
|
|
INT32 index;
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if ((target == NULL) || (filesystemtype == NULL)) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (mountflags & MS_REMOUNT) {
|
|
ret = Remount(target, mountflags);
|
|
goto OUT;
|
|
}
|
|
|
|
if (strcmp(filesystemtype, "fat") != 0) {
|
|
errno = ENODEV;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
index = FsPartitionMatch(target, VOLUME_NAME);
|
|
if (index == FS_FAILURE) {
|
|
errno = ENODEV;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* If the volume has been mounted */
|
|
if (g_fatfs[index].fs_type != 0) {
|
|
errno = EBUSY;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_mount(&g_fatfs[index], target, 1);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
g_volWriteEnable[index] = (mountflags & MS_RDONLY) ? FALSE : TRUE;
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_umount(const char *target)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
INT32 index;
|
|
|
|
if (target == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
index = FsPartitionMatch(target, VOLUME_NAME);
|
|
if (index == FS_FAILURE) {
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* The volume is not mounted */
|
|
if (g_fatfs[index].fs_type == 0) {
|
|
errno = EINVAL;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* umount is not allowed when a file or diretory is opened. */
|
|
if (f_checkopenlock(index) != FR_OK) {
|
|
errno = EBUSY;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_mount((FATFS *)NULL, target, 0);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
if (g_fatfs[index].win != NULL) {
|
|
ff_memfree(g_fatfs[index].win);
|
|
}
|
|
|
|
(void)memset_s(&g_fatfs[index], sizeof(FATFS), 0x0, sizeof(FATFS));
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
static int CloseAll(int index)
|
|
{
|
|
INT32 i;
|
|
FRESULT res;
|
|
|
|
for (i = 0; i < FAT_MAX_OPEN_FILES; i++) {
|
|
if (g_fileNum <= 0) {
|
|
break;
|
|
}
|
|
if ((g_handle[i].useFlag == 1) && (g_handle[i].fil.obj.fs == &g_fatfs[index])) {
|
|
res = f_close(&g_handle[i].fil);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
return FS_FAILURE;
|
|
}
|
|
(void)memset_s(&g_handle[i], sizeof(FatHandleStruct), 0x0, sizeof(FatHandleStruct));
|
|
g_fileNum--;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < FAT_MAX_OPEN_DIRS; i++) {
|
|
if (g_dirNum <= 0) {
|
|
break;
|
|
}
|
|
if (g_dir[i].obj.fs == &g_fatfs[index]) {
|
|
res = f_closedir(&g_dir[i]);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
return FS_FAILURE;
|
|
}
|
|
(void)memset_s(&g_dir[i], sizeof(DIR), 0x0, sizeof(DIR));
|
|
g_dirNum--;
|
|
}
|
|
}
|
|
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
int fatfs_umount2(const char *target, int flag)
|
|
{
|
|
INT32 index;
|
|
INT32 ret;
|
|
UINT32 flags;
|
|
FRESULT res;
|
|
|
|
if (target == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
flags = MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW;
|
|
if ((UINT32)flag & ~flags) {
|
|
errno = EINVAL;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
index = FsPartitionMatch(target, VOLUME_NAME);
|
|
if (index == FS_FAILURE) {
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* The volume is not mounted */
|
|
if (g_fatfs[index].fs_type == 0) {
|
|
errno = EINVAL;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
if ((UINT32)flag & MNT_FORCE) {
|
|
ret = CloseAll(index);
|
|
if (ret != FS_SUCCESS) {
|
|
goto OUT;
|
|
}
|
|
}
|
|
|
|
res = f_mount((FATFS *)NULL, target, 0);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
if (g_fatfs[index].win != NULL) {
|
|
ff_memfree(g_fatfs[index].win);
|
|
}
|
|
|
|
(void)memset_s(&g_fatfs[index], sizeof(FATFS), 0x0, sizeof(FATFS));
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_open(const char *path, int oflag, ...)
|
|
{
|
|
FRESULT res;
|
|
UINT32 i;
|
|
UINT32 openNum = 0;
|
|
UINT32 fmode;
|
|
INT32 ret;
|
|
FILINFO fileInfo = {0};
|
|
|
|
if (path == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
fmode = FatFsGetMode(oflag);
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (g_fileNum >= FAT_MAX_OPEN_FILES) {
|
|
PRINTK("FAT g_fileNum is out of range 0x%x!\r\n", g_fileNum);
|
|
errno = ENFILE;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
for (i = 0; i < FAT_MAX_OPEN_FILES; i++) {
|
|
if (g_handle[i].useFlag == 0) {
|
|
openNum = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= FAT_MAX_OPEN_FILES) {
|
|
PRINTK("FAT opennum is out of range 0x%x!\r\n", openNum);
|
|
errno = ENFILE;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT open ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* cannot creat a new file in the write protected part */
|
|
if ((((UINT32)oflag & O_CREAT) != 0) && (!FsCheckByPath(path))) {
|
|
res = f_stat(path, &fileInfo);
|
|
if ((res == FR_NO_FILE) || (res == FR_NO_PATH)) {
|
|
PRINTK("FAT creat err 0x%x!\r\n", res);
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
}
|
|
|
|
res = f_open(&g_handle[openNum].fil, path, fmode);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT open err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
g_handle[openNum].useFlag = 1;
|
|
g_fileNum++;
|
|
|
|
ret = openNum;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_close(int fd)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
res = f_close(&g_handle[fd].fil);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT close err 0x%x!\r\n", res);
|
|
FsUnlock();
|
|
errno = FatfsErrno(res);
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
#if !FF_FS_TINY
|
|
if (g_handle[fd].fil.buf != NULL) {
|
|
(void)ff_memfree(g_handle[fd].fil.buf);
|
|
}
|
|
#endif
|
|
|
|
(void)memset_s(&g_handle[fd], sizeof(FatHandleStruct), 0x0, sizeof(FatHandleStruct));
|
|
|
|
if (g_fileNum > 0) {
|
|
g_fileNum--;
|
|
}
|
|
|
|
FsUnlock();
|
|
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
ssize_t fatfs_read(int fd, void *buf, size_t nbyte)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
UINT32 lenRead;
|
|
|
|
if (buf == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
res = f_read(&g_handle[fd].fil, buf, nbyte, &lenRead);
|
|
if (res != FR_OK) {
|
|
FsUnlock();
|
|
errno = FatfsErrno(res);
|
|
return FS_FAILURE;
|
|
}
|
|
FsUnlock();
|
|
|
|
return (ssize_t)lenRead;
|
|
}
|
|
|
|
ssize_t fatfs_write(int fd, const void *buf, size_t nbyte)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
UINT32 lenWrite;
|
|
static BOOL overFlow = FALSE;
|
|
|
|
if (buf == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
|
|
errno = EACCES;
|
|
goto ERROUT;
|
|
}
|
|
res = f_write(&g_handle[fd].fil, buf, nbyte, &lenWrite);
|
|
if ((res == FR_OK) && (lenWrite == 0) && (nbyte != 0) && (overFlow == FALSE)) {
|
|
overFlow = TRUE;
|
|
PRINTK("FAT write err 0x%x!\r\n", fd);
|
|
}
|
|
if ((res != FR_OK) || (nbyte != lenWrite)) {
|
|
errno = FatfsErrno(res);
|
|
goto ERROUT;
|
|
}
|
|
|
|
FsUnlock();
|
|
return (ssize_t)lenWrite;
|
|
|
|
ERROUT:
|
|
FsUnlock();
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
off_t fatfs_lseek(int fd, off_t offset, int whence)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
off_t pos;
|
|
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (whence == SEEK_SET) {
|
|
pos = 0;
|
|
} else if (whence == SEEK_CUR) {
|
|
pos = f_tell(&g_handle[fd].fil);
|
|
} else if (whence == SEEK_END) {
|
|
pos = f_size(&g_handle[fd].fil);
|
|
} else {
|
|
errno = EINVAL;
|
|
goto ERROUT;
|
|
}
|
|
|
|
res = f_lseek(&g_handle[fd].fil, offset + pos);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
goto ERROUT;
|
|
}
|
|
|
|
pos = f_tell(&g_handle[fd].fil);
|
|
FsUnlock();
|
|
return pos;
|
|
|
|
ERROUT:
|
|
FsUnlock();
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
/* Remove the specified FILE */
|
|
int fatfs_unlink(const char *path)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (path == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByPath(path)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT ulink ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_unlink(path);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT ulink err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
/* Return information about a file */
|
|
int fatfs_fstat(int fd, struct stat *buf)
|
|
{
|
|
INT32 ret;
|
|
|
|
if (buf == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
buf->st_size = f_size(&g_handle[fd].fil);
|
|
buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
|
S_IWUSR | S_IWGRP | S_IWOTH |
|
|
S_IXUSR | S_IXGRP | S_IXOTH;
|
|
if (g_handle[fd].fil.obj.attr & AM_RDO) {
|
|
buf->st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
|
|
}
|
|
|
|
FsUnlock();
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
int fatfs_stat(const char *path, struct stat *buf)
|
|
{
|
|
FRESULT res;
|
|
FILINFO fileInfo = {0};
|
|
INT32 ret;
|
|
|
|
if ((path == NULL) || (buf == NULL)) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT stat ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
res = f_stat(path, &fileInfo);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT stat err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
buf->st_size = fileInfo.fsize;
|
|
buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
|
S_IWUSR | S_IWGRP | S_IWOTH |
|
|
S_IXUSR | S_IXGRP | S_IXOTH;
|
|
|
|
if (fileInfo.fattrib & AM_RDO) {
|
|
buf->st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
|
|
}
|
|
|
|
if (fileInfo.fattrib & AM_DIR) {
|
|
buf->st_mode &= ~S_IFREG;
|
|
buf->st_mode |= S_IFDIR;
|
|
}
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
/* Synchronize all changes to Flash */
|
|
int fatfs_fsync(int fd)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
res = f_sync(&g_handle[fd].fil);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_mkdir(const char *path, mode_t mode)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (path == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByPath(path)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT mkdir ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_mkdir(path);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT mkdir err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
DIR *fatfs_opendir(const char *dirName)
|
|
{
|
|
FRESULT res;
|
|
UINT32 openNum = 0;
|
|
UINT32 i;
|
|
INT32 ret;
|
|
|
|
if (dirName == NULL) {
|
|
errno = EFAULT;
|
|
return NULL;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return NULL;
|
|
}
|
|
|
|
if (g_dirNum >= FAT_MAX_OPEN_DIRS) {
|
|
PRINTK("FAT opendir g_dirNum err 0x%x!\r\n", g_dirNum);
|
|
errno = ENFILE;
|
|
goto ERROUT;
|
|
}
|
|
|
|
for (i = 0; i < FAT_MAX_OPEN_DIRS; i++) {
|
|
if (g_dir[i].dir == NULL) {
|
|
openNum = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= FAT_MAX_OPEN_DIRS) {
|
|
PRINTK("FAT dir opennum is out of range 0x%x!\r\n", openNum);
|
|
errno = ENFILE;
|
|
goto ERROUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(dirName);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT opendir ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
goto ERROUT;
|
|
}
|
|
|
|
res = f_opendir(&g_dir[openNum], dirName);
|
|
if (res != FR_OK) {
|
|
g_dir[openNum].dir = NULL;
|
|
PRINTK("FAT opendir err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
goto ERROUT;
|
|
}
|
|
|
|
g_dirNum++;
|
|
|
|
FsUnlock();
|
|
return &g_dir[openNum];
|
|
|
|
ERROUT:
|
|
FsUnlock();
|
|
return NULL;
|
|
}
|
|
|
|
struct dirent *fatfs_readdir(DIR *dir)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
FILINFO fileInfo = {0};
|
|
|
|
if (dir == NULL) {
|
|
errno = EBADF;
|
|
return NULL;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return NULL;
|
|
}
|
|
|
|
res = f_readdir(dir, &fileInfo);
|
|
/* if res not ok or fname is NULL , return NULL */
|
|
if ((res != FR_OK) || (fileInfo.fname[0] == 0x0)) {
|
|
PRINTK("FAT readdir err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
FsUnlock();
|
|
return NULL;
|
|
}
|
|
|
|
(void)memcpy_s(g_retValue.d_name, sizeof(g_retValue.d_name), fileInfo.fname, sizeof(g_retValue.d_name));
|
|
if (fileInfo.fattrib & AM_DIR) {
|
|
g_retValue.d_type = DT_DIR;
|
|
} else {
|
|
g_retValue.d_type = DT_REG;
|
|
}
|
|
FsUnlock();
|
|
|
|
return &g_retValue;
|
|
}
|
|
|
|
int fatfs_closedir(DIR *dir)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (dir == NULL) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
g_dirNum--;
|
|
|
|
res = f_closedir(dir);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT closedir err 0x%x!\r\n", res);
|
|
FsUnlock();
|
|
errno = FatfsErrno(res);
|
|
return FS_FAILURE;
|
|
}
|
|
dir->dir = NULL;
|
|
FsUnlock();
|
|
|
|
return FS_SUCCESS;
|
|
}
|
|
|
|
int fatfs_rmdir(const char *path)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (path == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByPath(path)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT rmdir ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_rmdir(path);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT rmdir err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_rename(const char *oldName, const char *newName)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if ((oldName == NULL) || (newName == NULL)) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByPath(oldName) || !FsCheckByPath(newName)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FsChangeDrive(oldName);
|
|
if (ret != FS_SUCCESS) {
|
|
PRINTK("FAT f_getfree ChangeDrive err 0x%x!\r\n", ret);
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_rename(oldName, newName);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT frename err 0x%x!\r\n", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_statfs(const char *path, struct statfs *buf)
|
|
{
|
|
FATFS *fs = NULL;
|
|
UINT32 freeClust;
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if ((path == NULL) || (buf == NULL)) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsChangeDrive(path);
|
|
if (ret != FR_OK) {
|
|
PRINTK("FAT f_getfree ChangeDrive err %d.", ret);
|
|
errno = FatfsErrno(FR_INVALID_PARAMETER);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_getfree(path, &freeClust, &fs);
|
|
if (res != FR_OK) {
|
|
PRINTK("FAT f_getfree err 0x%x.", res);
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
buf->f_bfree = freeClust;
|
|
buf->f_bavail = freeClust;
|
|
/* Cluster #0 and #1 is for VBR, reserve sectors and fat */
|
|
buf->f_blocks = fs->n_fatent - 2;
|
|
#if FF_MAX_SS != FF_MIN_SS
|
|
buf->f_bsize = fs->ssize * fs->csize;
|
|
#else
|
|
buf->f_bsize = FF_MIN_SS * fs->csize;
|
|
#endif
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
static int do_truncate(int fd, off_t length, UINT count)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret = FR_OK;
|
|
DWORD csz;
|
|
|
|
csz = (DWORD)(g_handle[fd].fil.obj.fs)->csize * SS(g_handle[fd].fil.obj.fs); /* Cluster size */
|
|
if (length > csz * count) {
|
|
#if FF_USE_EXPAND
|
|
res = f_expand(&g_handle[fd].fil, 0, (FSIZE_t)(length), FALLOC_FL_KEEP_SIZE);
|
|
#else
|
|
errno = ENOSYS;
|
|
ret = FS_FAILURE;
|
|
return ret;
|
|
#endif
|
|
} else if (length < csz * count) {
|
|
res = f_truncate(&g_handle[fd].fil, (FSIZE_t)length);
|
|
}
|
|
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
return ret;
|
|
}
|
|
|
|
g_handle[fd].fil.obj.objsize = length; /* Set file size to length */
|
|
g_handle[fd].fil.flag |= 0x40; /* Set modified flag */
|
|
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_ftruncate(int fd, off_t length)
|
|
{
|
|
FRESULT res;
|
|
INT32 ret;
|
|
UINT count;
|
|
DWORD fclust;
|
|
|
|
if (!IsValidFd(fd)) {
|
|
errno = EBADF;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if ((length < 0) || (length > UINT_MAX)) {
|
|
errno = EINVAL;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
|
|
errno = EACCES;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_getclustinfo(&g_handle[fd].fil, &fclust, &count);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = do_truncate(fd, length, count);
|
|
if (ret != FR_OK) {
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_fdisk(int pdrv, const unsigned int *partTbl)
|
|
{
|
|
INT32 index;
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (partTbl == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* fdisk is not allowed when the device has been mounted. */
|
|
for (index = 0; index < FF_VOLUMES; index++) {
|
|
if ((g_fatfs[index].pdrv == pdrv) && (g_fatfs[index].fs_type != 0)) {
|
|
errno = EBUSY;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
}
|
|
|
|
res = f_fdisk(pdrv, (DWORD const *)partTbl, g_workBuffer);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|
|
|
|
int fatfs_format(const char *dev, int sectors, int option)
|
|
{
|
|
INT32 index;
|
|
FRESULT res;
|
|
INT32 ret;
|
|
|
|
if (dev == NULL) {
|
|
errno = EFAULT;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
ret = FsLock();
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return FS_FAILURE;
|
|
}
|
|
|
|
index = FsPartitionMatch(dev, VOLUME_NAME);
|
|
if (index == FS_FAILURE) {
|
|
errno = ENOENT;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
/* format is not allowed when the device has been mounted. */
|
|
if (g_fatfs[index].fs_type != 0) {
|
|
errno = EBUSY;
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
res = f_mkfs(dev, option, sectors, g_workBuffer, FF_MAX_SS);
|
|
if (res != FR_OK) {
|
|
errno = FatfsErrno(res);
|
|
ret = FS_FAILURE;
|
|
goto OUT;
|
|
}
|
|
|
|
ret = FS_SUCCESS;
|
|
|
|
OUT:
|
|
FsUnlock();
|
|
return ret;
|
|
}
|