bl_mcu_sdk/components/fatfs/fatfs_posix_api.c

/**
 * @file fatfs_posix_api.c
 * @brief
 *
 * Copyright (c) 2021 Bouffalolab team
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 */

/**
 * @brief POSIX Common File System Interface,
 *        Based on the fatfs.
 *        Only part of the interface is implemented
 */

#include "fatfs_posix_api.h"
#include "ff.h"
#include "stdlib.h"

/*Memory request interface*/
static void *(*vfs_malloc)(size_t size) = mmheap_alloc; //默认的内存申请接口
static void (*vfs_free)(void *ptr) = mmheap_free;       //默认的内存释放接口

/**
 * @brief fs init
 *
 * @return  0 on successful, -1 on failed.
 */
int ff_vfs_init(void)
{
    return 0;
}

/**
 * @brief FATF error conversion,Used for compatible Linux system error codes
 *
 * @param Status
 * @return int
 */
int ff_vfs_error(FRESULT Status)
{
    switch (Status) {
        case FR_OK:
            return 0;
        case FR_DISK_ERR:
            return -EIO; /* (1) A hard error occurred in the low level disk I/O layer */
        case FR_INT_ERR:
            return -EPIPE; /* (2) Assertion failed */
        case FR_NOT_READY:
            return -EIO; /* (3) The physical drive cannot work */
        case FR_NO_FILE:
            return -ENOENT; /* (4) Could not find the file */
        case FR_NO_PATH:
            return -ENOENT; /* (5) Could not find the path */
        case FR_INVALID_NAME:
            return -ENOEXEC; /* (6) The path name format is invalid */
        case FR_DENIED:
            return -ENOSPC; /* (7) Access denied due to prohibited access or directory full */
        case FR_EXIST:
            return -EACCES; /* (8) Access denied due to prohibited access */
        case FR_INVALID_OBJECT:
            return -ENXIO; /* (9) The file/directory object is invalid */
        case FR_WRITE_PROTECTED:
            return -EROFS; /* (10) The physical drive is write protected */
        case FR_INVALID_DRIVE:
            return -ENXIO; /* (11) The logical drive number is invalid */
        case FR_NOT_ENABLED:
            return -ENXIO; /* (12) The volume has no work area */
        case FR_NO_FILESYSTEM:
            return -EPERM; /* (13) There is no valid FAT volume */
        case FR_MKFS_ABORTED:
            return -EPERM; /* (14) The f_mkfs() aborted due to any problem */
        case FR_TIMEOUT:
            return -EBUSY; /* (15) Could not get a grant to access the volume within defined period */
        case FR_LOCKED:
            return -EACCES; /* (16) The operation is rejected according to the file sharing policy */
        case FR_NOT_ENOUGH_CORE:
            return -ENOMEM; /* (17) LFN working buffer could not be allocated */
        case FR_TOO_MANY_OPEN_FILES:
            return -EMFILE; /* (18) Number of open files > FF_FS_LOCK */
        case FR_INVALID_PARAMETER:
            return -EINVAL; /* (19) Given parameter is invalid */
        default:
            return -EPERM;
    }
}

/**
 * @brief Open the file described in PATH
 *
 * @param path The file path
 * @param flags The file's parameters:
 *          O_RDONLY:   read-only
 *          O_WRONLY:   write-only
 *          O_RDWR:     readable and writable
 *          O_CREAT:    Create a file when it doesn't exist
 *          O_EXCL:     When the file is opened, returned -EEXIST if the file exists and the flag bit O_CREAT is also specified.
 *                      If the file does not exist, the file is created
 *          O_TRUNC:    When opening the file, if the length of the file is not 0, the length of the file will be truncated to 0,
 *                      and the next time the file is written, the data will be written from the file
 *          O_APPEND:   After opening the file, set the write point of the file to the end of the file. The next time the file is written,
 *                      the newly written data will be appended to the end of the file
 * @param mode The permissions, not currently supported, ignored
 * @return int Positive: File descriptor (actually a pointer); Negative: Error execution, return error code
 */
