complete upgrade nffs to 1.0.0

Author: hathach

libraries/nffs/src/fs/disk/include/disk/disk.h

@@ -0,0 +1,56 @@
+/*
+ * 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.
+ */
+
+#ifndef __DISK_H__
+#define __DISK_H__
+
+#include <stddef.h>
+#include <inttypes.h>
+#include <os/queue.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DISK_EOK          0  /* Success */
+#define DISK_EHW          1  /* Error accessing storage medium */
+#define DISK_ENOMEM       2  /* Insufficient memory */
+#define DISK_ENOENT       3  /* No such file or directory */
+#define DISK_EOS          4  /* OS error */
+#define DISK_EUNINIT      5  /* File system not initialized */
+
+struct disk_ops {
+    int (*read)(uint8_t, uint32_t, void *, uint32_t);
+    int (*write)(uint8_t, uint32_t, const void *, uint32_t);
+    int (*ioctl)(uint8_t, uint32_t, void *);
+
+    SLIST_ENTRY(disk_ops) sc_next;
+};
+
+int disk_register(const char *disk_name, const char *fs_name, struct disk_ops *dops);
+struct disk_ops *disk_ops_for(const char *disk_name);
+char *disk_fs_for(const char *disk_name);
+char *disk_name_from_path(const char *path);
+char *disk_filepath_from_path(const char *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libraries/nffs/src/fs/disk/pkg.yml

@@ -0,0 +1,27 @@
+#
+# 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.
+#
+
+pkg.name: fs/disk
+pkg.description: Disk management layer to glue filesystems to disk devices.
+pkg.author: "Apache Mynewt <[email protected]>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+    - kernel/os

libraries/nffs/src/fs/disk/src/disk.c

@@ -0,0 +1,151 @@
+/*
+ * 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.
+ */
+
+#include <syscfg/syscfg.h>
+#include <disk/disk.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct disk_info {
+    const char *disk_name;
+    const char *fs_name;
+    struct disk_ops *dops;
+
+    SLIST_ENTRY(disk_info) sc_next;
+};
+
+static SLIST_HEAD(, disk_info) disks = SLIST_HEAD_INITIALIZER();
+
+/**
+ *
+ */
+int disk_register(const char *disk_name, const char *fs_name, struct disk_ops *dops)
+{
+    struct disk_info *info = NULL;
+    struct disk_info *sc;
+
+    SLIST_FOREACH(sc, &disks, sc_next) {
+        if (strcmp(sc->disk_name, disk_name) == 0) {
+            return DISK_ENOENT;
+        }
+    }
+
+    info = malloc(sizeof(struct disk_info));
+    if (!info) {
+        return DISK_ENOMEM;
+    }
+
+    info->disk_name = disk_name;
+    info->fs_name = fs_name;
+    info->dops = dops;
+
+    SLIST_INSERT_HEAD(&disks, info, sc_next);
+
+    return 0;
+}
+
+struct disk_ops *
+disk_ops_for(const char *disk_name)
+{
+    struct disk_info *sc;
+
+    if (disk_name) {
+        SLIST_FOREACH(sc, &disks, sc_next) {
+            if (strcmp(sc->disk_name, disk_name) == 0) {
+                return sc->dops;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+char *
+disk_fs_for(const char *disk_name)
+{
+    struct disk_info *sc;
+
+    if (disk_name) {
+        SLIST_FOREACH(sc, &disks, sc_next) {
+            if (strcmp(sc->disk_name, disk_name) == 0) {
+                return ((char *) sc->fs_name);
+            }
+        }
+    }
+
+    return NULL;
+}
+
+char *
+disk_name_from_path(const char *path)
+{
+    char *colon;
+    uint8_t len;
+    char *disk;
+
+    colon = (char *) path;
+    while (*colon && *colon != ':') {
+        colon++;
+    }
+
+    if (*colon != ':') {
+        return NULL;
+    }
+
+    len = colon - path;
+    disk = malloc(len + 1);
+    if (!disk) {
+        return NULL;
+    }
+    memcpy(disk, path, len);
+    disk[len] = '\0';
+
+    return disk;
+}
+
+/**
+ * @brief Returns the path with the disk prefix removed (if found)
+ *
+ * Paths should be given in the form disk<number>:/path. This routine
+ * will parse and return only the path, removing the disk information.
+ */
+char *
+disk_filepath_from_path(const char *path)
+{
+    char *colon;
+    char *filepath;
+    size_t len;
+
+    colon = (char *) path;
+    while (*colon && *colon != ':') {
+        colon++;
+    }
+
+    if (*colon != ':') {
+        filepath = strdup(path);
+    } else {
+        colon++;
+        len = strlen(colon);
+        filepath = malloc(len);
+        memcpy(filepath, colon, len);
+        filepath[len] = '\0';
+    }
+
+    return filepath;
+}

libraries/nffs/src/fs/fs/include/fs/fs.h

@@ -79,6 +79,11 @@ int fs_dirent_is_dir(const struct fs_dirent *);
 #define FS_EACCESS      12  /* Operation prohibited by file open mode */
 #define FS_EUNINIT      13  /* File system not initialized */
 
+#define FS_NMGR_ID_FILE     0
+
+#define FS_NMGR_MAX_MSG     400
+#define FS_NMGR_MAX_NAME    64
+
 #ifdef __cplusplus
 }
 #endif

libraries/nffs/src/fs/fs/include/fs/fs_if.h

@@ -24,6 +24,8 @@
 extern "C" {
 #endif
 
+#include <os/queue.h>
+
 /*
  * Common interface filesystem(s) provide.
  */
@@ -52,12 +54,41 @@ struct fs_ops {
     int (*f_dirent_is_dir)(const struct fs_dirent *dirent);
 
     const char *f_name;
+
+    SLIST_ENTRY(fs_ops) sc_next;
 };
 
-/*
- * Currently allow only one type of FS, starts at root.
+struct fops_container {
+    struct fs_ops *fops;
+};
+
+/**
+ * Registers a new filesystem interface
+ *
+ * @param fops filesystem operations table
+ *
+ * @return 0 on success, non-zero on failure
  */
-int fs_register(const struct fs_ops *);
+int fs_register(struct fs_ops *fops);
+
+/**
+ * Will look for the number of registered filesystems and will return
+ * the fops if there is only one.
+ *
+ * @return fops if there's only one registered filesystem, NULL otherwise.
+ */
+struct fs_ops *fs_ops_try_unique(void);
+
+/**
+ * Retrieve a filesystem's operations table
+ *
+ * @param name Name of the filesystem to retrieve fs_ops for
+ *
+ * @return valid pointer on success, NULL on failure
+ */
+struct fs_ops *fs_ops_for(const char *name);
+
+struct fs_ops *fs_ops_from_container(struct fops_container *container);
 
 #ifdef __cplusplus
 }

libraries/nffs/src/fs/fs/pkg.yml

@@ -26,5 +26,8 @@ pkg.keywords:
     - filesystem
     - ffs
 
+pkg.deps:
+    - fs/disk
+
 pkg.deps.FS_CLI:
     - sys/shell

libraries/nffs/src/fs/fs/src/fs_dirent.c

@@ -20,33 +20,52 @@
 #include <fs/fs_if.h>
 #include "fs_priv.h"
 
+struct fs_ops *fops_from_filename(const char *);
+
+static struct fs_ops *
+fops_from_dir(const struct fs_dir *dir)
+{
+    return fs_ops_from_container((struct fops_container *) dir);
+}
+
+static inline struct fs_ops *
+fops_from_dirent(const struct fs_dirent *dirent)
+{
+    return fs_ops_from_container((struct fops_container *) dirent);
+}
+
 int
 fs_opendir(const char *path, struct fs_dir **out_dir)
 {
-    return fs_root_ops->f_opendir(path, out_dir);
+    struct fs_ops *fops = fops_from_filename(path);
+    return fops->f_opendir(path, out_dir);
 }
 
 int
 fs_readdir(struct fs_dir *dir, struct fs_dirent **out_dirent)
 {
-    return fs_root_ops->f_readdir(dir, out_dirent);
+    struct fs_ops *fops = fops_from_dir(dir);
+    return fops->f_readdir(dir, out_dirent);
 }
 
 int
 fs_closedir(struct fs_dir *dir)
 {
-    return fs_root_ops->f_closedir(dir);
+    struct fs_ops *fops = fops_from_dir(dir);
+    return fops->f_closedir(dir);
 }
 
 int
 fs_dirent_name(const struct fs_dirent *dirent, size_t max_len,
   char *out_name, uint8_t *out_name_len)
 {
-    return fs_root_ops->f_dirent_name(dirent, max_len, out_name, out_name_len);
+    struct fs_ops *fops = fops_from_dirent(dirent);
+    return fops->f_dirent_name(dirent, max_len, out_name, out_name_len);
 }
 
 int
 fs_dirent_is_dir(const struct fs_dirent *dirent)
 {
-    return fs_root_ops->f_dirent_is_dir(dirent);
+    struct fs_ops *fops = fops_from_dirent(dirent);
+    return fops->f_dirent_is_dir(dirent);
 }