!174 m核上littlefs新增错误码功能

Merge pull request !174 from li_zan/master

components/fs/littlefs/lfs_api.c

@@ -222,7 +222,7 @@ int FreeMountRes(const char *target)
     return VFS_ERROR;
 }
 
-int ConvertFlagToLfsOpenFlag (int oflags)
+static int ConvertFlagToLfsOpenFlag (int oflags)
 {
     int lfsOpenFlag = 0;
 
@@ -257,6 +257,49 @@ int ConvertFlagToLfsOpenFlag (int oflags)
     return lfsOpenFlag;
 }
 
+static int LittlefsErrno(int result)
+{
+    int status = 0;
+
+    if (result < 0) {
+        return result;
+    }
+
+    switch (result) {
+        case LFS_ERR_OK:
+            break;
+        case LFS_ERR_NOTDIR:
+            status = ENOTDIR;
+            break;
+        case LFS_ERR_NOENT:
+            status = ENFILE;
+            break;
+        case LFS_ERR_EXIST:
+            status = EEXIST;
+            break;
+        case LFS_ERR_ISDIR:
+            status = EISDIR;
+            break;
+        case LFS_ERR_NOTEMPTY:
+            status = ENOTEMPTY;
+            break;
+        case LFS_ERR_INVAL:
+            status = EINVAL;
+            break;
+        case LFS_ERR_NOSPC:
+            status = ENOSPC;
+            break;
+        case LFS_ERR_IO:
+            status = EIO;
+            break;
+        default:
+            status = result;
+            break;
+    }
+
+    return status;
+}
+
 const struct MountOps g_lfsMnt = {
     .Mount = LfsMount,
     .Umount = LfsUmount,
@@ -286,16 +329,19 @@ int LfsMount(const char *source, const char *target, const char *fileSystemType,
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (target == NULL || fileSystemType == NULL || data == NULL) {
+        errno = EFAULT;
         ret = VFS_ERROR;
         goto errout;
     }
 
     if (strcmp(fileSystemType, "littlefs") != 0) {
+        errno = ENODEV;
         ret = VFS_ERROR;
         goto errout;
     }
 
     if (CheckPathIsMounted(target, &fileOpInfo)) {
+        errno = EBUSY;
         ret = VFS_OK;
         goto errout;
     }
@@ -303,6 +349,7 @@ int LfsMount(const char *source, const char *target, const char *fileSystemType,
     // select free mount resource
     fileOpInfo = AllocMountRes(target, &g_lfsFops);
     if (fileOpInfo == NULL) {
+        errno = ENODEV;
         ret = VFS_ERROR;
         goto errout;
     }
@@ -315,6 +362,10 @@ int LfsMount(const char *source, const char *target, const char *fileSystemType,
         }
     }
 
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
     return ret;
 errout:
     return ret;
@@ -327,15 +378,20 @@ int LfsUmount(const char *target)
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (target == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     fileOpInfo = GetMountRes(target, &mountIndex);
     if (fileOpInfo == NULL) {
+        errno = ENOENT;
         return VFS_ERROR;
     }
 
     ret = lfs_unmount(&(fileOpInfo->lfsInfo));
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
 
     (void)FreeMountResByIndex(mountIndex);
     return ret;
@@ -343,47 +399,72 @@ int LfsUmount(const char *target)
 
 int LfsUnlink(const char *fileName)
 {
+    int ret;
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (fileName == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (CheckPathIsMounted(fileName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
-    return lfs_remove(&(fileOpInfo->lfsInfo), fileName);
+    ret = lfs_remove(&(fileOpInfo->lfsInfo), fileName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    return ret;
 }
 
 int LfsMkdir(const char *dirName, mode_t mode)
 {
+    int ret;
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (dirName == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
-    return lfs_mkdir(&(fileOpInfo->lfsInfo), dirName);
+    ret = lfs_mkdir(&(fileOpInfo->lfsInfo), dirName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    return ret;
 }
 
 int LfsRmdir(const char *dirName)
 {
+    int ret;
+
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (dirName == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
-    return lfs_remove(&(fileOpInfo->lfsInfo), dirName);
+    ret = lfs_remove(&(fileOpInfo->lfsInfo), dirName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    return ret;
 }
 
 DIR *LfsOpendir(const char *dirName)
@@ -392,25 +473,30 @@ DIR *LfsOpendir(const char *dirName)
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (dirName == NULL) {
-        return VFS_ERROR;
+        errno = EFAULT;
+        goto errout;
     }
 
     if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
-        return VFS_ERROR;
+        errno = EACCES;
+        goto errout;
     }
 
     if (CheckDirIsOpen(dirName)) {
+        errno = EBUSY;
         goto errout;
     }
 
     FileDirInfo *dirInfo = GetFreeDir(dirName);
     if (dirInfo == NULL) {
+        errno = ENFILE;
         goto errout;
     }
 
     ret = lfs_dir_open(&(fileOpInfo->lfsInfo), (lfs_dir_t *)(&(dirInfo->dir)), dirName);
 
     if (ret != 0) {
+        errno = LittlefsErrno(ret);
         goto errout;
     }
 
@@ -430,6 +516,7 @@ struct dirent *LfsReaddir(DIR *dir)
     FileDirInfo *dirInfo = (FileDirInfo *)dir;
 
     if (dirInfo == NULL || dirInfo->lfsHandle == NULL) {
+        errno = EFAULT;
         return NULL;
     }
 
@@ -449,6 +536,10 @@ struct dirent *LfsReaddir(DIR *dir)
         return &g_nameValue;
     }
 
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
     return NULL;
 }
 
@@ -458,6 +549,7 @@ int LfsClosedir(const DIR *dir)
     FileDirInfo *dirInfo = (FileDirInfo *)dir;
 
     if (dirInfo == NULL || dirInfo->lfsHandle == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
@@ -465,6 +557,10 @@ int LfsClosedir(const DIR *dir)
 
     FreeDirInfo(dirInfo->dirName);
 
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
     return ret;
 }
 
@@ -476,25 +572,30 @@ int LfsOpen(const char *pathName, int openFlag, int mode)
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (pathName == NULL) {
+        errno = EFAULT;
         goto errout;
     }
 
     if (CheckPathIsMounted(pathName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         goto errout;
     }
     // if file is already open, return invalid fd
     if (CheckFileIsOpen(pathName)) {
+        errno = EBUSY;
         goto errout;
     }
 
     LittleFsHandleStruct *fsHandle = LfsAllocFd(pathName, &fd);
     if (fd == INVALID_FD) {
+        errno = ENFILE;
         goto errout;
     }
 
     int lfsOpenFlag = ConvertFlagToLfsOpenFlag(openFlag);
     err = lfs_file_open(&(fileOpInfo->lfsInfo), &(fsHandle->file), pathName, lfsOpenFlag);
     if (err != 0) {
+        errno = LittlefsErrno(err);
         goto errout;
     }
 
@@ -506,41 +607,63 @@ errout:
 
 int LfsRead(int fd, void *buf, unsigned int len)
 {
+    int ret;
     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0 || buf == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (g_handle[fd].lfsHandle == NULL) {
+        errno = EBADF;
         return VFS_ERROR;
     }
 
-    return lfs_file_read(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    ret = lfs_file_read(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+    return ret;
 }
 
 int LfsWrite(int fd, const void *buf, unsigned int len)
 {
+    int ret;
     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0 || buf == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (g_handle[fd].lfsHandle == NULL) {
+        errno = EBADF;
         return VFS_ERROR;
     }
 
-    return lfs_file_write(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    ret = lfs_file_write(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+    return ret;
 }
 
 int LfsSeek(int fd, off_t offset, int whence)
 {
+    int ret;
     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (g_handle[fd].lfsHandle == NULL) {
+        errno = EBADF;
         return VFS_ERROR;
     }
 
-    return lfs_file_seek(g_handle[fd].lfsHandle, &(g_handle[fd].file), offset, whence);
+    ret = lfs_file_seek(g_handle[fd].lfsHandle, &(g_handle[fd].file), offset, whence);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    return ret;
 }
 
 int LfsClose(int fd)
@@ -548,10 +671,12 @@ int LfsClose(int fd)
     int ret = VFS_ERROR;
 
     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0) {
+        errno = EFAULT;
         return ret;
     }
 
     if (g_handle[fd].lfsHandle == NULL) {
+        errno = EBADF;
         return VFS_ERROR;
     }
 
@@ -568,22 +693,34 @@ int LfsClose(int fd)
     }
     pthread_mutex_unlock(&g_FslocalMutex);
 
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
     return ret;    
 }
 
 int LfsRename(const char *oldName, const char *newName)
 {
+    int ret;
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (oldName == NULL || newName == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (CheckPathIsMounted(oldName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
-    return lfs_rename(&(fileOpInfo->lfsInfo), oldName, newName);
+    ret = lfs_rename(&(fileOpInfo->lfsInfo), oldName, newName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    return ret;
 }
 
 int LfsStat(const char *path, struct stat *buf)
@@ -593,16 +730,20 @@ int LfsStat(const char *path, struct stat *buf)
     struct FileOpInfo *fileOpInfo = NULL;
 
     if (path == NULL || buf == NULL) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (CheckPathIsMounted(path, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
     ret = lfs_stat(&(fileOpInfo->lfsInfo), path, &info);
     if (ret == 0) {
         buf->st_size = info.size;
+    } else {
+        errno = LittlefsErrno(ret);
     }
 
     return ret;    
@@ -610,14 +751,22 @@ int LfsStat(const char *path, struct stat *buf)
 
 int LfsFsync(int fd)
 {
+    int ret;
+
     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0) {
+        errno = EFAULT;
         return VFS_ERROR;
     }
 
     if (g_handle[fd].lfsHandle == NULL) {
+        errno = EACCES;
         return VFS_ERROR;
     }
 
-    return lfs_file_sync(g_handle[fd].lfsHandle, &(g_handle[fd].file));
+    ret = lfs_file_sync(g_handle[fd].lfsHandle, &(g_handle[fd].file));
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+    return ret;
 }
 

components/fs/littlefs/lfs_api.h

@@ -37,6 +37,7 @@
 #include "sys/stat.h"
 
 #include "dirent.h"
+#include "errno.h"
 #include "lfs.h"
 #include "lfs_util.h"
 #include "memory.h"