int ff_open(const char *path, int flags, int mode)
{
    uint8_t OpenMode = 0;
    FIL *pFile;
    FRESULT Status;

    pFile = (FIL *)vfs_malloc(sizeof(FIL));
    if (pFile == NULL) {
        return -ENOMEM;
    }

    if (flags & O_WRONLY) {
        OpenMode |= FA_WRITE;
    }
    if (flags & O_RDWR) {
        OpenMode |= FA_WRITE | FA_READ;
    }
    if ((OpenMode & (FA_WRITE | FA_READ)) == 0) /*If no read-write is specified, the default is read-only*/
    {
        OpenMode |= FA_READ;
    }
    if ((flags & O_CREAT) && (flags & O_EXCL)) {
        OpenMode |= FA_CREATE_NEW;
    } else if (flags & O_CREAT) {
        OpenMode |= FA_OPEN_ALWAYS;
    }
    if (flags & O_TRUNC) {
        OpenMode |= FA_CREATE_ALWAYS;
    }
    if (flags & O_APPEND) {
        OpenMode |= FA_OPEN_APPEND;
    }

    Status = f_open(pFile, path, OpenMode);
    if (Status != FR_OK) {
        vfs_free(pFile);
        pFile = NULL;

        if ((flags & O_CREAT) && (flags & O_EXCL) && (Status == FR_EXIST)) {
            return -EEXIST;
        }
        return ff_vfs_error(Status);
    }

    return (int)pFile;
}

/**
 * @brief Close the file
 *
 * @param fd The descriptor of the file
 * @return int 0: success; Negative: Error execution, return error code
 */
int ff_close(int fd)
{
    FRESULT Status;

    if (fd <= 0)
        return -ENXIO;
    Status = f_close((FIL *)fd);
    if (Status == FR_OK) {
        vfs_free((void *)fd);
    }

    return ff_vfs_error(Status);
}

/**
 * @brief Read file data
 *
 * @param fd    The descriptor of the file
 * @param buf   The cache of data read by the file
 * @param nbytes Number of bytes to read
 * @return int  Read successfully, return the number of bytes read;
 *              Returns 0 if the file offset reached the end of the file when it was read.
 *              Other error conditions, return the error code
 */
int ff_read(int fd, void *buf, size_t nbytes)
{
    FRESULT Status;
    UINT cnt;

    if (fd <= 0)
        return -ENXIO;
    Status = f_read((FIL *)fd, buf, nbytes, (UINT *)&cnt);
    if (Status != FR_OK) {
        return ff_vfs_error(Status);
    }
    return cnt;
}

/**
 * @brief Writes data to a file
 *
 * @param fd    The descriptor of the file
 * @param buf   The cache of data to write to the file
 * @param nbytes The length of the file written
 * @return int  When successfully written, the number of bytes written to the file is returned.
 *              The actual number of bytes written may be less than nbytes (insufficient file space).
 *              Returns an error code (negative) when writing fails
 */
int ff_write(int fd, const void *buf, size_t nbytes)
{
    FRESULT Status;
    UINT cnt;

    if (fd <= 0)
        return -ENXIO;
    Status = f_write((FIL *)fd, buf, nbytes, (UINT *)&cnt);
    if (Status != FR_OK) {
        return ff_vfs_error(Status);
    }
    return cnt;
}

/**
 * @brief Resets the offset of the open file
 *
 * @param fd        The descriptor of the file
 * @param offset    Offset from the third parameter whence
 * @param whence    File offset basics
 *                  VFS_SEEK_SET: Based on file headers
 *                  VFS_SEEK_CUR: Based on the current location
 *                  VFS_SEEK_END: Based on file end
 * @return ff_off_t    Non-negative: on success, returns the number of offset bytes relative to the start of the file;
 *                  Negative: Failure, return error code
 */
ff_off_t ff_lseek(int fd, ff_off_t offset, int whence)
{
    FRESULT Status;
    long long temp;

    if (fd <= 0)
        return -ENXIO;

    switch (whence) {
        case VFS_SEEK_SET: {
            Status = f_lseek((FIL *)fd, offset);
            if (Status == FR_OK) {
                return (ff_off_t)((FIL *)fd)->fptr;
            }
            return ff_vfs_error(Status);
        }
        case VFS_SEEK_CUR: {
            temp = (ff_off_t)((FIL *)fd)->fptr;
            temp += offset;
            if (temp >= 0xffffffff)
                temp = 0xffffffff - 1;
            Status = f_lseek((FIL *)fd, temp);
            if (Status == FR_OK) {
                return (ff_off_t)((FIL *)fd)->fptr;
            }
            return ff_vfs_error(Status);
        }
        case VFS_SEEK_END: {
            temp = (ff_off_t)((FIL *)fd)->obj.objsize;
            temp -= offset;
            if (temp <= 0)
                temp = 0;
            Status = f_lseek((FIL *)fd, temp);
            if (Status == FR_OK) {
                return (ff_off_t)((FIL *)fd)->fptr;
            }
            return ff_vfs_error(Status);
        }
        default:
            return -EINVAL;
    }
}

/**
 * @brief Update the cache to memory
 *
 * @param fd    The descriptor of the file
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_sync(int fd)
{
    FRESULT Status;

    if (fd <= 0)
        return -ENXIO;           //文件指针为空,直接返回
    Status = f_sync((FIL *)fd);  //存储文件
    return ff_vfs_error(Status); //错误代码转义
}

/**
 * @brief Get the attributes of the file(path)
 *
 * @param path  The file path
 * @param st    Pointer to file status information structure
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_stat(const char *path, struct stat *st)
{
    FRESULT Status;
    FILINFO *pInfo;

    if (path == NULL || st == NULL) {
        return -EINVAL;
    }
    pInfo = vfs_malloc(sizeof(FILINFO));
    if (pInfo == NULL) {
        return -ENOMEM;
    }
    Status = f_stat(path, pInfo);
    if (Status == FR_OK) {
        st->st_size = pInfo->fsize;
        st->st_mode = pInfo->fattrib;
        st->st_actime = 0;
        st->st_modtime = 0;
    }
    vfs_free(pInfo);
    return ff_vfs_error(Status);
}

/**
 * @brief Get the property information of the file
 *
 * @param fd    The descriptor of the file
 * @param st    Pointer to file status information structure
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_fstat(int fd, struct stat *st)
{
    if (fd <= 0)
        return -ENXIO;
    if (st == NULL)
        return -EINVAL;

    st->st_size = ((FIL *)fd)->obj.objsize;
    st->st_mode = 0777;
    st->st_actime = 0;
    st->st_modtime = 0;

    return 0;
}

/**
 * @brief Checks whether the current program has access to PATH
 *
 * @param path  The descriptor of the file
 * @param amode The permissions, not currently supported, ignored
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_access(const char *path, int amode)
{
    struct stat st;

    return ff_stat(path, &st);
}

/**
 * @brief Retutn the current working directory,
 *        If the buf parameter is not empty, the current working directory string is also copied into the buf
 *
 * @param buf       Path string buffer
 * @param size      Path buffer size
 * @return char*    Path string buffer
 */
char *ff_getcwd(char *buf, size_t size)
{
    FRESULT Status;

    if (buf == NULL || size == 0) {
        return NULL;
    }

    Status = f_getcwd(buf, size);
    if (Status == FR_OK) {
        return buf;
    } else {
    }

    return NULL;
}

/*************************************************************************************************************************
* 函数			:	int ff_ftruncate(int fd, ff_off_t  length)
* 功能			:	指定文件大小
* 参数			:	fd:已经打开的文件描述符，必须由写入权限；length：指定的文件大小
* 返回			:	0：成功；负数：返回错误码
* 依赖			:	FATFS
* 作者			:	cp1300@139.com
* 时间			:	2020-09-29
* 最后修改时间 	: 	2020-09-29
* 说明			:
*************************************************************************************************************************/
/**
 * @brief
 *
 * @param fd        Specify file size,Automatically truncate or fill
 * @param length    File descriptor that is already open. Must have write permission
 * @return int      0: success;
 *                  Negative: Data synchronization failure, return error code
 */
int ff_ftruncate(int fd, ff_off_t length)
{
    FRESULT Status;
    UINT cnt;
    uint32_t PackCnt;
    uint16_t EndPackSize;
    uint8_t *pBuff;
    uint32_t i;

    if (fd <= 0)
        return -ENXIO;
    if (length <= ((FIL *)fd)->obj.objsize) {
        Status = f_lseek((FIL *)fd, length);
        if (Status == FR_OK) {
            Status = f_truncate((FIL *)fd);
            if (Status == FR_OK) {
                return 0;
            } else {
            }
        } else {
        }
        return ff_vfs_error(Status);
    } else {
        Status = f_lseek((FIL *)fd, ((FIL *)fd)->obj.objsize);
        if (Status == FR_OK) {
            PackCnt = (length - ((FIL *)fd)->obj.objsize) / 512;
            EndPackSize = (length - ((FIL *)fd)->obj.objsize) % 512;
            pBuff = vfs_malloc(512);
            if (pBuff == NULL) {
                return -ENOMEM;
            }
            memset(pBuff, 0, 512);

            for (i = 0; i < PackCnt; i++) {
                Status = f_write((FIL *)fd, pBuff, 512, (UINT *)&cnt);
                if (Status != FR_OK) {
                    break;
                }
            }
            if ((Status == FR_OK) && EndPackSize) {
                Status = f_write((FIL *)fd, pBuff, EndPackSize, (UINT *)&cnt);
                if (Status != FR_OK) {
                }
            }
            vfs_free(pBuff);
        } else {
        }
    }

    return ff_vfs_error(Status);
}

/**
 * @brief
 *
 * @param fd
 * @param cmd
 * @param lock
 * @return int
 */
int ff_fcntl(int fd, int cmd, struct flock *lock)
{
    if (fd <= 0)
        return -ENXIO; //文件指针为空,直接返回

    return 0;
}

/**
 * @brief           Change access to existing files
 *
 * @param fd        The file descriptor
 * @param mode
 * @return int
 */
int ff_fchmod(int fd, ff_mode_t mode)
{
    if (fd <= 0)
        return -ENXIO; //文件指针为空,直接返回

    return 0;
}

/**
 * @brief   Delete the file
 *
 * @param path  The file path
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_unlink(const char *path)
{
    FRESULT Status;
    FILINFO *pInfo;

    if (path == NULL)
        return -ENXIO;
    pInfo = vfs_malloc(sizeof(FILINFO));
    if (pInfo == NULL) {
        return -ENOMEM;
    }

    Status = f_stat(path, pInfo);
    if (Status == FR_OK) {
        Status = f_unlink(path);
        if (Status != FR_OK) {
        }
    } else {
    }
    vfs_free(pInfo);

    return ff_vfs_error(Status);
}

/**
 * @brief Create a directory, If it already exists, the creation fails
 *
 * @param path  The directory path
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_mkdir(const char *path)
{
    FRESULT Status;

    if (path == NULL)
        return -ENXIO;
    Status = f_mkdir(path);

    return ff_vfs_error(Status);
}

/**
 * @brief   Delete a directory,When you delete a directory, the directory must be empty
 *
 * @param path  Directory path
 * @return int  0: success;
 *              Negative: Data synchronization failure, return error code
 */
int ff_rmdir(const char *path)
{
    FRESULT Status;
    FILINFO *pInfo;

    if (path == NULL)
        return -ENXIO;
    pInfo = vfs_malloc(sizeof(FILINFO));
    if (pInfo == NULL) {
        return -ENOMEM;
    }

    Status = f_stat(path, pInfo);
    if (Status == FR_INVALID_NAME) {
        Status = f_unlink(path);
        if (Status != FR_OK) {
        }
    } else {
        if (Status != FR_OK) {
        } else {
            vfs_free(pInfo);
            return -ENOTDIR;
        }
    }
    vfs_free(pInfo);

    return ff_vfs_error(Status);
}

/**
 * @brief
 *
 * @param fd
 * @param owner
 * @param group
 * @return int
 */

int ff_fchown(int fd, ff_uid_t owner, ff_gid_t group)
{
    return 0;
}

/**
 * @brief
 *
 * @return ff_uid_t
 */
ff_uid_t ff_geteuid(void)
{
    return 0;
}

/**
 * @brief
 *
 * @param path
 * @param times
 * @return int
 */
int ff_utimes(const char *path, const struct ff_timeval times[2])
{
    return 0;
}