Initial commit based on content of fs/nffs from mynewt-core
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e53a422
--- /dev/null
+++ b/README.md
@@ -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.
+#
+-->
+
+## Overview
+Newtron Flash File System (nffs) is a flash file system with the following
+priorities:
+ * Minimal RAM usage
+ * Reliability
+
diff --git a/design.txt b/design.txt
new file mode 100644
index 0000000..07c2e9d
--- /dev/null
+++ b/design.txt
@@ -0,0 +1,885 @@
+#
+# 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.
+#
+
+***** NFFS
+
+*** HISTORY
+Rev. Date Changes
+6 2015/10/12 Add directory-reading API.
+5 2015/09/28 Rename to Newtron Flash File System.
+4 2015/09/08 Fix some badly-specified CRC behavior; clarification of
+ behavior during restore of corrupt disk.
+3 2015/08/20 More cache specifics; updated nffs_read() function
+ type.
+2 2015/08/17 Addition of crc16; clarification of sweep phase.
+1 2015/08/13
+
+
+*** SUMMARY
+
+Newtron Flash File System (nffs) is a flash file system with the following
+priorities:
+ * Minimal RAM usage
+ * Reliability
+
+
+*** DISK STRUCTURE
+
+At the top level, an nffs disk is partitioned into areas. An area is a region
+of disk with the following properties:
+ (1) An area can be fully erased without affecting any other areas.
+ (2) A write to one area does not restrict writes to other areas.
+
+Clarification of point (2): some flash hardware divides its memory space into
+"blocks." Writes within a block must be sequential, but writes to one block
+have no effect on what parts of other blocks can be written. Thus, for flash
+hardware with such a restriction, each area must comprise a discrete number of
+blocks.
+
+While not strictly necessary, it is recommended that all areas have the same
+size.
+
+On disk, each area is prefixed with the following header:
+
+/** On-disk representation of an area header. */
+struct nffs_disk_area {
+ uint32_t nda_magic[4]; /* NFFS_AREA_MAGIC{0,1,2,3} */
+ uint32_t nda_length; /* Total size of area, in bytes. */
+ uint8_t nda_ver; /* Current nffs version: 0 */
+ uint8_t nda_gc_seq; /* Garbage collection count. */
+ uint8_t reserved8;
+ uint8_t nda_id; /* 0xff if scratch area. */
+};
+
+Beyond its header, an area contains a sequence of disk objects, representing
+the contents of the file system. There are two types of objects: inodes and
+data blocks. An inode represents a file or directory; a data block represents
+part of a file's contents.
+
+/** On-disk representation of an inode (file or directory). */
+struct nffs_disk_inode {
+ uint32_t ndi_magic; /* NFFS_INODE_MAGIC */
+ uint32_t ndi_id; /* Unique object ID. */
+ uint32_t ndi_seq; /* Sequence number; greater supersedes
+ lesser. */
+ uint32_t ndi_parent_id; /* Object ID of parent directory inode. */
+ uint8_t reserved8;
+ uint8_t ndi_filename_len; /* Length of filename, in bytes. */
+ uint16_t ndi_crc16; /* Covers rest of header and filename. */
+ /* Followed by filename. */
+};
+
+An inode filename's length cannot exceed 256 bytes. The filename is not
+null-terminated. The following ASCII characters are not allowed in a
+filename:
+ * / (slash character)
+ * \0 (NUL character)
+
+/** On-disk representation of a data block. */
+struct nffs_disk_block {
+ uint32_t ndb_magic; /* NFFS_BLOCK_MAGIC */
+ uint32_t ndb_id; /* Unique object ID. */
+ uint32_t ndb_seq; /* Sequence number; greater supersedes lesser. */
+ uint32_t ndb_inode_id; /* Object ID of owning inode. */
+ uint32_t ndb_prev_id; /* Object ID of previous block in file;
+ NFFS_ID_NONE if this is the first block. */
+ uint16_t ndb_data_len; /* Length of data contents, in bytes. */
+ uint16_t ndb_crc16; /* Covers rest of header and data. */
+ /* Followed by 'ndb_data_len' bytes of data. */
+};
+
+Each data block contains the ID of the previous data block in the file.
+Together, the set of blocks in a file form a reverse singly-linked list.
+
+The maximum number of data bytes that a block can contain is determined at
+initialization-time. The result is the greatest number which satisfies all of
+the following restrictions:
+ o No more than 2048.
+ o At least two maximum-sized blocks can fit in the smallest area.
+
+The 2048 number was chosen somewhat arbitrarily, and may change in the future.
+
+
+*** ID SPACE
+
+All disk objects have a unique 32-bit ID. The ID space is partitioned as
+follows:
+ * 0x00000000 - 0x0fffffff: Directory inodes.
+ * 0x10000000 - 0x7fffffff: File inodes.
+ * 0x80000000 - 0xfffffffe: Data blocks.
+ * 0xffffffff : Reserved (NFFS_ID_NONE)
+
+
+*** SCRATCH AREA
+
+A valid nffs file system must contain a single "scratch area." The scratch
+area does not contain any objects of its own, and is only used during garbage
+collection. The scratch area must have a size greater than or equal to each
+of the other areas in flash.
+
+
+*** RAM REPRESENTATION
+
+The file system comprises a set of objects of the following two types:
+ 1) inode
+ 2) data block
+
+Every object in the file system is stored in a 256-entry hash table. An
+object's hash key is derived from its 32-bit ID. Each list in the hash table
+is sorted by time of use; most-recently-used is at the front of the list. All
+objects are represented by the following structure:
+
+/**
+ * What gets stored in the hash table. Each entry represents a data block or
+ * an inode.
+ */
+struct nffs_hash_entry {
+ SLIST_ENTRY(nffs_hash_entry) nhe_next;
+ uint32_t nhe_id; /* 0 - 0x7fffffff if inode; else if block. */
+ uint32_t nhe_flash_loc; /* Upper-byte = area idx; rest = area offset. */
+};
+
+For each data block, the above structure is all that is stored in RAM. To
+acquire more information about a data block, the block header must be read
+from flash.
+
+Inodes require a fuller RAM representation to capture the structure of the
+file system. There are two types of inodes: files and directories. Each
+inode hash entry is actually an instance of the following structure:
+
+/** Each inode hash entry is actually one of these. */
+struct nffs_inode_entry {
+ struct nffs_hash_entry nie_hash_entry;
+ SLIST_ENTRY(nffs_inode_entry) nie_sibling_next;
+ union {
+ struct nffs_inode_list nie_child_list; /* If directory */
+ struct nffs_hash_entry *nie_last_block_entry; /* If file */
+ };
+ uint8_t nie_refcnt;
+};
+
+A directory inode contains a list of its child files and directories
+(fie_child_list). These entries are sorted alphabetically using the ASCII
+character set.
+
+A file inode contains a pointer to the last data block in the file
+(nie_last_block_entry). For most file operations, the reversed block list must
+be walked backwards. This introduces a number of speed inefficiencies:
+ * All data blocks must be read to determine the length of the file.
+ * Data blocks often need to be processed sequentially. The reversed
+ nature of the block list transforms this from linear time to an O(n^2)
+ operation.
+
+Furthermore, obtaining information about any constituent data block requires a
+separate flash read.
+
+
+*** INODE CACHE AND DATA BLOCK CACHE
+The speed issues are addressed by a pair of caches. Cached inodes entries
+contain the file length and a much more convenient doubly-linked list of
+cached data blocks. The benefit of using caches is that the size of the
+caches need not be proportional to the size of the file system. In other
+words, caches can address speed efficiency concerns without negatively
+impacting the file system's scalability.
+
+nffs requires both caches during normal operation, so it is not possible to
+disable them. However, the cache sizes are configurable, and both caches can
+be configured with a size of one if RAM usage must be minimized.
+
+The following data structures are used in the inode and data block caches.
+
+/** Full data block representation; not stored permanently in RAM. */
+struct nffs_block {
+ struct nffs_hash_entry *nb_hash_entry; /* Points to real block entry. */
+ uint32_t nb_seq; /* Sequence number; greater
+ supersedes lesser. */
+ struct nffs_inode_entry *nb_inode_entry; /* Owning inode. */
+ struct nffs_hash_entry *nb_prev; /* Previous block in file. */
+ uint16_t nb_data_len; /* # of data bytes in block. */
+ uint16_t reserved16;
+};
+
+/** Represents a single cached data block. */
+struct nffs_cache_block {
+ TAILQ_ENTRY(nffs_cache_block) ncb_link; /* Next / prev cached block. */
+ struct nffs_block ncb_block; /* Full data block. */
+ uint32_t ncb_file_offset; /* File offset of this block. */
+};
+
+/** Full inode representation; not stored permanently in RAM. */
+struct nffs_inode {
+ struct nffs_inode_entry *ni_inode_entry; /* Points to real inode entry. */
+ uint32_t ni_seq; /* Sequence number; greater
+ supersedes lesser. */
+ struct nffs_inode_entry *ni_parent; /* Points to parent directory. */
+ uint8_t ni_filename_len; /* # chars in filename. */
+ uint8_t ni_filename[NFFS_SHORT_FILENAME_LEN]; /* First 3 bytes. */
+};
+
+/** Doubly-linked tail queue of cached blocks; contained in cached inodes. */
+TAILQ_HEAD(nffs_block_cache_list, nffs_block_cache_entry);
+
+/** Represents a single cached file inode. */
+struct nffs_cache_inode {
+ TAILQ_ENTRY(nffs_cache_inode) nci_link; /* Sorted; LRU at tail. */
+ struct nffs_inode nci_inode; /* Full inode. */
+ struct nffs_cache_block_list nci_block_list; /* List of cached blocks. */
+ uint32_t nci_file_size; /* Total file size. */
+};
+
+Only file inodes are cached; directory inodes are never cached.
+
+Within a cached inode, all cached data blocks are contiguous. E.g., if the
+start and end of a file are cached, then the middle must also be cached. A
+data block is only cached if its owning file is also cached.
+
+Internally, cached inodes are stored in a singly-linked list, ordered by time
+of use. The most-recently-used entry is the first element in the list. If a
+new inode needs to be cached, but the inode cache is full, the
+least-recently-used entry is freed to make room for the new one. The
+following operations cause an inode to be cached:
+ * Querying a file's length.
+ * Seeking within a file.
+ * Reading from a file.
+ * Writing to a file.
+
+The following operations cause a data block to be cached:
+ * Reading from the block.
+ * Writing to the block.
+
+If one of the above operations is applied to a data block that is not currently
+cached, nffs uses the following procedure to cache the necessary block:
+ 1. If none of the owning inode's blocks are currently cached, allocate a
+ cached block entry corresponding to the requested block and insert it
+ into the inode's list.
+ 2. Else if the requested file offset is less than that of the first cached
+ block, bridge the gap between the inode's sequence of cached blocks and
+ the block that now needs to be cached. This is accomplished by caching
+ each block in the gap, finishing with the requested block.
+ 3. Else (the requested offset is beyond the end of the cache),
+ a. If the requested offset belongs to the block that immediately
+ follows the end of the cache, cache the block and append it to the
+ list.
+ b. Else, clear the cache, and populate it with the single entry
+ corresponding to the requested block.
+
+If the system is unable to allocate a cached block entry at any point during
+the above procedure, the system frees up other blocks currently in the cache.
+This is accomplished as follows:
+ 1. Iterate the inode cache in reverse (i.e., start with the
+ least-recently-used entry). For each entry:
+ a. If the entry's cached block list is empty, advance to the next
+ entry.
+ b. Else, free all the cached blocks in the entry's list.
+
+Because the system imposes a minimum block cache size of one, the above
+procedure will always reclaim at least one cache block entry. The above
+procedure may result in the freeing of the block list that belongs to the very
+inode being operated on. This is OK, as the final block to get cached is
+always the block being requested.
+
+
+*** CONFIGURATION
+The file system is configured by populating fields in a global structure.
+Each field in the structure corresponds to a setting. All configuration must
+be done prior to calling nffs_init(). The configuration structure is defined
+as follows:
+
+struct nffs_config {
+ /** Maximum number of inodes; default=1024. */
+ uint32_t nc_num_inodes;
+
+ /** Maximum number of data blocks; default=4096. */
+ uint32_t nc_num_blocks;
+
+ /** Maximum number of open files; default=4. */
+ uint32_t nc_num_files;
+
+ /** Inode cache size; default=4. */
+ uint32_t nc_num_cache_inodes;
+
+ /** Data block cache size; default=64. */
+ uint32_t nc_num_cache_blocks;
+};
+
+extern struct nffs_config nffs_config;
+
+Any fields that are set to 0 (or not set at all) inherit the corresponding
+default value. This means that it is impossible to configure any setting with
+a value of zero.
+
+
+*** INITIALIZATION
+
+There are two means of initializing an nffs file system:
+ (1) Restore an existing file system via detection.
+ (2) Create a new file system via formatting.
+
+Both methods require the user to describe how the flash memory is divided into
+areas. This is accomplished with an array of struct nffs_area_desc, defined as
+follows:
+
+struct nffs_area_desc {
+ uint32_t nad_offset; /* Flash offset of start of area. */
+ uint32_t nad_length; /* Size of area, in bytes. */
+};
+
+An array of area descriptors is terminated by an entry with a fad_length field
+of 0.
+
+One common initialization sequence is the following:
+
+ (1) Detect an nffs file system anywhere in flash.
+ (2) If no file system detected, format a new file system in a specific
+ region of flash.
+
+
+*** DETECTION
+
+The file system detection process consists of scanning a specified set of
+flash regions for valid nffs areas, and then populating the RAM representation
+of the file system with the detected objects. Detection is initiated with the
+following function:
+
+/**
+ * Searches for a valid nffs file system among the specified areas. This
+ * function succeeds if a file system is detected among any subset of the
+ * supplied areas. If the area set does not contain a valid file system,
+ * a new one can be created via a separate call to nffs_format().
+ *
+ * @param area_descs The area set to search. This array must be
+ * terminated with a 0-length area.
+ *
+ * @return 0 on success;
+ * NFFS_ECORRUPT if no valid file system was detected;
+ * other nonzero on error.
+ */
+int nffs_detect(const struct nffs_area_desc *area_descs);
+
+As indicated, not every area descriptor needs to reference a valid nffs area.
+Detection is successful as long as a complete file system is detected
+somewhere in the specified regions of flash. If an application is unsure
+where a file system might be located, it can initiate detection across the
+entire flash region.
+
+A detected file system is valid if:
+ (1) At least one non-scratch area is present.
+ (2) At least one scratch area is present (only the first gets used if
+ there is more than one).
+ (3) The root directory inode is present.
+
+During detection, each indicated region of flash is checked for a valid area
+header. The contents of each valid non-scratch area are then restored into
+the nffs RAM representation. The following procedure is applied to each object
+in the area:
+
+ (1) Verify the object's integrity via a crc16 check. If invalid, the
+ object is discarded and the procedure restarts on the next object in
+ the area.
+
+ (2) Convert the disk object into its corresponding RAM representation and
+ insert it into the hash table. If the object is an inode, its
+ reference count is initialized to 1, indicating ownership by its
+ parent directory.
+
+ (3) If an object with the same ID is already present, then one supersedes
+ the other. Accept the object with the greater sequence number and
+ discard the other.
+
+ (4) If the object references a nonexistant inode (parent directory in the
+ case of an inode; owning file in the case of a data block), insert a
+ temporary "dummy" inode into the hash table so that inter-object links
+ can be maintained until the absent inode is eventually restored. Dummy
+ inodes are identified by a reference count of 0.
+
+ (5) If a delete record for an inode is encountered, the inode's parent
+ pointer is set to null to indicate that it should be removed from RAM.
+
+If nffs encounters an object that cannot be identified (i.e., its magic number
+is not valid), it scans the remainder of the flash area for the next valid
+magic number. Upon encountering a valid object, nffs resumes the procedure
+described above.
+
+After all areas have been restored, a sweep is performed across the entire RAM
+representation so that invalid inodes can be deleted from memory.
+
+For each directory inode:
+ * If its reference count is 0 (i.e., it is a dummy), migrate its children
+ to the /lost+found directory, and delete it from the RAM representation.
+ This should only happen in the case of file system corruption.
+ * If its parent reference is null (i.e., it was deleted), delete it and all
+ its children from the RAM representation.
+
+For each file inode:
+ * If its reference count is 0 (i.e., it is a dummy), delete it from the RAM
+ representation. This should only happen in the case of file system
+ corruption. (We should try to migrate the file to the lost+found
+ directory in this case, as mentioned in the todo section).
+
+When an object is deleted during this sweep, it is only deleted from the RAM
+representation; nothing is written to disk.
+
+When objects are migrated to the lost+found directory, their parent inode
+reference is permanently updated on the disk.
+
+In addition, a single scratch area is identified during the detection process.
+The first area whose 'fda_id' value is set to 0xff is designated as the file
+system scratch area. If no valid scratch area is found, the cause could be
+that the system was restarted while a garbage collection cycle was in progress.
+Such a condition is identified by the presence of two areas with the same ID.
+In such a case, the shorter of the two areas is erased and designated as the
+scratch area.
+
+
+*** FORMATTING
+
+A new file system is created via formatting. Formatting is achieved via the
+following function:
+
+/**
+ * Erases all the specified areas and initializes them with a clean nffs
+ * file system.
+ *
+ * @param area_descs The set of areas to format.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int nffs_format(const struct nffs_area_desc *area_descs);
+
+On success, an area header is written to each of the specified locations. The
+largest area in the set is designated as the initial scratch area.
+
+
+*** FLASH WRITES
+
+The nffs implementation always writes in a strictly sequential fashion within an
+area. For each area, the system keeps track of the current offset. Whenever
+an object gets written to an area, it gets written to that area's current
+offset, and the offset is increased by the object's disk size.
+
+When a write needs to be performed, the nffs implementation selects the
+appropriate destination area by iterating though each area until one with
+sufficient free space is encountered.
+
+There is no write buffering. Each call to a write function results in a write
+operation being sent to the flash hardware.
+
+
+*** NEW OBJECTS
+
+Whenever a new object is written to disk, it is assigned the following
+properties:
+ * ID: A unique value is selected from the 32-bit ID space, as appropriate
+ for the object's type.
+ * Sequence number: 0
+
+When a new file or directory is created, a corresponding inode is written to
+flash. Likewise, a new data block also results in the writing of a
+corresponding disk object.
+
+
+*** MOVING / RENAMING FILES AND DIRECTORIES
+
+When a file or directory is moved or renamed, its corresponding inode is
+rewritten to flash with the following properties:
+ * ID: Unchanged
+ * Sequence number: Previous value plus one.
+ * Parent inode: As specified by the move / rename operation.
+ * Filename: As specified by the move / rename operation.
+
+Because the inode's ID is unchanged, all dependent objects remain valid.
+
+
+*** UNLINKING FILES AND DIRECTORIES
+
+When a file or directory is unlinked from its parent directory, a deletion
+record for the unlinked inode gets written to flash. The deletion record is an
+inode with the following properties:
+ * ID: Unchanged
+ * Sequence number: Previous value plus one.
+ * Parent inode ID: NFFS_ID_NONE
+
+When an inode is unlinked, no deletion records need to be written for the
+inode's dependent objects (constituent data blocks or child inodes). During
+the next file system detection, it is recognized that the objects belong to
+a deleted inode, so they are not restored into the RAM representation.
+
+If a file has an open handle at the time it gets unlinked, application code
+can continued to use the file handle to read and write data. All files retain
+a reference count, and a file isn't deleted from the RAM representation until
+its reference code drops to 0. Any attempt to open an unlinked file fails,
+even if the file is referenced by other file handles.
+
+
+*** WRITING TO A FILE
+
+The following procedure is used whenever the application code writes to a file.
+First, if the write operation specifies too much data to fit into a single
+block, the operation is split into several separate write operations. Then,
+for each write operation:
+
+ (1) Determine which existing blocks the write operation overlaps
+ (n = number of overwritten blocks).
+
+ (2) If n = 0, this is an append operation. Write a data block with the
+ following properties:
+ * ID: New unique value.
+ * Sequence number: 0.
+
+ (3) Else (n > 1), this write overlaps existing data.
+ (a) For each block in [1, 2, ... n-1], write a new block
+ containing the updated contents. Each new block supersedes the
+ block it overwrites. That is, each block has the following
+ properties:
+ * ID: Unchanged
+ * Sequence number: Previous value plus one.
+
+ (b) Write the nth block. The nth block includes all appended data,
+ if any. As with the other blocks, its ID is unchanged and its
+ sequence number is incremented.
+
+Appended data can only be written to the end of the file. That is, "holes" are
+not supported.
+
+
+*** GARBAGE COLLECTION
+
+When the file system is too full to accomodate a write operation, the system
+must perform garbage collection to make room. The garbage collection
+procedure is described below:
+
+ (1) The non-scratch area with the lowest garbage collection sequence
+ number is selected as the "source area." If there are other areas
+ with the same sequence number, the one with the smallest flash offset
+ is selected.
+
+ (2) The source area's ID is written to the scratch area's header,
+ transforming it into a non-scratch ID. This former scratch area is now
+ known as the "destination area."
+
+ (3) The RAM representation is exhaustively searched for collectible
+ objects. The following procedure is applied to each inode in the
+ system:
+
+ (a) If the inode is resident in the source area, copy the inode record
+ to the destination area.
+
+ (b) If the inode is a file inode, walk the inode's list of data blocks,
+ starting with the last block in the file. Each block that is
+ resident in the source area is copied to the destination area. If
+ there is a run of two or more blocks that are resident in the
+ source area, they are consolidated and copied to the destination
+ area as a single new block (subject to the maximum block size
+ restriction).
+
+ (4) The source area is reformatted as a scratch sector (i.e., is is fully
+ erased, and its header is rewritten with an ID of 0xff). The area's
+ garbage collection sequence number is incremented prior to rewriting
+ the header. This area is now the new scratch sector.
+
+
+*** MISC
+
+ * RAM usage:
+ o 24 bytes per inode
+ o 12 bytes per data block
+ o 36 bytes per inode cache entry
+ o 32 bytes per data block cache entry
+ * Maximum filename size: 256 characters (no null terminator required)
+ * Disallowed filename characters: '/' and '\0'
+
+
+*** FUTURE ENHANCEMENTS
+
+ * API function to traverse a directory.
+ * Migrate corrupt files to the /lost+found directory during restore, rather
+ than discarding them from RAM.
+ * Error correction.
+ * Encryption.
+ * Compression.
+
+
+*** API
+
+struct nffs_file;
+
+/**
+ * Opens a file at the specified path. The result of opening a nonexistent
+ * file depends on the access flags specified. All intermediate directories
+ * must already exist.
+ *
+ * The mode strings passed to fopen() map to nffs_open()'s access flags as
+ * follows:
+ * "r" - NFFS_ACCESS_READ
+ * "r+" - NFFS_ACCESS_READ | NFFS_ACCESS_WRITE
+ * "w" - NFFS_ACCESS_WRITE | NFFS_ACCESS_TRUNCATE
+ * "w+" - NFFS_ACCESS_READ | NFFS_ACCESS_WRITE | NFFS_ACCESS_TRUNCATE
+ * "a" - NFFS_ACCESS_WRITE | NFFS_ACCESS_APPEND
+ * "a+" - NFFS_ACCESS_READ | NFFS_ACCESS_WRITE | NFFS_ACCESS_APPEND
+ *
+ * @param out_file On success, a pointer to the newly-created file
+ * handle gets written here.
+ * @param path The path of the file to open.
+ * @param access_flags Flags controlling file access; see above table.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_open(const char *path, uint8_t access_flags,
+ struct nffs_file **out_file);
+
+
+/**
+ * Closes the specified file and invalidates the file handle. If the file has
+ * already been unlinked, and this is the last open handle to the file, this
+ * operation causes the file to be deleted from disk.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_close(struct nffs_file *file);
+
+
+/**
+ * Positions a file's read and write pointer at the specified offset. The
+ * offset is expressed as the number of bytes from the start of the file (i.e.,
+ * seeking to offset 0 places the pointer at the first byte in the file).
+ *
+ * @param file The file to reposition.
+ * @param offset The 0-based file offset to seek to.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_seek(struct nffs_file *file, uint32_t offset);
+
+
+/**
+ * Retrieves the current read and write position of the specified open file.
+ *
+ * @param file The file to query.
+ *
+ * @return The file offset, in bytes.
+ */
+uint32_t nffs_getpos(const struct nffs_file *file);
+
+
+/**
+ * Retrieves the current length of the specified open file.
+ *
+ * @param file The file to query.
+ * @param out_len On success, the number of bytes in the file gets
+ * written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_file_len(const struct nffs_file *file, uint32_t *out_len)
+
+
+/**
+ * Reads data from the specified file. If more data is requested than remains
+ * in the file, all available data is retrieved. Note: this type of short read
+ * results in a success return code.
+ *
+ * @param file The file to read from.
+ * @param len The number of bytes to attempt to read.
+ * @param out_data The destination buffer to read into.
+ * @param out_len On success, the number of bytes actually read gets
+ * written here. Pass null if you don't care.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_read(struct nffs_file *file, uint32_t len, void *out_data,
+ uint32_t *out_len)
+
+
+/**
+ * Writes the supplied data to the current offset of the specified file handle.
+ *
+ * @param file The file to write to.
+ * @param data The data to write.
+ * @param len The number of bytes to write.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_write(struct nffs_file *file, const void *data, int len);
+
+
+/**
+ * Unlinks the file or directory at the specified path. If the path refers to
+ * a directory, all the directory's descendants are recursively unlinked. Any
+ * open file handles refering to an unlinked file remain valid, and can be
+ * read from and written to.
+ *
+ * @path The path of the file or directory to unlink.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_unlink(const char *path);
+
+
+/**
+ * Performs a rename and / or move of the specified source path to the
+ * specified destination. The source path can refer to either a file or a
+ * directory. All intermediate directories in the destination path must
+ * already exist. If the source path refers to a file, the destination path
+ * must contain a full filename path, rather than just the new parent
+ * directory. If an object already exists at the specified destination path,
+ * this function causes it to be unlinked prior to the rename (i.e., the
+ * destination gets clobbered).
+ *
+ * @param from The source path.
+ * @param to The destination path.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int nffs_rename(const char *from, const char *to);
+
+
+/**
+ * Creates the directory represented by the specified path. All intermediate
+ * directories must already exist. The specified path must start with a '/'
+ * character.
+ *
+ * @param path The directory to create.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int nffs_mkdir(const char *path);
+
+
+/**
+ * Erases all the specified areas and initializes them with a clean nffs
+ * file system.
+ *
+ * @param area_descs The set of areas to format.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int nffs_format(const struct nffs_area_desc *area_descs);
+
+
+/**
+ * Opens the directory at the specified path. The directory's contents can be
+ * read with subsequent calls to nffs_readdir(). When you are done with the
+ * directory handle, close it with nffs_closedir().
+ *
+ * Unlinking files from the directory while it is open may result in
+ * unpredictable behavior. New files can be created inside the directory.
+ *
+ * @param path The directory to open.
+ * @param out_dir On success, points to the directory handle.
+ *
+ * @return 0 on success;
+ * NFFS_ENOENT if the specified directory does not
+ * exist;
+ * other nonzero on error.
+ */
+int nffs_opendir(const char *path, struct nffs_dir **out_dir);
+
+
+/**
+ * Reads the next entry in an open directory.
+ *
+ * @param dir The directory handle to read from.
+ * @param out_dirent On success, points to the next child entry in
+ * the specified directory.
+ *
+ * @return 0 on success;
+ * NFFS_ENOENT if there are no more entries in the
+ * parent directory;
+ * other nonzero on error.
+ */
+int nffs_readdir(struct nffs_dir *dir, struct nffs_dirent **out_dirent);
+
+
+/**
+ * Closes the specified directory handle.
+ *
+ * @param dir The directory to close.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_closedir(struct nffs_dir *dir);
+
+
+/**
+ * Retrieves the filename of the specified directory entry. The retrieved
+ * filename is always null-terminated. To ensure enough space to hold the full
+ * filename plus a null-termintor, a destination buffer of size
+ * (NFFS_FILENAME_MAX_LEN + 1) should be used.
+ *
+ * @param dirent The directory entry to query.
+ * @param max_len The size of the "out_name" character buffer.
+ * @param out_name On success, the entry's filename is written
+ * here; always null-terminated.
+ * @param out_name_len On success, contains the actual length of the
+ * filename, NOT including the
+ * null-terminator.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int nffs_dirent_name(struct nffs_dirent *dirent, size_t max_len,
+ char *out_name, uint8_t *out_name_len);
+
+
+/**
+ * Tells you whether the specified directory entry is a sub-directory or a
+ * regular file.
+ *
+ * @param dirent The directory entry to query.
+ *
+ * @return 1: The entry is a directory;
+ * 0: The entry is a regular file.
+ */
+int nffs_dirent_is_dir(const struct nffs_dirent *dirent);
+
+/**
+ * Searches for a valid nffs file system among the specified areas. This
+ * function succeeds if a file system is detected among any subset of the
+ * supplied areas. If the area set does not contain a valid file system,
+ * a new one can be created via a call to nffs_format().
+ *
+ * @param area_descs The area set to search. This array must be
+ * terminated with a 0-length area.
+ *
+ * @return 0 on success;
+ * NFFS_ECORRUPT if no valid file system was detected;
+ * other nonzero on error.
+ */
+int nffs_detect(const struct nffs_area_desc *area_descs);
+
+
+/**
+ * Indicates whether a valid filesystem has been initialized, either via
+ * detection or formatting.
+ *
+ * @return 1 if a file system is present; 0 otherwise.
+ */
+int nffs_ready(void);
+
+
+/**
+ * Initializes the nffs memory and data structures. This must be called before
+ * any nffs operations are attempted.
+ *
+ * @return 0 on success; nonzero on error.
+ */
+int nffs_init(void);
diff --git a/include/nffs/nffs.h b/include/nffs/nffs.h
new file mode 100644
index 0000000..35baeb5
--- /dev/null
+++ b/include/nffs/nffs.h
@@ -0,0 +1,72 @@
+/*
+ * 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 H_NFFS_
+#define H_NFFS_
+
+#include <stddef.h>
+#include <inttypes.h>
+#include "fs/fs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NFFS_FILENAME_MAX_LEN 256 /* Does not require null terminator. */
+#define NFFS_MAX_AREAS 256
+
+struct nffs_config {
+ /** Maximum number of inodes; default=1024. */
+ uint32_t nc_num_inodes;
+
+ /** Maximum number of data blocks; default=4096. */
+ uint32_t nc_num_blocks;
+
+ /** Maximum number of open files; default=4. */
+ uint32_t nc_num_files;
+
+ /** Maximum number of open directories; default=4. */
+ uint32_t nc_num_dirs;
+
+ /** Inode cache size; default=4. */
+ uint32_t nc_num_cache_inodes;
+
+ /** Data block cache size; default=64. */
+ uint32_t nc_num_cache_blocks;
+};
+
+extern struct nffs_config nffs_config;
+
+struct nffs_area_desc {
+ uint32_t nad_offset; /* Flash offset of start of area. */
+ uint32_t nad_length; /* Size of area, in bytes. */
+ uint8_t nad_flash_id; /* Logical flash id */
+};
+
+int nffs_init(void);
+int nffs_detect(const struct nffs_area_desc *area_descs);
+int nffs_format(const struct nffs_area_desc *area_descs);
+
+int nffs_misc_desc_from_flash_area(int idx, int *cnt, struct nffs_area_desc *nad);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/nffs/nffs_test.h b/include/nffs/nffs_test.h
new file mode 100644
index 0000000..bac660a
--- /dev/null
+++ b/include/nffs/nffs_test.h
@@ -0,0 +1,33 @@
+/*
+ * 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 H_NFFS_TEST_
+#define H_NFFS_TEST_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int nffs_test_all(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pkg.yml b/pkg.yml
new file mode 100644
index 0000000..276f456
--- /dev/null
+++ b/pkg.yml
@@ -0,0 +1,41 @@
+#
+# 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/nffs
+pkg.description: Newtron Flash File System.
+pkg.author: "Apache Mynewt <dev@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+ - file
+ - filesystem
+ - ffs
+
+pkg.deps:
+ - fs/fs
+ - util/crc
+ - hw/hal
+ - kernel/os
+ - test/testutil
+ - sys/flash_map
+pkg.req_apis:
+ - log
+ - stats
+
+pkg.init:
+ nffs_pkg_init: 200
diff --git a/src/nffs.c b/src/nffs.c
new file mode 100644
index 0000000..ace9174
--- /dev/null
+++ b/src/nffs.c
@@ -0,0 +1,809 @@
+/*
+ * 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 <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "sysinit/sysinit.h"
+#include "sysflash/sysflash.h"
+#include "bsp/bsp.h"
+#include "hal/hal_flash.h"
+#include "flash_map/flash_map.h"
+#include "os/os_mempool.h"
+#include "os/os_mutex.h"
+#include "os/os_malloc.h"
+#include "stats/stats.h"
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+#include "fs/fs_if.h"
+#include "disk/disk.h"
+
+struct nffs_area *nffs_areas;
+uint8_t nffs_num_areas;
+uint8_t nffs_scratch_area_idx;
+uint16_t nffs_block_max_data_sz;
+struct nffs_area_desc *nffs_current_area_descs;
+
+struct os_mempool nffs_file_pool;
+struct os_mempool nffs_dir_pool;
+struct os_mempool nffs_inode_entry_pool;
+struct os_mempool nffs_block_entry_pool;
+struct os_mempool nffs_cache_inode_pool;
+struct os_mempool nffs_cache_block_pool;
+
+void *nffs_file_mem;
+void *nffs_inode_mem;
+void *nffs_block_entry_mem;
+void *nffs_cache_inode_mem;
+void *nffs_cache_block_mem;
+void *nffs_dir_mem;
+
+struct nffs_inode_entry *nffs_root_dir;
+struct nffs_inode_entry *nffs_lost_found_dir;
+
+static struct os_mutex nffs_mutex;
+
+struct log nffs_log;
+
+static int nffs_open(const char *path, uint8_t access_flags,
+ struct fs_file **out_file);
+static int nffs_close(struct fs_file *fs_file);
+static int nffs_read(struct fs_file *fs_file, uint32_t len, void *out_data,
+ uint32_t *out_len);
+static int nffs_write(struct fs_file *fs_file, const void *data, int len);
+static int nffs_seek(struct fs_file *fs_file, uint32_t offset);
+static uint32_t nffs_getpos(const struct fs_file *fs_file);
+static int nffs_file_len(const struct fs_file *fs_file, uint32_t *out_len);
+static int nffs_unlink(const char *path);
+static int nffs_rename(const char *from, const char *to);
+static int nffs_mkdir(const char *path);
+static int nffs_opendir(const char *path, struct fs_dir **out_fs_dir);
+static int nffs_readdir(struct fs_dir *dir, struct fs_dirent **out_dirent);
+static int nffs_closedir(struct fs_dir *dir);
+static int nffs_dirent_name(const struct fs_dirent *fs_dirent, size_t max_len,
+ char *out_name, uint8_t *out_name_len);
+static int nffs_dirent_is_dir(const struct fs_dirent *fs_dirent);
+
+struct fs_ops nffs_ops = {
+ .f_open = nffs_open,
+ .f_close = nffs_close,
+ .f_read = nffs_read,
+ .f_write = nffs_write,
+
+ .f_seek = nffs_seek,
+ .f_getpos = nffs_getpos,
+ .f_filelen = nffs_file_len,
+
+ .f_unlink = nffs_unlink,
+ .f_rename = nffs_rename,
+ .f_mkdir = nffs_mkdir,
+
+ .f_opendir = nffs_opendir,
+ .f_readdir = nffs_readdir,
+ .f_closedir = nffs_closedir,
+
+ .f_dirent_name = nffs_dirent_name,
+ .f_dirent_is_dir = nffs_dirent_is_dir,
+
+ .f_name = "nffs"
+};
+
+STATS_SECT_DECL(nffs_stats) nffs_stats;
+STATS_NAME_START(nffs_stats)
+ STATS_NAME(nffs_stats, nffs_hashcnt_ins)
+ STATS_NAME(nffs_stats, nffs_hashcnt_rm)
+ STATS_NAME(nffs_stats, nffs_object_count)
+ STATS_NAME(nffs_stats, nffs_iocnt_read)
+ STATS_NAME(nffs_stats, nffs_iocnt_write)
+ STATS_NAME(nffs_stats, nffs_gccnt)
+ STATS_NAME(nffs_stats, nffs_readcnt_data)
+ STATS_NAME(nffs_stats, nffs_readcnt_block)
+ STATS_NAME(nffs_stats, nffs_readcnt_crc)
+ STATS_NAME(nffs_stats, nffs_readcnt_copy)
+ STATS_NAME(nffs_stats, nffs_readcnt_format)
+ STATS_NAME(nffs_stats, nffs_readcnt_gccollate)
+ STATS_NAME(nffs_stats, nffs_readcnt_inode)
+ STATS_NAME(nffs_stats, nffs_readcnt_inodeent)
+ STATS_NAME(nffs_stats, nffs_readcnt_rename)
+ STATS_NAME(nffs_stats, nffs_readcnt_update)
+ STATS_NAME(nffs_stats, nffs_readcnt_filename)
+ STATS_NAME(nffs_stats, nffs_readcnt_object)
+ STATS_NAME(nffs_stats, nffs_readcnt_detect)
+STATS_NAME_END(nffs_stats)
+
+static void
+nffs_lock(void)
+{
+ int rc;
+
+ rc = os_mutex_pend(&nffs_mutex, 0xffffffff);
+ assert(rc == 0 || rc == OS_NOT_STARTED);
+}
+
+static void
+nffs_unlock(void)
+{
+ int rc;
+
+ rc = os_mutex_release(&nffs_mutex);
+ assert(rc == 0 || rc == OS_NOT_STARTED);
+}
+
+static int
+nffs_stats_init(void)
+{
+ int rc;
+
+ rc = stats_init_and_reg(
+ STATS_HDR(nffs_stats),
+ STATS_SIZE_INIT_PARMS(nffs_stats, STATS_SIZE_32),
+ STATS_NAME_INIT_PARMS(nffs_stats),
+ "nffs_stats");
+ if (rc) {
+ if (rc < 0) {
+ /* multiple initializations are okay */
+ rc = 0;
+ } else {
+ rc = FS_EOS;
+ }
+ }
+ return rc;
+}
+
+/**
+ * Opens a file at the specified path. The result of opening a nonexistent
+ * file depends on the access flags specified. All intermediate directories
+ * must already exist.
+ *
+ * The mode strings passed to fopen() map to nffs_open()'s access flags as
+ * follows:
+ * "r" - FS_ACCESS_READ
+ * "r+" - FS_ACCESS_READ | FS_ACCESS_WRITE
+ * "w" - FS_ACCESS_WRITE | FS_ACCESS_TRUNCATE
+ * "w+" - FS_ACCESS_READ | FS_ACCESS_WRITE | FS_ACCESS_TRUNCATE
+ * "a" - FS_ACCESS_WRITE | FS_ACCESS_APPEND
+ * "a+" - FS_ACCESS_READ | FS_ACCESS_WRITE | FS_ACCESS_APPEND
+ *
+ * @param path The path of the file to open.
+ * @param access_flags Flags controlling file access; see above table.
+ * @param out_file On success, a pointer to the newly-created file
+ * handle gets written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_open(const char *path, uint8_t access_flags, struct fs_file **out_fs_file)
+{
+ int rc;
+ struct nffs_file *out_file;
+ char *filepath = NULL;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ filepath = disk_filepath_from_path(path);
+
+ rc = nffs_file_open(&out_file, filepath, access_flags);
+ if (rc != 0) {
+ goto done;
+ }
+ *out_fs_file = (struct fs_file *)out_file;
+done:
+ if (filepath) {
+ free(filepath);
+ }
+ nffs_unlock();
+ if (rc != 0) {
+ *out_fs_file = NULL;
+ }
+ return rc;
+}
+
+/**
+ * Closes the specified file and invalidates the file handle. If the file has
+ * already been unlinked, and this is the last open handle to the file, this
+ * operation causes the file to be deleted from disk.
+ *
+ * @param file The file handle to close.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_close(struct fs_file *fs_file)
+{
+ int rc;
+ struct nffs_file *file = (struct nffs_file *)fs_file;
+
+ if (file == NULL) {
+ return 0;
+ }
+
+ nffs_lock();
+ rc = nffs_file_close(file);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Positions a file's read and write pointer at the specified offset. The
+ * offset is expressed as the number of bytes from the start of the file (i.e.,
+ * seeking to offset 0 places the pointer at the first byte in the file).
+ *
+ * @param file The file to reposition.
+ * @param offset The 0-based file offset to seek to.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_seek(struct fs_file *fs_file, uint32_t offset)
+{
+ int rc;
+ struct nffs_file *file = (struct nffs_file *)fs_file;
+
+ nffs_lock();
+ rc = nffs_file_seek(file, offset);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Retrieves the current read and write position of the specified open file.
+ *
+ * @param file The file to query.
+ *
+ * @return The file offset, in bytes.
+ */
+static uint32_t
+nffs_getpos(const struct fs_file *fs_file)
+{
+ uint32_t offset;
+ const struct nffs_file *file = (const struct nffs_file *)fs_file;
+
+ nffs_lock();
+ offset = file->nf_offset;
+ nffs_unlock();
+
+ return offset;
+}
+
+/**
+ * Retrieves the current length of the specified open file.
+ *
+ * @param file The file to query.
+ * @param out_len On success, the number of bytes in the file gets
+ * written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_file_len(const struct fs_file *fs_file, uint32_t *out_len)
+{
+ int rc;
+ const struct nffs_file *file = (const struct nffs_file *)fs_file;
+
+ nffs_lock();
+ rc = nffs_inode_data_len(file->nf_inode_entry, out_len);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Reads data from the specified file. If more data is requested than remains
+ * in the file, all available data is retrieved and a success code is returned.
+ *
+ * @param file The file to read from.
+ * @param len The number of bytes to attempt to read.
+ * @param out_data The destination buffer to read into.
+ * @param out_len On success, the number of bytes actually read gets
+ * written here. Pass null if you don't care.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_read(struct fs_file *fs_file, uint32_t len, void *out_data,
+ uint32_t *out_len)
+{
+ int rc;
+ struct nffs_file *file = (struct nffs_file *)fs_file;
+
+ nffs_lock();
+ rc = nffs_file_read(file, len, out_data, out_len);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Writes the supplied data to the current offset of the specified file handle.
+ *
+ * @param file The file to write to.
+ * @param data The data to write.
+ * @param len The number of bytes to write.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_write(struct fs_file *fs_file, const void *data, int len)
+{
+ int rc;
+ struct nffs_file *file = (struct nffs_file *)fs_file;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ rc = nffs_write_to_file(file, data, len);
+ if (rc != 0) {
+ goto done;
+ }
+
+ rc = 0;
+
+done:
+ nffs_unlock();
+ return rc;
+}
+
+/**
+ * Unlinks the file or directory at the specified path. If the path refers to
+ * a directory, all the directory's descendants are recursively unlinked. Any
+ * open file handles refering to an unlinked file remain valid, and can be
+ * read from and written to.
+ *
+ * @path The path of the file or directory to unlink.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_unlink(const char *path)
+{
+ int rc;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ rc = nffs_path_unlink(path);
+ if (rc != 0) {
+ goto done;
+ }
+
+ rc = 0;
+
+done:
+ nffs_unlock();
+ return rc;
+}
+
+/**
+ * Performs a rename and / or move of the specified source path to the
+ * specified destination. The source path can refer to either a file or a
+ * directory. All intermediate directories in the destination path must
+ * already exist. If the source path refers to a file, the destination path
+ * must contain a full filename path, rather than just the new parent
+ * directory. If an object already exists at the specified destination path,
+ * this function causes it to be unlinked prior to the rename (i.e., the
+ * destination gets clobbered).
+ *
+ * @param from The source path.
+ * @param to The destination path.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+static int
+nffs_rename(const char *from, const char *to)
+{
+ int rc;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ rc = nffs_path_rename(from, to);
+ if (rc != 0) {
+ goto done;
+ }
+
+ rc = 0;
+
+done:
+ nffs_unlock();
+ return rc;
+}
+
+/**
+ * Creates the directory represented by the specified path. All intermediate
+ * directories must already exist. The specified path must start with a '/'
+ * character.
+ *
+ * @param path The name of the directory to create.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+static int
+nffs_mkdir(const char *path)
+{
+ int rc;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ rc = nffs_path_new_dir(path, NULL);
+ if (rc != 0) {
+ goto done;
+ }
+
+done:
+ nffs_unlock();
+ return rc;
+}
+
+/**
+ * Opens the directory at the specified path. The directory's contents can be
+ * read with subsequent calls to nffs_readdir(). When you are done with the
+ * directory handle, close it with nffs_closedir().
+ *
+ * Unlinking files from the directory while it is open may result in
+ * unpredictable behavior. New files can be created inside the directory.
+ *
+ * @param path The name of the directory to open.
+ * @param out_dir On success, points to the directory handle.
+ *
+ * @return 0 on success;
+ * FS_ENOENT if the specified directory does not
+ * exist;
+ * other nonzero on error.
+ */
+static int
+nffs_opendir(const char *path, struct fs_dir **out_fs_dir)
+{
+ int rc;
+ struct nffs_dir **out_dir = (struct nffs_dir **)out_fs_dir;
+ char *filepath = NULL;
+
+ nffs_lock();
+
+ if (!nffs_misc_ready()) {
+ rc = FS_EUNINIT;
+ goto done;
+ }
+
+ filepath = disk_filepath_from_path(path);
+
+ rc = nffs_dir_open(filepath, out_dir);
+
+done:
+ if (filepath) {
+ free(filepath);
+ }
+ nffs_unlock();
+ if (rc != 0) {
+ *out_dir = NULL;
+ }
+ return rc;
+}
+
+/**
+ * Reads the next entry in an open directory.
+ *
+ * @param dir The directory handle to read from.
+ * @param out_dirent On success, points to the next child entry in
+ * the specified directory.
+ *
+ * @return 0 on success;
+ * FS_ENOENT if there are no more entries in the
+ * parent directory;
+ * other nonzero on error.
+ */
+static int
+nffs_readdir(struct fs_dir *fs_dir, struct fs_dirent **out_fs_dirent)
+{
+ int rc;
+ struct nffs_dir *dir = (struct nffs_dir *)fs_dir;
+ struct nffs_dirent **out_dirent = (struct nffs_dirent **)out_fs_dirent;
+
+ nffs_lock();
+ rc = nffs_dir_read(dir, out_dirent);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Closes the specified directory handle.
+ *
+ * @param dir The name of the directory to close.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_closedir(struct fs_dir *fs_dir)
+{
+ int rc;
+ struct nffs_dir *dir = (struct nffs_dir *)fs_dir;
+
+ nffs_lock();
+ rc = nffs_dir_close(dir);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Retrieves the filename of the specified directory entry. The retrieved
+ * filename is always null-terminated. To ensure enough space to hold the full
+ * filename plus a null-termintor, a destination buffer of size
+ * (NFFS_FILENAME_MAX_LEN + 1) should be used.
+ *
+ * @param dirent The directory entry to query.
+ * @param max_len The size of the "out_name" character buffer.
+ * @param out_name On success, the entry's filename is written
+ * here; always null-terminated.
+ * @param out_name_len On success, contains the actual length of the
+ * filename, NOT including the
+ * null-terminator.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_dirent_name(const struct fs_dirent *fs_dirent, size_t max_len,
+ char *out_name, uint8_t *out_name_len)
+{
+ int rc;
+ struct nffs_dirent *dirent = (struct nffs_dirent *)fs_dirent;
+
+ nffs_lock();
+
+ assert(dirent != NULL && dirent->nde_inode_entry != NULL);
+ rc = nffs_inode_read_filename(dirent->nde_inode_entry, max_len, out_name,
+ out_name_len);
+
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Tells you whether the specified directory entry is a sub-directory or a
+ * regular file.
+ *
+ * @param dirent The directory entry to query.
+ *
+ * @return 1: The entry is a directory;
+ * 0: The entry is a regular file.
+ */
+static int
+nffs_dirent_is_dir(const struct fs_dirent *fs_dirent)
+{
+ uint32_t id;
+ const struct nffs_dirent *dirent = (const struct nffs_dirent *)fs_dirent;
+
+ nffs_lock();
+
+ assert(dirent != NULL && dirent->nde_inode_entry != NULL);
+ id = dirent->nde_inode_entry->nie_hash_entry.nhe_id;
+
+ nffs_unlock();
+
+ return nffs_hash_id_is_dir(id);
+}
+
+/**
+ * Erases all the specified areas and initializes them with a clean nffs
+ * file system.
+ *
+ * @param area_descs The set of areas to format.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int
+nffs_format(const struct nffs_area_desc *area_descs)
+{
+ int rc;
+
+ nffs_lock();
+ rc = nffs_format_full(area_descs);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Searches for a valid nffs file system among the specified areas. This
+ * function succeeds if a file system is detected among any subset of the
+ * supplied areas. If the area set does not contain a valid file system,
+ * a new one can be created via a separate call to nffs_format().
+ *
+ * @param area_descs The area set to search. This array must be
+ * terminated with a 0-length area.
+ *
+ * @return 0 on success;
+ * FS_ECORRUPT if no valid file system was detected;
+ * other nonzero on error.
+ */
+int
+nffs_detect(const struct nffs_area_desc *area_descs)
+{
+ int rc;
+
+ nffs_lock();
+ rc = nffs_restore_full(area_descs);
+ nffs_unlock();
+
+ return rc;
+}
+
+/**
+ * Initializes internal nffs memory and data structures. This must be called
+ * before any nffs operations are attempted.
+ *
+ * @return 0 on success; nonzero on error.
+ */
+int
+nffs_init(void)
+{
+ int rc;
+
+ nffs_config_init();
+
+ nffs_cache_clear();
+
+ rc = nffs_stats_init();
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mutex_init(&nffs_mutex);
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ free(nffs_file_mem);
+ nffs_file_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_files, sizeof (struct nffs_file)));
+ if (nffs_file_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ free(nffs_inode_mem);
+ nffs_inode_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_inodes,
+ sizeof (struct nffs_inode_entry)));
+ if (nffs_inode_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ free(nffs_block_entry_mem);
+ nffs_block_entry_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_blocks,
+ sizeof (struct nffs_hash_entry)));
+ if (nffs_block_entry_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ free(nffs_cache_inode_mem);
+ nffs_cache_inode_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_inodes,
+ sizeof (struct nffs_cache_inode)));
+ if (nffs_cache_inode_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ free(nffs_cache_block_mem);
+ nffs_cache_block_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_blocks,
+ sizeof (struct nffs_cache_block)));
+ if (nffs_cache_block_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ free(nffs_dir_mem);
+ nffs_dir_mem = malloc(
+ OS_MEMPOOL_BYTES(nffs_config.nc_num_dirs,
+ sizeof (struct nffs_dir)));
+ if (nffs_dir_mem == NULL) {
+ return FS_ENOMEM;
+ }
+
+ rc = nffs_misc_reset();
+ if (rc != 0) {
+ return rc;
+ }
+
+ fs_register(&nffs_ops);
+ return 0;
+}
+
+void
+nffs_pkg_init(void)
+{
+ struct nffs_area_desc descs[MYNEWT_VAL(NFFS_NUM_AREAS) + 1];
+ int cnt;
+ int rc;
+
+ /* Ensure this function only gets called by sysinit. */
+ SYSINIT_ASSERT_ACTIVE();
+
+ /* Initialize nffs's internal state. */
+ rc = nffs_init();
+ SYSINIT_PANIC_ASSERT(rc == 0);
+
+ /* Convert the set of flash blocks we intend to use for nffs into an array
+ * of nffs area descriptors.
+ */
+ cnt = MYNEWT_VAL(NFFS_NUM_AREAS);
+ rc = nffs_misc_desc_from_flash_area(
+ MYNEWT_VAL(NFFS_FLASH_AREA), &cnt, descs);
+ SYSINIT_PANIC_ASSERT(rc == 0);
+
+ /* Attempt to restore an existing nffs file system from flash. */
+ rc = nffs_detect(descs);
+ switch (rc) {
+ case 0:
+ break;
+
+ case FS_ECORRUPT:
+ /* No valid nffs instance detected; act based on configued detection
+ * failure policy.
+ */
+ switch (MYNEWT_VAL(NFFS_DETECT_FAIL)) {
+ case NFFS_DETECT_FAIL_IGNORE:
+ break;
+
+ case NFFS_DETECT_FAIL_FORMAT:
+ rc = nffs_format(descs);
+ SYSINIT_PANIC_ASSERT(rc == 0);
+ break;
+
+ default:
+ SYSINIT_PANIC();
+ break;
+ }
+ break;
+
+ default:
+ SYSINIT_PANIC();
+ break;
+ }
+}
diff --git a/src/nffs_area.c b/src/nffs_area.c
new file mode 100644
index 0000000..87b0dbf
--- /dev/null
+++ b/src/nffs_area.c
@@ -0,0 +1,118 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+
+static void
+nffs_area_set_magic(struct nffs_disk_area *disk_area)
+{
+ disk_area->nda_magic[0] = NFFS_AREA_MAGIC0;
+ disk_area->nda_magic[1] = NFFS_AREA_MAGIC1;
+ disk_area->nda_magic[2] = NFFS_AREA_MAGIC2;
+ disk_area->nda_magic[3] = NFFS_AREA_MAGIC3;
+}
+
+int
+nffs_area_magic_is_set(const struct nffs_disk_area *disk_area)
+{
+ return disk_area->nda_magic[0] == NFFS_AREA_MAGIC0 &&
+ disk_area->nda_magic[1] == NFFS_AREA_MAGIC1 &&
+ disk_area->nda_magic[2] == NFFS_AREA_MAGIC2 &&
+ disk_area->nda_magic[3] == NFFS_AREA_MAGIC3;
+}
+
+int
+nffs_area_is_scratch(const struct nffs_disk_area *disk_area)
+{
+ return nffs_area_magic_is_set(disk_area) &&
+ disk_area->nda_id == NFFS_AREA_ID_NONE;
+}
+
+int
+nffs_area_is_current_version(const struct nffs_disk_area *disk_area)
+{
+ return disk_area->nda_ver == NFFS_AREA_VER;
+}
+
+void
+nffs_area_to_disk(const struct nffs_area *area,
+ struct nffs_disk_area *out_disk_area)
+{
+ memset(out_disk_area, 0, sizeof *out_disk_area);
+ nffs_area_set_magic(out_disk_area);
+ out_disk_area->nda_length = area->na_length;
+ out_disk_area->nda_ver = NFFS_AREA_VER;
+ out_disk_area->nda_gc_seq = area->na_gc_seq;
+ out_disk_area->nda_id = area->na_id;
+}
+
+uint32_t
+nffs_area_free_space(const struct nffs_area *area)
+{
+ return area->na_length - area->na_cur;
+}
+
+/**
+ * Finds a corrupt scratch area. An area is indentified as a corrupt scratch
+ * area if it and another area share the same ID. Among two areas with the
+ * same ID, the one with fewer bytes written is the corrupt scratch area.
+ *
+ * @param out_good_idx On success, the index of the good area (longer
+ * of the two areas) gets written here.
+ * @param out_bad_idx On success, the index of the corrupt scratch
+ * area gets written here.
+ *
+ * @return 0 if a corrupt scratch area was identified;
+ * FS_ENOENT if one was not found.
+ */
+int
+nffs_area_find_corrupt_scratch(uint16_t *out_good_idx, uint16_t *out_bad_idx)
+{
+ const struct nffs_area *iarea;
+ const struct nffs_area *jarea;
+ int i;
+ int j;
+
+ for (i = 0; i < nffs_num_areas; i++) {
+ iarea = nffs_areas + i;
+ for (j = i + 1; j < nffs_num_areas; j++) {
+ jarea = nffs_areas + j;
+
+ if (jarea->na_id == iarea->na_id) {
+ /* Found a duplicate. The shorter of the two areas should be
+ * used as scratch.
+ */
+ if (iarea->na_cur < jarea->na_cur) {
+ *out_good_idx = j;
+ *out_bad_idx = i;
+ } else {
+ *out_good_idx = i;
+ *out_bad_idx = j;
+ }
+
+ return 0;
+ }
+ }
+ }
+
+ return FS_ENOENT;
+}
diff --git a/src/nffs_block.c b/src/nffs_block.c
new file mode 100644
index 0000000..f7d5847
--- /dev/null
+++ b/src/nffs_block.c
@@ -0,0 +1,456 @@
+/*
+ * 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 <stddef.h>
+#include <assert.h>
+#include <string.h>
+#include "testutil/testutil.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+struct nffs_hash_entry *
+nffs_block_entry_alloc(void)
+{
+ struct nffs_hash_entry *entry;
+
+ entry = os_memblock_get(&nffs_block_entry_pool);
+ if (entry != NULL) {
+ memset(entry, 0, sizeof *entry);
+ }
+
+ return entry;
+}
+
+void
+nffs_block_entry_free(struct nffs_hash_entry *block_entry)
+{
+ assert(nffs_hash_id_is_block(block_entry->nhe_id));
+ os_memblock_put(&nffs_block_entry_pool, block_entry);
+}
+
+/**
+ * Allocates a block entry. If allocation fails due to memory exhaustion,
+ * garbage collection is performed and the allocation is retried. This
+ * process is repeated until allocation is successful or all areas have been
+ * garbage collected.
+ *
+ * @param out_block_entry On success, the address of the allocated
+ * block gets written here.
+ *
+ * @return 0 on successful allocation;
+ * FS_ENOMEM on memory exhaustion;
+ * other nonzero on garbage collection error.
+ */
+int
+nffs_block_entry_reserve(struct nffs_hash_entry **out_block_entry)
+{
+ int rc;
+
+ do {
+ *out_block_entry = nffs_block_entry_alloc();
+ } while (nffs_misc_gc_if_oom(*out_block_entry, &rc));
+
+ return rc;
+}
+
+/**
+ * Reads a data block header from flash.
+ *
+ * @param area_idx The index of the area to read from.
+ * @param area_offset The offset within the area to read from.
+ * @param out_disk_block On success, the block header is writteh here.
+ *
+ * @return 0 on success;
+ * FS_EOFFSET on an attempt to read an invalid
+ * address range;
+ * FS_EHW on flash error;
+ * FS_EUNEXP if the specified disk location does
+ * not contain a block.
+ */
+int
+nffs_block_read_disk(uint8_t area_idx, uint32_t area_offset,
+ struct nffs_disk_block *out_disk_block)
+{
+ int rc;
+
+ STATS_INC(nffs_stats, nffs_readcnt_block);
+ rc = nffs_flash_read(area_idx, area_offset, out_disk_block,
+ sizeof *out_disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+ if (!nffs_hash_id_is_block(out_disk_block->ndb_id)) {
+ return FS_EUNEXP;
+ }
+
+ return 0;
+}
+
+/**
+ * Writes the specified data block to a suitable location in flash.
+ *
+ * @param disk_block Points to the disk block to write.
+ * @param data The contents of the data block.
+ * @param out_area_idx On success, contains the index of the area
+ * written to.
+ * @param out_area_offset On success, contains the offset within the area
+ * written to.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_block_write_disk(const struct nffs_disk_block *disk_block,
+ const void *data,
+ uint8_t *out_area_idx, uint32_t *out_area_offset)
+{
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ rc = nffs_misc_reserve_space(sizeof *disk_block + disk_block->ndb_data_len,
+ &area_idx, &area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_flash_write(area_idx, area_offset, disk_block,
+ sizeof *disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (disk_block->ndb_data_len > 0) {
+ rc = nffs_flash_write(area_idx, area_offset + sizeof *disk_block,
+ data, disk_block->ndb_data_len);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ *out_area_idx = area_idx;
+ *out_area_offset = area_offset;
+
+ ASSERT_IF_TEST(nffs_crc_disk_block_validate(disk_block, area_idx,
+ area_offset) == 0);
+
+ return 0;
+}
+
+static void
+nffs_block_from_disk_no_ptrs(struct nffs_block *out_block,
+ const struct nffs_disk_block *disk_block)
+{
+ out_block->nb_seq = disk_block->ndb_seq;
+ out_block->nb_inode_entry = NULL;
+ out_block->nb_prev = NULL;
+ out_block->nb_data_len = disk_block->ndb_data_len;
+}
+
+/**
+ * Constructs a block representation from a disk record. If the disk block
+ * references other objects (inode or previous data block), the resulting block
+ * object is populated with pointers to the referenced objects. If the any
+ * referenced objects are not present in the NFFS RAM representation, this
+ * indicates file system corruption. In this case, the resulting block is
+ * populated with all valid references, and an FS_ECORRUPT code is returned.
+ *
+ * @param out_block The resulting block is written here (regardless
+ * of this function's return code).
+ * @param disk_block The source disk record to convert.
+ *
+ * @return 0 if the block was successfully constructed;
+ * FS_ECORRUPT if one or more pointers could not
+ * be filled in due to file system corruption.
+ */
+static int
+nffs_block_from_disk(struct nffs_block *out_block,
+ const struct nffs_disk_block *disk_block)
+{
+ int rc;
+
+ rc = 0;
+
+ nffs_block_from_disk_no_ptrs(out_block, disk_block);
+
+ out_block->nb_inode_entry = nffs_hash_find_inode(disk_block->ndb_inode_id);
+ if (out_block->nb_inode_entry == NULL) {
+ rc = FS_ECORRUPT;
+ }
+
+ if (disk_block->ndb_prev_id != NFFS_ID_NONE) {
+ out_block->nb_prev = nffs_hash_find_block(disk_block->ndb_prev_id);
+ if (out_block->nb_prev == NULL) {
+ rc = FS_ECORRUPT;
+ }
+ }
+
+ return rc;
+}
+
+/**
+ * Constructs a disk-representation of the specified data block.
+ *
+ * @param block The source block to convert.
+ * @param out_disk_block The disk block to write to.
+ */
+void
+nffs_block_to_disk(const struct nffs_block *block,
+ struct nffs_disk_block *out_disk_block)
+{
+ assert(block->nb_inode_entry != NULL);
+
+ memset(out_disk_block, 0, sizeof *out_disk_block);
+ out_disk_block->ndb_id = block->nb_hash_entry->nhe_id;
+ out_disk_block->ndb_seq = block->nb_seq;
+ out_disk_block->ndb_inode_id =
+ block->nb_inode_entry->nie_hash_entry.nhe_id;
+ if (block->nb_prev == NULL) {
+ out_disk_block->ndb_prev_id = NFFS_ID_NONE;
+ } else {
+ out_disk_block->ndb_prev_id = block->nb_prev->nhe_id;
+ }
+ out_disk_block->ndb_data_len = block->nb_data_len;
+}
+
+/**
+ * Deletes the specified block entry from the nffs RAM representation.
+ *
+ * @param block_entry The block entry to delete.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_block_delete_from_ram(struct nffs_hash_entry *block_entry)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_block block;
+ int rc;
+
+ if (nffs_hash_entry_is_dummy(block_entry)) {
+ /*
+ * it's very limited to what we can do here as the block doesn't have
+ * any way to get to the inode via hash entry. Just delete the
+ * block and return FS_ECORRUPT
+ */
+ nffs_hash_remove(block_entry);
+ nffs_block_entry_free(block_entry);
+ return FS_ECORRUPT;
+ }
+
+ rc = nffs_block_from_hash_entry(&block, block_entry);
+ if (rc == 0 || rc == FS_ECORRUPT) {
+ /* If file system corruption was detected, the resulting block is still
+ * valid and can be removed from RAM.
+ * Note that FS_CORRUPT can occur because the owning inode was not
+ * found in the hash table - this can occur during the sweep where
+ * the inodes were deleted ahead of the blocks.
+ */
+ inode_entry = block.nb_inode_entry;
+ if (inode_entry != NULL &&
+ inode_entry->nie_last_block_entry == block_entry) {
+
+ inode_entry->nie_last_block_entry = block.nb_prev;
+ }
+
+ nffs_hash_remove(block_entry);
+ nffs_block_entry_free(block_entry);
+ }
+
+ return rc;
+}
+
+/**
+ * Determines if a particular block can be found in RAM by following a chain of
+ * previous block pointers, starting with the specified hash entry.
+ *
+ * @param start The block entry at which to start the search.
+ * @param sought_id The ID of the block to search for.
+ *
+ * @return 0 if the sought after ID was found;
+ * FS_ENOENT if the ID was not found;
+ * Other FS code on error.
+ */
+int
+nffs_block_find_predecessor(struct nffs_hash_entry *start, uint32_t sought_id)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_disk_block disk_block;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ entry = start;
+ while (entry != NULL && entry->nhe_id != sought_id) {
+ nffs_flash_loc_expand(entry->nhe_flash_loc, &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (disk_block.ndb_prev_id == NFFS_ID_NONE) {
+ entry = NULL;
+ } else {
+ entry = nffs_hash_find(disk_block.ndb_prev_id);
+ }
+ }
+
+ if (entry == NULL) {
+ rc = FS_ENOENT;
+ } else {
+ rc = 0;
+ }
+
+ return rc;
+}
+
+/**
+ * Constructs a full data block representation from the specified minimal
+ * block entry. However, the resultant block's pointers are set to null,
+ * rather than populated via hash table lookups. This behavior is useful when
+ * the RAM representation has not been fully constructed yet.
+ *
+ * @param out_block On success, this gets populated with the data
+ * block information.
+ * @param block_entry The source block entry to convert.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_block_from_hash_entry_no_ptrs(struct nffs_block *out_block,
+ struct nffs_hash_entry *block_entry)
+{
+ struct nffs_disk_block disk_block;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ assert(nffs_hash_id_is_block(block_entry->nhe_id));
+
+ memset(out_block, 0, sizeof *out_block);
+
+ if (nffs_hash_entry_is_dummy(block_entry)) {
+ /*
+ * We can't read this from disk so we'll be missing filling in anything
+ * not already in inode_entry (e.g., prev_id).
+ */
+ out_block->nb_hash_entry = block_entry;
+ return FS_ENOENT; /* let caller know it's a partial inode_entry */
+ }
+
+ nffs_flash_loc_expand(block_entry->nhe_flash_loc, &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ out_block->nb_hash_entry = block_entry;
+ nffs_block_from_disk_no_ptrs(out_block, &disk_block);
+
+ return 0;
+}
+
+/**
+ * Constructs a block representation from a minimal block hash entry. If the
+ * hash entry references other objects (inode or previous data block), the
+ * resulting block object is populated with pointers to the referenced objects.
+ * If the any referenced objects are not present in the NFFS RAM
+ * representation, this indicates file system corruption. In this case, the
+ * resulting block is populated with all valid references, and an FS_ECORRUPT
+ * code is returned.
+ *
+ * @param out_block On success, this gets populated with the data
+ * block information.
+ * @param block_entry The source block entry to convert.
+ *
+ * @return 0 on success;
+ * FS_ECORRUPT if one or more pointers could not
+ * be filled in due to file system corruption;
+ * FS_EOFFSET on an attempt to read an invalid
+ * address range;
+ * FS_EHW on flash error;
+ * FS_EUNEXP if the specified disk location does
+ * not contain a block.
+ */
+int
+nffs_block_from_hash_entry(struct nffs_block *out_block,
+ struct nffs_hash_entry *block_entry)
+{
+ struct nffs_disk_block disk_block;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ assert(nffs_hash_id_is_block(block_entry->nhe_id));
+
+ if (nffs_block_is_dummy(block_entry)) {
+ out_block->nb_hash_entry = block_entry;
+ out_block->nb_inode_entry = NULL;
+ out_block->nb_prev = NULL;
+ /*
+ * Dummy block added when inode was read in before real block
+ * (see nffs_restore_inode()). Return success (because there's
+ * too many places that ned to check for this,
+ * but it's the responsibility fo the upstream code to check
+ * whether this is still a dummy entry. XXX
+ */
+ return 0;
+ /*return FS_ENOENT;*/
+ }
+ nffs_flash_loc_expand(block_entry->nhe_flash_loc, &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ out_block->nb_hash_entry = block_entry;
+ rc = nffs_block_from_disk(out_block, &disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+int
+nffs_block_read_data(const struct nffs_block *block, uint16_t offset,
+ uint16_t length, void *dst)
+{
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ nffs_flash_loc_expand(block->nb_hash_entry->nhe_flash_loc,
+ &area_idx, &area_offset);
+ area_offset += sizeof (struct nffs_disk_block);
+ area_offset += offset;
+
+ STATS_INC(nffs_stats, nffs_readcnt_data);
+ rc = nffs_flash_read(area_idx, area_offset, dst, length);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+int
+nffs_block_is_dummy(struct nffs_hash_entry *entry)
+{
+ return (entry->nhe_flash_loc == NFFS_FLASH_LOC_NONE);
+}
diff --git a/src/nffs_cache.c b/src/nffs_cache.c
new file mode 100644
index 0000000..b50750f
--- /dev/null
+++ b/src/nffs_cache.c
@@ -0,0 +1,511 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+TAILQ_HEAD(nffs_cache_inode_list, nffs_cache_inode);
+static struct nffs_cache_inode_list nffs_cache_inode_list =
+ TAILQ_HEAD_INITIALIZER(nffs_cache_inode_list);
+
+static void nffs_cache_reclaim_blocks(void);
+
+static struct nffs_cache_block *
+nffs_cache_block_alloc(void)
+{
+ struct nffs_cache_block *entry;
+
+ entry = os_memblock_get(&nffs_cache_block_pool);
+ if (entry != NULL) {
+ memset(entry, 0, sizeof *entry);
+ }
+
+ return entry;
+}
+
+static void
+nffs_cache_block_free(struct nffs_cache_block *entry)
+{
+ if (entry != NULL) {
+ os_memblock_put(&nffs_cache_block_pool, entry);
+ }
+}
+
+static struct nffs_cache_block *
+nffs_cache_block_acquire(void)
+{
+ struct nffs_cache_block *cache_block;
+
+ cache_block = nffs_cache_block_alloc();
+ if (cache_block == NULL) {
+ nffs_cache_reclaim_blocks();
+ cache_block = nffs_cache_block_alloc();
+ }
+
+ assert(cache_block != NULL);
+
+ return cache_block;
+}
+
+static int
+nffs_cache_block_populate(struct nffs_cache_block *cache_block,
+ struct nffs_hash_entry *block_entry,
+ uint32_t end_offset)
+{
+ int rc;
+
+ rc = nffs_block_from_hash_entry(&cache_block->ncb_block, block_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ cache_block->ncb_file_offset = end_offset -
+ cache_block->ncb_block.nb_data_len;
+
+ return 0;
+}
+
+static struct nffs_cache_inode *
+nffs_cache_inode_alloc(void)
+{
+ struct nffs_cache_inode *entry;
+
+ entry = os_memblock_get(&nffs_cache_inode_pool);
+ if (entry != NULL) {
+ memset(entry, 0, sizeof *entry);
+ TAILQ_INIT(&entry->nci_block_list);
+ }
+
+ return entry;
+}
+
+static void
+nffs_cache_inode_free_blocks(struct nffs_cache_inode *cache_inode)
+{
+ struct nffs_cache_block *cache_block;
+
+ while ((cache_block = TAILQ_FIRST(&cache_inode->nci_block_list)) != NULL) {
+ TAILQ_REMOVE(&cache_inode->nci_block_list, cache_block, ncb_link);
+ nffs_cache_block_free(cache_block);
+ }
+}
+
+static void
+nffs_cache_inode_free(struct nffs_cache_inode *entry)
+{
+ if (entry != NULL) {
+ nffs_cache_inode_free_blocks(entry);
+ os_memblock_put(&nffs_cache_inode_pool, entry);
+ }
+}
+
+static struct nffs_cache_inode *
+nffs_cache_inode_acquire(void)
+{
+ struct nffs_cache_inode *entry;
+
+ entry = nffs_cache_inode_alloc();
+ if (entry == NULL) {
+ entry = TAILQ_LAST(&nffs_cache_inode_list, nffs_cache_inode_list);
+ assert(entry != NULL);
+
+ TAILQ_REMOVE(&nffs_cache_inode_list, entry, nci_link);
+ nffs_cache_inode_free(entry);
+
+ entry = nffs_cache_inode_alloc();
+ }
+
+ assert(entry != NULL);
+
+ return entry;
+}
+
+static int
+nffs_cache_inode_populate(struct nffs_cache_inode *cache_inode,
+ struct nffs_inode_entry *inode_entry)
+{
+ int rc;
+
+ memset(cache_inode, 0, sizeof *cache_inode);
+
+ rc = nffs_inode_from_entry(&cache_inode->nci_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_calc_data_length(cache_inode->nci_inode.ni_inode_entry,
+ &cache_inode->nci_file_size);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Retrieves the block entry corresponding to the last cached block in the
+ * specified inode's list. If the inode has no cached blocks, this function
+ * returns null.
+ */
+static struct nffs_hash_entry *
+nffs_cache_inode_last_entry(struct nffs_cache_inode *cache_inode)
+{
+ struct nffs_cache_block *cache_block;
+
+ if (TAILQ_EMPTY(&cache_inode->nci_block_list)) {
+ return NULL;
+ }
+
+ cache_block = TAILQ_LAST(&cache_inode->nci_block_list,
+ nffs_cache_block_list);
+ return cache_block->ncb_block.nb_hash_entry;
+}
+
+static struct nffs_cache_inode *
+nffs_cache_inode_find(const struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_cache_inode *cur;
+
+ TAILQ_FOREACH(cur, &nffs_cache_inode_list, nci_link) {
+ if (cur->nci_inode.ni_inode_entry == inode_entry) {
+ return cur;
+ }
+ }
+
+ return NULL;
+}
+
+void
+nffs_cache_inode_range(const struct nffs_cache_inode *cache_inode,
+ uint32_t *out_start, uint32_t *out_end)
+{
+ struct nffs_cache_block *cache_block;
+
+ cache_block = TAILQ_FIRST(&cache_inode->nci_block_list);
+ if (cache_block == NULL) {
+ *out_start = 0;
+ *out_end = 0;
+ return;
+ }
+
+ *out_start = cache_block->ncb_file_offset;
+
+ cache_block = TAILQ_LAST(&cache_inode->nci_block_list,
+ nffs_cache_block_list);
+ *out_end = cache_block->ncb_file_offset +
+ cache_block->ncb_block.nb_data_len;
+}
+
+static void
+nffs_cache_reclaim_blocks(void)
+{
+ struct nffs_cache_inode *cache_inode;
+
+ TAILQ_FOREACH_REVERSE(cache_inode, &nffs_cache_inode_list,
+ nffs_cache_inode_list, nci_link) {
+ if (!TAILQ_EMPTY(&cache_inode->nci_block_list)) {
+ nffs_cache_inode_free_blocks(cache_inode);
+ return;
+ }
+ }
+
+ assert(0);
+}
+
+void
+nffs_cache_inode_delete(const struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_cache_inode *entry;
+
+ entry = nffs_cache_inode_find(inode_entry);
+ if (entry == NULL) {
+ return;
+ }
+
+ TAILQ_REMOVE(&nffs_cache_inode_list, entry, nci_link);
+ nffs_cache_inode_free(entry);
+}
+
+int
+nffs_cache_inode_ensure(struct nffs_cache_inode **out_cache_inode,
+ struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_cache_inode *cache_inode;
+ int rc;
+
+ cache_inode = nffs_cache_inode_find(inode_entry);
+ if (cache_inode != NULL) {
+ rc = 0;
+ goto done;
+ }
+
+ cache_inode = nffs_cache_inode_acquire();
+ rc = nffs_cache_inode_populate(cache_inode, inode_entry);
+ if (rc != 0) {
+ goto done;
+ }
+
+ TAILQ_INSERT_HEAD(&nffs_cache_inode_list, cache_inode, nci_link);
+
+ rc = 0;
+
+done:
+ if (rc == 0) {
+ *out_cache_inode = cache_inode;
+ } else {
+ nffs_cache_inode_free(cache_inode);
+ *out_cache_inode = NULL;
+ }
+ return rc;
+}
+
+/**
+ * Recaches all cached inodes. All cached blocks are deleted from the cache
+ * during this operation. This function should be called after garbage
+ * collection occurs to ensure the cache is consistent.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_cache_inode_refresh(void)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_inode_entry *inode_entry;
+ int rc;
+
+ TAILQ_FOREACH(cache_inode, &nffs_cache_inode_list, nci_link) {
+ /* Clear entire block list. */
+ nffs_cache_inode_free_blocks(cache_inode);
+
+ inode_entry = cache_inode->nci_inode.ni_inode_entry;
+ rc = nffs_inode_from_entry(&cache_inode->nci_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* File size remains valid. */
+ }
+
+ return 0;
+}
+
+static void
+nffs_cache_log_block(struct nffs_cache_inode *cache_inode,
+ struct nffs_cache_block *cache_block)
+{
+ NFFS_LOG(DEBUG, "id=%u inode=%u flash_off=0x%08x "
+ "file_off=%u len=%d (entry=%p)\n",
+ (unsigned int)cache_block->ncb_block.nb_hash_entry->nhe_id,
+ (unsigned int)cache_inode->nci_inode.ni_inode_entry->nie_hash_entry.nhe_id,
+ (unsigned int)cache_block->ncb_block.nb_hash_entry->nhe_flash_loc,
+ (unsigned int)cache_block->ncb_file_offset,
+ cache_block->ncb_block.nb_data_len,
+ cache_block->ncb_block.nb_hash_entry);
+}
+
+static void
+nffs_cache_log_insert_block(struct nffs_cache_inode *cache_inode,
+ struct nffs_cache_block *cache_block,
+ int tail)
+{
+ NFFS_LOG(DEBUG, "caching block (%s): ", tail ? "tail" : "head");
+ nffs_cache_log_block(cache_inode, cache_block);
+}
+
+void
+nffs_cache_insert_block(struct nffs_cache_inode *cache_inode,
+ struct nffs_cache_block *cache_block,
+ int tail)
+{
+ if (tail) {
+ TAILQ_INSERT_TAIL(&cache_inode->nci_block_list, cache_block, ncb_link);
+ } else {
+ TAILQ_INSERT_HEAD(&cache_inode->nci_block_list, cache_block, ncb_link);
+ }
+
+ nffs_cache_log_insert_block(cache_inode, cache_block, tail);
+}
+
+/**
+ * Finds the data block containing the specified offset within a file inode.
+ * If the block is not yet cached, it gets cached as a result of this
+ * operation. This function modifies the inode's cached block list according
+ * to the following procedure:
+ *
+ * 1. If none of the owning inode's blocks are currently cached, allocate a
+ * cached block entry and insert it into the inode's list.
+ * 2. Else if the requested file offset is less than that of the first cached
+ * block, bridge the gap between the inode's sequence of cached blocks and
+ * the block that now needs to be cached. This is accomplished by caching
+ * each block in the gap, finishing with the requested block.
+ * 3. Else (the requested offset is beyond the end of the cache),
+ * a. If the requested offset belongs to the block that immediately
+ * follows the end of the cache, cache the block and append it to the
+ * list.
+ * b. Else, clear the cache, and populate it with the single entry
+ * corresponding to the requested block.
+ *
+ * @param cache_inode The cached file inode to seek within.
+ * @param seek_offset The file offset to seek to.
+ * @param out_cache_block On success, the requested cached block gets
+ * written here; pass null if you don't need
+ * this.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_cache_seek(struct nffs_cache_inode *cache_inode, uint32_t seek_offset,
+ struct nffs_cache_block **out_cache_block)
+{
+ struct nffs_cache_block *cache_block;
+ struct nffs_hash_entry *last_cached_entry;
+ struct nffs_hash_entry *block_entry;
+ struct nffs_hash_entry *pred_entry;
+ struct nffs_block block;
+ uint32_t cache_start;
+ uint32_t cache_end;
+ uint32_t block_start;
+ uint32_t block_end;
+ int rc;
+
+ /* Empty files have no blocks that can be cached. */
+ if (cache_inode->nci_file_size == 0) {
+ return FS_ENOENT;
+ }
+
+ nffs_cache_inode_range(cache_inode, &cache_start, &cache_end);
+ if (cache_end != 0 && seek_offset < cache_start) {
+ /* Seeking prior to cache. Iterate backwards from cache start. */
+ cache_block = TAILQ_FIRST(&cache_inode->nci_block_list);
+ block_entry = cache_block->ncb_block.nb_prev;
+ block_end = cache_block->ncb_file_offset;
+ cache_block = NULL;
+ } else if (seek_offset < cache_end) {
+ /* Seeking within cache. Iterate backwards from cache end. */
+ cache_block = TAILQ_LAST(&cache_inode->nci_block_list,
+ nffs_cache_block_list);
+ block_entry = cache_block->ncb_block.nb_hash_entry;
+ block_end = cache_end;
+ } else {
+ /* Seeking beyond end of cache. Iterate backwards from file end. If
+ * sought-after block is adjacent to cache end, its cache entry will
+ * get appended to the current cache. Otherwise, the current cache
+ * will be freed and replaced with the single requested block.
+ */
+ cache_block = NULL;
+ block_entry =
+ cache_inode->nci_inode.ni_inode_entry->nie_last_block_entry;
+ block_end = cache_inode->nci_file_size;
+ }
+
+ /* Scan backwards until we find the block containing the seek offest. */
+ while (1) {
+ if (block_end <= cache_start) {
+ /* We are looking before the start of the cache. Allocate a new
+ * cache block and prepend it to the cache.
+ */
+ assert(cache_block == NULL);
+ cache_block = nffs_cache_block_acquire();
+ rc = nffs_cache_block_populate(cache_block, block_entry,
+ block_end);
+ if (rc != 0) {
+ return rc;
+ }
+
+ nffs_cache_insert_block(cache_inode, cache_block, 0);
+ }
+
+ /* Calculate the file offset of the start of this block. This is used
+ * to determine if this block contains the sought-after offset.
+ */
+ if (cache_block != NULL) {
+ /* Current block is cached. */
+ block_start = cache_block->ncb_file_offset;
+ pred_entry = cache_block->ncb_block.nb_prev;
+ } else {
+ /* We are looking beyond the end of the cache. Read the data block
+ * from flash.
+ */
+ rc = nffs_block_from_hash_entry(&block, block_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ block_start = block_end - block.nb_data_len;
+ pred_entry = block.nb_prev;
+ }
+
+ if (block_start <= seek_offset) {
+ /* This block contains the requested address; iteration is
+ * complete.
+ */
+ if (cache_block == NULL) {
+ /* The block isn't cached, so it must come after the cache end.
+ * Append it to the cache if it directly follows. Otherwise,
+ * erase the current cache and populate it with this single
+ * block.
+ */
+ cache_block = nffs_cache_block_acquire();
+ cache_block->ncb_block = block;
+ cache_block->ncb_file_offset = block_start;
+
+ last_cached_entry = nffs_cache_inode_last_entry(cache_inode);
+ if (last_cached_entry != NULL &&
+ last_cached_entry == pred_entry) {
+
+ nffs_cache_insert_block(cache_inode, cache_block, 1);
+ } else {
+ nffs_cache_inode_free_blocks(cache_inode);
+ nffs_cache_insert_block(cache_inode, cache_block, 0);
+ }
+ }
+
+ if (out_cache_block != NULL) {
+ *out_cache_block = cache_block;
+ }
+ break;
+ }
+
+ /* Prepare for next iteration. */
+ if (cache_block != NULL) {
+ cache_block = TAILQ_PREV(cache_block, nffs_cache_block_list,
+ ncb_link);
+ }
+ block_entry = pred_entry;
+ block_end = block_start;
+ }
+
+ return 0;
+}
+
+/**
+ * Frees all cached inodes and blocks.
+ */
+void
+nffs_cache_clear(void)
+{
+ struct nffs_cache_inode *entry;
+
+ while ((entry = TAILQ_FIRST(&nffs_cache_inode_list)) != NULL) {
+ TAILQ_REMOVE(&nffs_cache_inode_list, entry, nci_link);
+ nffs_cache_inode_free(entry);
+ }
+}
diff --git a/src/nffs_config.c b/src/nffs_config.c
new file mode 100644
index 0000000..6ff6177
--- /dev/null
+++ b/src/nffs_config.c
@@ -0,0 +1,54 @@
+/*
+ * 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 "nffs/nffs.h"
+
+struct nffs_config nffs_config;
+
+const struct nffs_config nffs_config_dflt = {
+ .nc_num_inodes = 100,
+ .nc_num_blocks = 100,
+ .nc_num_files = 4,
+ .nc_num_cache_inodes = 4,
+ .nc_num_cache_blocks = 64,
+ .nc_num_dirs = 4,
+};
+
+void
+nffs_config_init(void)
+{
+ if (nffs_config.nc_num_inodes == 0) {
+ nffs_config.nc_num_inodes = nffs_config_dflt.nc_num_inodes;
+ }
+ if (nffs_config.nc_num_blocks == 0) {
+ nffs_config.nc_num_blocks = nffs_config_dflt.nc_num_blocks;
+ }
+ if (nffs_config.nc_num_files == 0) {
+ nffs_config.nc_num_files = nffs_config_dflt.nc_num_files;
+ }
+ if (nffs_config.nc_num_cache_inodes == 0) {
+ nffs_config.nc_num_cache_inodes = nffs_config_dflt.nc_num_cache_inodes;
+ }
+ if (nffs_config.nc_num_cache_blocks == 0) {
+ nffs_config.nc_num_cache_blocks = nffs_config_dflt.nc_num_cache_blocks;
+ }
+ if (nffs_config.nc_num_dirs == 0) {
+ nffs_config.nc_num_dirs = nffs_config_dflt.nc_num_dirs;
+ }
+}
diff --git a/src/nffs_crc.c b/src/nffs_crc.c
new file mode 100644
index 0000000..12a0a3a
--- /dev/null
+++ b/src/nffs_crc.c
@@ -0,0 +1,175 @@
+/*
+ * 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 "nffs_priv.h"
+
+int
+nffs_crc_flash(uint16_t initial_crc, uint8_t area_idx, uint32_t area_offset,
+ uint32_t len, uint16_t *out_crc)
+{
+ uint32_t chunk_len;
+ uint16_t crc;
+ int rc;
+
+ crc = initial_crc;
+
+ /* Copy data in chunks small enough to fit in the flash buffer. */
+ while (len > 0) {
+ if (len > sizeof nffs_flash_buf) {
+ chunk_len = sizeof nffs_flash_buf;
+ } else {
+ chunk_len = len;
+ }
+
+ STATS_INC(nffs_stats, nffs_readcnt_crc);
+ rc = nffs_flash_read(area_idx, area_offset, nffs_flash_buf, chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ crc = crc16_ccitt(crc, nffs_flash_buf, chunk_len);
+
+ area_offset += chunk_len;
+ len -= chunk_len;
+ }
+
+ *out_crc = crc;
+ return 0;
+}
+
+uint16_t
+nffs_crc_disk_block_hdr(const struct nffs_disk_block *disk_block)
+{
+ uint16_t crc;
+
+ crc = crc16_ccitt(0, disk_block, NFFS_DISK_BLOCK_OFFSET_CRC);
+
+ return crc;
+}
+
+static int
+nffs_crc_disk_block(const struct nffs_disk_block *disk_block,
+ uint8_t area_idx, uint32_t area_offset,
+ uint16_t *out_crc)
+{
+ uint16_t crc;
+ int rc;
+
+ crc = nffs_crc_disk_block_hdr(disk_block);
+
+ rc = nffs_crc_flash(crc, area_idx, area_offset + sizeof *disk_block,
+ disk_block->ndb_data_len, &crc);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *out_crc = crc;
+ return 0;
+}
+
+int
+nffs_crc_disk_block_validate(const struct nffs_disk_block *disk_block,
+ uint8_t area_idx, uint32_t area_offset)
+{
+ uint16_t crc;
+ int rc;
+
+ rc = nffs_crc_disk_block(disk_block, area_idx, area_offset, &crc);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (crc != disk_block->ndb_crc16) {
+ return FS_ECORRUPT;
+ }
+
+ return 0;
+}
+
+void
+nffs_crc_disk_block_fill(struct nffs_disk_block *disk_block, const void *data)
+{
+ uint16_t crc16;
+
+ crc16 = nffs_crc_disk_block_hdr(disk_block);
+ crc16 = crc16_ccitt(crc16, data, disk_block->ndb_data_len);
+
+ disk_block->ndb_crc16 = crc16;
+}
+
+static uint16_t
+nffs_crc_disk_inode_hdr(const struct nffs_disk_inode *disk_inode)
+{
+ uint16_t crc;
+
+ crc = crc16_ccitt(0, disk_inode, NFFS_DISK_INODE_OFFSET_CRC);
+
+ return crc;
+}
+
+static int
+nffs_crc_disk_inode(const struct nffs_disk_inode *disk_inode,
+ uint8_t area_idx, uint32_t area_offset,
+ uint16_t *out_crc)
+{
+ uint16_t crc;
+ int rc;
+
+ crc = nffs_crc_disk_inode_hdr(disk_inode);
+
+ rc = nffs_crc_flash(crc, area_idx, area_offset + sizeof *disk_inode,
+ disk_inode->ndi_filename_len, &crc);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *out_crc = crc;
+ return 0;
+}
+
+int
+nffs_crc_disk_inode_validate(const struct nffs_disk_inode *disk_inode,
+ uint8_t area_idx, uint32_t area_offset)
+{
+ uint16_t crc;
+ int rc;
+
+ rc = nffs_crc_disk_inode(disk_inode, area_idx, area_offset, &crc);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (crc != disk_inode->ndi_crc16) {
+ return FS_ECORRUPT;
+ }
+
+ return 0;
+}
+
+void
+nffs_crc_disk_inode_fill(struct nffs_disk_inode *disk_inode,
+ const char *filename)
+{
+ uint16_t crc16;
+
+ crc16 = nffs_crc_disk_inode_hdr(disk_inode);
+ crc16 = crc16_ccitt(crc16, filename, disk_inode->ndi_filename_len);
+
+ disk_inode->ndi_crc16 = crc16;
+}
diff --git a/src/nffs_dir.c b/src/nffs_dir.c
new file mode 100644
index 0000000..8cdefa9
--- /dev/null
+++ b/src/nffs_dir.c
@@ -0,0 +1,144 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+#include "fs/fs_if.h"
+
+struct fs_ops nffs_ops;
+
+static struct nffs_dir *
+nffs_dir_alloc(void)
+{
+ struct nffs_dir *dir;
+
+ dir = os_memblock_get(&nffs_dir_pool);
+ if (dir != NULL) {
+ memset(dir, 0, sizeof *dir);
+ }
+
+ return dir;
+}
+
+static int
+nffs_dir_free(struct nffs_dir *dir)
+{
+ int rc;
+
+ if (dir != NULL) {
+ rc = os_memblock_put(&nffs_dir_pool, dir);
+ if (rc != 0) {
+ return FS_EOS;
+ }
+ }
+
+ return 0;
+}
+
+int
+nffs_dir_open(const char *path, struct nffs_dir **out_dir)
+{
+ struct nffs_inode_entry *parent_inode_entry;
+ struct nffs_dir *dir;
+ int rc;
+
+ rc = nffs_path_find_inode_entry(path, &parent_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (!nffs_hash_id_is_dir(parent_inode_entry->nie_hash_entry.nhe_id)) {
+ return FS_EINVAL;
+ }
+
+ dir = nffs_dir_alloc();
+ if (dir == NULL) {
+ return FS_ENOMEM;
+ }
+
+ dir->nd_parent_inode_entry = parent_inode_entry;
+ nffs_inode_inc_refcnt(dir->nd_parent_inode_entry);
+ memset(&dir->nd_dirent, 0, sizeof dir->nd_dirent);
+ dir->fops = &nffs_ops;
+
+ *out_dir = dir;
+
+ return 0;
+}
+
+int
+nffs_dir_read(struct nffs_dir *dir, struct nffs_dirent **out_dirent)
+{
+ struct nffs_inode_entry *child;
+ int rc;
+
+ if (dir->nd_dirent.nde_inode_entry == NULL) {
+ child = SLIST_FIRST(&dir->nd_parent_inode_entry->nie_child_list);
+ } else {
+ child = SLIST_NEXT(dir->nd_dirent.nde_inode_entry, nie_sibling_next);
+ rc = nffs_inode_dec_refcnt(dir->nd_dirent.nde_inode_entry);
+ if (rc != 0) {
+ /* XXX: Need to clean up anything? */
+ return rc;
+ }
+ }
+ dir->nd_dirent.nde_inode_entry = child;
+
+ if (child == NULL) {
+ *out_dirent = NULL;
+ return FS_ENOENT;
+ }
+
+ nffs_inode_inc_refcnt(child);
+ dir->nd_dirent.fops = &nffs_ops;
+ *out_dirent = &dir->nd_dirent;
+
+ return 0;
+}
+
+int
+nffs_dir_close(struct nffs_dir *dir)
+{
+ int rc;
+
+ if (dir == NULL) {
+ return 0;
+ }
+
+ if (dir->nd_dirent.nde_inode_entry != NULL) {
+ rc = nffs_inode_dec_refcnt(dir->nd_dirent.nde_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ rc = nffs_inode_dec_refcnt(dir->nd_parent_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_dir_free(dir);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
diff --git a/src/nffs_file.c b/src/nffs_file.c
new file mode 100644
index 0000000..bf1866f
--- /dev/null
+++ b/src/nffs_file.c
@@ -0,0 +1,355 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+#include "fs/fs_if.h"
+
+struct fs_ops nffs_ops;
+
+static struct nffs_file *
+nffs_file_alloc(void)
+{
+ struct nffs_file *file;
+
+ file = os_memblock_get(&nffs_file_pool);
+ if (file != NULL) {
+ memset(file, 0, sizeof *file);
+ }
+
+ return file;
+}
+
+static int
+nffs_file_free(struct nffs_file *file)
+{
+ int rc;
+
+ if (file != NULL) {
+ rc = os_memblock_put(&nffs_file_pool, file);
+ if (rc != 0) {
+ return FS_EOS;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Creates a new empty file and writes it to the file system. If a file with
+ * the specified path already exists, the behavior is undefined.
+ *
+ * @param parent The parent directory to insert the new file in.
+ * @param filename The name of the file to create.
+ * @param filename_len The length of the filename, in characters.
+ * @param is_dir 1 if this is a directory; 0 if it is a normal
+ * file.
+ * @param out_inode_entry On success, this points to the inode
+ * corresponding to the new file.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_file_new(struct nffs_inode_entry *parent, const char *filename,
+ uint8_t filename_len, int is_dir,
+ struct nffs_inode_entry **out_inode_entry)
+{
+ struct nffs_disk_inode disk_inode;
+ struct nffs_inode_entry *inode_entry;
+ uint32_t offset;
+ uint8_t area_idx;
+ int rc;
+
+ rc = nffs_inode_entry_reserve(&inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = nffs_misc_reserve_space(sizeof disk_inode + filename_len,
+ &area_idx, &offset);
+ if (rc != 0) {
+ goto err;
+ }
+
+ memset(&disk_inode, 0, sizeof disk_inode);
+ if (is_dir) {
+ disk_inode.ndi_id = nffs_hash_next_dir_id++;
+ } else {
+ disk_inode.ndi_id = nffs_hash_next_file_id++;
+ }
+ disk_inode.ndi_seq = 0;
+ disk_inode.ndi_lastblock_id = NFFS_ID_NONE;
+ if (parent == NULL) {
+ disk_inode.ndi_parent_id = NFFS_ID_NONE;
+ } else {
+ disk_inode.ndi_parent_id = parent->nie_hash_entry.nhe_id;
+ }
+ disk_inode.ndi_filename_len = filename_len;
+ disk_inode.ndi_flags = 0;
+ nffs_crc_disk_inode_fill(&disk_inode, filename);
+
+ rc = nffs_inode_write_disk(&disk_inode, filename, area_idx, offset);
+ if (rc != 0) {
+ goto err;
+ }
+
+ inode_entry->nie_hash_entry.nhe_id = disk_inode.ndi_id;
+ inode_entry->nie_hash_entry.nhe_flash_loc =
+ nffs_flash_loc(area_idx, offset);
+ inode_entry->nie_refcnt = 1;
+ inode_entry->nie_last_block_entry = NULL;
+
+ if (parent != NULL) {
+ rc = nffs_inode_add_child(parent, inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+ } else {
+ assert(disk_inode.ndi_id == NFFS_ID_ROOT_DIR);
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_INTREE);
+ }
+
+ nffs_hash_insert(&inode_entry->nie_hash_entry);
+ *out_inode_entry = inode_entry;
+
+ return 0;
+
+err:
+ nffs_inode_entry_free(inode_entry);
+ return rc;
+}
+
+/**
+ * Performs a file open operation.
+ *
+ * @param out_file On success, a pointer to the newly-created file
+ * handle gets written here.
+ * @param path The path of the file to open.
+ * @param access_flags Flags controlling file access; see nffs_open() for
+ * details.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_file_open(struct nffs_file **out_file, const char *path,
+ uint8_t access_flags)
+{
+ struct nffs_path_parser parser;
+ struct nffs_inode_entry *parent;
+ struct nffs_inode_entry *inode;
+ struct nffs_file *file;
+ int rc;
+
+ file = NULL;
+
+ /* Reject invalid access flag combinations. */
+ if (!(access_flags & (FS_ACCESS_READ | FS_ACCESS_WRITE))) {
+ rc = FS_EINVAL;
+ goto err;
+ }
+ if (access_flags & (FS_ACCESS_APPEND | FS_ACCESS_TRUNCATE) &&
+ !(access_flags & FS_ACCESS_WRITE)) {
+
+ rc = FS_EINVAL;
+ goto err;
+ }
+ if (access_flags & FS_ACCESS_APPEND &&
+ access_flags & FS_ACCESS_TRUNCATE) {
+
+ rc = FS_EINVAL;
+ goto err;
+ }
+
+ file = nffs_file_alloc();
+ if (file == NULL) {
+ rc = FS_ENOMEM;
+ goto err;
+ }
+
+ nffs_path_parser_new(&parser, path);
+ rc = nffs_path_find(&parser, &inode, &parent);
+ if (rc == FS_ENOENT && parser.npp_token_type == NFFS_PATH_TOKEN_LEAF) {
+ /* The path is valid, but the file does not exist. This is an error
+ * for read-only opens.
+ */
+ if (!(access_flags & FS_ACCESS_WRITE)) {
+ goto err;
+ }
+
+ /* Make sure the parent directory exists. */
+ if (parent == NULL) {
+ goto err;
+ }
+
+ /* Create a new file at the specified path. */
+ rc = nffs_file_new(parent, parser.npp_token, parser.npp_token_len, 0,
+ &file->nf_inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+ } else if (rc == 0) {
+ /* The file already exists. */
+
+ /* Reject an attempt to open a directory. */
+ if (nffs_hash_id_is_dir(inode->nie_hash_entry.nhe_id)) {
+ rc = FS_EINVAL;
+ goto err;
+ }
+
+ if (access_flags & FS_ACCESS_TRUNCATE) {
+ /* The user is truncating the file. Unlink the old file and create
+ * a new one in its place.
+ */
+ nffs_path_unlink(path);
+ rc = nffs_file_new(parent, parser.npp_token, parser.npp_token_len,
+ 0, &file->nf_inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+ } else {
+ /* The user is not truncating the file. Point the file handle to
+ * the existing inode.
+ */
+ file->nf_inode_entry = inode;
+ }
+ } else {
+ /* Invalid path. */
+ goto err;
+ }
+
+ if (access_flags & FS_ACCESS_APPEND) {
+ rc = nffs_inode_data_len(file->nf_inode_entry, &file->nf_offset);
+ if (rc != 0) {
+ goto err;
+ }
+ } else {
+ file->nf_offset = 0;
+ }
+ nffs_inode_inc_refcnt(file->nf_inode_entry);
+ file->nf_access_flags = access_flags;
+ file->fops = &nffs_ops;
+
+ *out_file = file;
+
+ return 0;
+
+err:
+ nffs_file_free(file);
+ return rc;
+}
+
+/**
+ * Positions a file's read and write pointer at the specified offset. The
+ * offset is expressed as the number of bytes from the start of the file (i.e.,
+ * seeking to 0 places the pointer at the first byte in the file).
+ *
+ * @param file The file to reposition.
+ * @param offset The offset from the start of the file to seek to.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_file_seek(struct nffs_file *file, uint32_t offset)
+{
+ uint32_t len;
+ int rc;
+
+ rc = nffs_inode_data_len(file->nf_inode_entry, &len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (offset > len) {
+ return FS_EOFFSET;
+ }
+
+ file->nf_offset = offset;
+ return 0;
+}
+
+/**
+ * Reads data from the specified file. If more data is requested than remains
+ * in the file, all available data is retrieved. Note: this type of short read
+ * results in a success return code.
+ *
+ * @param file The file to read from.
+ * @param len The number of bytes to attempt to read.
+ * @param out_data The destination buffer to read into.
+ * @param out_len On success, the number of bytes actually read gets
+ * written here. Pass null if you don't care.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_file_read(struct nffs_file *file, uint32_t len, void *out_data,
+ uint32_t *out_len)
+{
+ uint32_t bytes_read;
+ int rc;
+
+ if (!nffs_misc_ready()) {
+ return FS_EUNINIT;
+ }
+
+ if (!(file->nf_access_flags & FS_ACCESS_READ)) {
+ return FS_EACCESS;
+ }
+
+ rc = nffs_inode_read(file->nf_inode_entry, file->nf_offset, len, out_data,
+ &bytes_read);
+ if (rc != 0) {
+ return rc;
+ }
+
+ file->nf_offset += bytes_read;
+ if (out_len != NULL) {
+ *out_len = bytes_read;
+ }
+
+ return 0;
+}
+
+/**
+ * Closes the specified file and invalidates the file handle. If the file has
+ * already been unlinked, and this is the last open handle to the file, this
+ * operation causes the file to be deleted.
+ *
+ * @param file The file handle to close.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_file_close(struct nffs_file *file)
+{
+ int rc;
+
+ rc = nffs_inode_dec_refcnt(file->nf_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_file_free(file);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
diff --git a/src/nffs_flash.c b/src/nffs_flash.c
new file mode 100644
index 0000000..cc83837
--- /dev/null
+++ b/src/nffs_flash.c
@@ -0,0 +1,180 @@
+/*
+ * 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 <assert.h>
+#include "hal/hal_flash.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+/** A buffer used for flash reads; shared across all of nffs. */
+uint8_t nffs_flash_buf[NFFS_FLASH_BUF_SZ];
+
+/**
+ * Reads a chunk of data from flash.
+ *
+ * @param area_idx The index of the area to read from.
+ * @param area_offset The offset within the area to read from.
+ * @param data On success, the flash contents are written
+ * here.
+ * @param len The number of bytes to read.
+ *
+ * @return 0 on success;
+ * FS_EOFFSET on an attempt to read an invalid
+ * address range;
+ * FS_EHW on flash error.
+ */
+int
+nffs_flash_read(uint8_t area_idx, uint32_t area_offset, void *data,
+ uint32_t len)
+{
+ const struct nffs_area *area;
+ int rc;
+
+ assert(area_idx < nffs_num_areas);
+
+ area = nffs_areas + area_idx;
+
+ if (area_offset + len > area->na_length) {
+ return FS_EOFFSET;
+ }
+
+ STATS_INC(nffs_stats, nffs_iocnt_read);
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + area_offset, data,
+ len);
+ if (rc != 0) {
+ return FS_EHW;
+ }
+
+ return 0;
+}
+
+/**
+ * Writes a chunk of data to flash.
+ *
+ * @param area_idx The index of the area to write to.
+ * @param area_offset The offset within the area to write to.
+ * @param data The data to write to flash.
+ * @param len The number of bytes to write.
+ *
+ * @return 0 on success;
+ * FS_EOFFSET on an attempt to write to an
+ * invalid address range, or on an attempt to
+ * perform a non-strictly-sequential write;
+ * FS_EFLASH_ERROR on flash error.
+ */
+int
+nffs_flash_write(uint8_t area_idx, uint32_t area_offset, const void *data,
+ uint32_t len)
+{
+ struct nffs_area *area;
+ int rc;
+
+ assert(area_idx < nffs_num_areas);
+ area = nffs_areas + area_idx;
+
+ if (area_offset + len > area->na_length) {
+ return FS_EOFFSET;
+ }
+
+ if (area_offset < area->na_cur) {
+ return FS_EOFFSET;
+ }
+
+ STATS_INC(nffs_stats, nffs_iocnt_write);
+ rc = hal_flash_write(area->na_flash_id, area->na_offset + area_offset,
+ data, len);
+ if (rc != 0) {
+ return FS_EHW;
+ }
+
+ area->na_cur = area_offset + len;
+
+ return 0;
+}
+
+/**
+ * Copies a chunk of data from one region of flash to another.
+ *
+ * @param area_idx_from The index of the area to copy from.
+ * @param area_offset_from The offset within the area to copy from.
+ * @param area_idx_to The index of the area to copy to.
+ * @param area_offset_to The offset within the area to copy to.
+ * @param len The number of bytes to copy.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_flash_copy(uint8_t area_idx_from, uint32_t area_offset_from,
+ uint8_t area_idx_to, uint32_t area_offset_to,
+ uint32_t len)
+{
+ uint32_t chunk_len;
+ int rc;
+
+ /* Copy data in chunks small enough to fit in the flash buffer. */
+ while (len > 0) {
+ if (len > sizeof nffs_flash_buf) {
+ chunk_len = sizeof nffs_flash_buf;
+ } else {
+ chunk_len = len;
+ }
+
+ STATS_INC(nffs_stats, nffs_readcnt_copy);
+ rc = nffs_flash_read(area_idx_from, area_offset_from, nffs_flash_buf,
+ chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_flash_write(area_idx_to, area_offset_to, nffs_flash_buf,
+ chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ area_offset_from += chunk_len;
+ area_offset_to += chunk_len;
+ len -= chunk_len;
+ }
+
+ return 0;
+}
+
+/**
+ * Compresses a flash-area-index,flash-area-offset pair into a 32-bit flash
+ * location.
+ */
+uint32_t
+nffs_flash_loc(uint8_t area_idx, uint32_t area_offset)
+{
+ assert(area_offset <= 0x00ffffff);
+ return area_idx << 24 | area_offset;
+}
+
+/**
+ * Expands a compressed 32-bit flash location into a
+ * flash-area-index,flash-area-offset pair.
+ */
+void
+nffs_flash_loc_expand(uint32_t flash_loc, uint8_t *out_area_idx,
+ uint32_t *out_area_offset)
+{
+ *out_area_idx = flash_loc >> 24;
+ *out_area_offset = flash_loc & 0x00ffffff;
+}
diff --git a/src/nffs_format.c b/src/nffs_format.c
new file mode 100644
index 0000000..d300209
--- /dev/null
+++ b/src/nffs_format.c
@@ -0,0 +1,189 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "hal/hal_flash.h"
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+
+/**
+ * Turns a scratch area into a non-scratch area. If the specified area is not
+ * actually a scratch area, this function falls back to a slower full format
+ * operation.
+ */
+int
+nffs_format_from_scratch_area(uint8_t area_idx, uint8_t area_id)
+{
+ struct nffs_disk_area disk_area;
+ int rc;
+
+ assert(area_idx < nffs_num_areas);
+ STATS_INC(nffs_stats, nffs_readcnt_format);
+ rc = nffs_flash_read(area_idx, 0, &disk_area, sizeof disk_area);
+ if (rc != 0) {
+ return rc;
+ }
+
+ nffs_areas[area_idx].na_id = area_id;
+ if (!nffs_area_is_scratch(&disk_area)) {
+ rc = nffs_format_area(area_idx, 0);
+ if (rc != 0) {
+ return rc;
+ }
+ } else {
+ disk_area.nda_id = area_id;
+ rc = nffs_flash_write(area_idx, NFFS_AREA_OFFSET_ID,
+ &disk_area.nda_id, sizeof disk_area.nda_id);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Formats a single scratch area.
+ */
+int
+nffs_format_area(uint8_t area_idx, int is_scratch)
+{
+ struct nffs_disk_area disk_area;
+ struct nffs_area *area;
+ uint32_t write_len;
+ int rc;
+
+ area = nffs_areas + area_idx;
+
+ rc = hal_flash_erase(area->na_flash_id, area->na_offset, area->na_length);
+ if (rc != 0) {
+ return FS_EHW;
+ }
+ area->na_cur = 0;
+
+ nffs_area_to_disk(area, &disk_area);
+
+ if (is_scratch) {
+ nffs_areas[area_idx].na_id = NFFS_AREA_ID_NONE;
+ write_len = sizeof disk_area - sizeof disk_area.nda_id;
+ } else {
+ write_len = sizeof disk_area;
+ }
+
+ rc = nffs_flash_write(area_idx, 0, &disk_area.nda_magic, write_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Erases all the specified areas and initializes them with a clean nffs
+ * file system.
+ *
+ * @param area_descs The set of areas to format.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int
+nffs_format_full(const struct nffs_area_desc *area_descs)
+{
+ int rc;
+ int i;
+
+ /* Start from a clean state. */
+ nffs_misc_reset();
+
+ /* Select largest area to be the initial scratch area. */
+ nffs_scratch_area_idx = 0;
+ for (i = 1; area_descs[i].nad_length != 0; i++) {
+ if (i >= NFFS_MAX_AREAS) {
+ rc = FS_EINVAL;
+ goto err;
+ }
+
+ if (area_descs[i].nad_length >
+ area_descs[nffs_scratch_area_idx].nad_length) {
+
+ nffs_scratch_area_idx = i;
+ }
+ }
+
+ rc = nffs_misc_set_num_areas(i);
+ if (rc != 0) {
+ goto err;
+ }
+
+ for (i = 0; i < nffs_num_areas; i++) {
+ nffs_areas[i].na_offset = area_descs[i].nad_offset;
+ nffs_areas[i].na_length = area_descs[i].nad_length;
+ nffs_areas[i].na_flash_id = area_descs[i].nad_flash_id;
+ nffs_areas[i].na_cur = 0;
+ nffs_areas[i].na_gc_seq = 0;
+
+ if (i == nffs_scratch_area_idx) {
+ nffs_areas[i].na_id = NFFS_AREA_ID_NONE;
+ } else {
+ nffs_areas[i].na_id = i;
+ }
+
+ rc = nffs_format_area(i, i == nffs_scratch_area_idx);
+ if (rc != 0) {
+ goto err;
+ }
+ }
+
+ rc = nffs_misc_validate_scratch();
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* Create root directory. */
+ rc = nffs_file_new(NULL, "", 0, 1, &nffs_root_dir);
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* Create "lost+found" directory. */
+ rc = nffs_misc_create_lost_found_dir();
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = nffs_misc_validate_root_dir();
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = nffs_misc_set_max_block_data_len(0);
+ if (rc != 0) {
+ goto err;
+ }
+
+ nffs_current_area_descs = (struct nffs_area_desc*) area_descs;
+
+ return 0;
+
+err:
+ nffs_misc_reset();
+ return rc;
+}
diff --git a/src/nffs_gc.c b/src/nffs_gc.c
new file mode 100644
index 0000000..8af1d2b
--- /dev/null
+++ b/src/nffs_gc.c
@@ -0,0 +1,574 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "os/os_malloc.h"
+#include "testutil/testutil.h"
+#include "nffs_priv.h"
+#include "nffs/nffs.h"
+
+/**
+ * Keeps track of the number of garbage collections performed. The exact
+ * number is not important, but it is useful to compare against an older copy
+ * to determine if garbage collection occurred.
+ */
+unsigned int nffs_gc_count;
+
+static int
+nffs_gc_copy_object(struct nffs_hash_entry *entry, uint16_t object_size,
+ uint8_t to_area_idx)
+{
+ uint32_t from_area_offset;
+ uint32_t to_area_offset;
+ uint8_t from_area_idx;
+ int rc;
+
+ nffs_flash_loc_expand(entry->nhe_flash_loc,
+ &from_area_idx, &from_area_offset);
+ to_area_offset = nffs_areas[to_area_idx].na_cur;
+
+ rc = nffs_flash_copy(from_area_idx, from_area_offset, to_area_idx,
+ to_area_offset, object_size);
+ if (rc != 0) {
+ return rc;
+ }
+
+ entry->nhe_flash_loc = nffs_flash_loc(to_area_idx, to_area_offset);
+
+ return 0;
+}
+
+static int
+nffs_gc_copy_inode(struct nffs_inode_entry *inode_entry, uint8_t to_area_idx)
+{
+ struct nffs_inode inode;
+ uint16_t copy_len;
+ int rc;
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+ copy_len = sizeof (struct nffs_disk_inode) + inode.ni_filename_len;
+
+ rc = nffs_gc_copy_object(&inode_entry->nie_hash_entry, copy_len,
+ to_area_idx);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Selects the most appropriate area for garbage collection.
+ *
+ * @return The ID of the area to garbage collect.
+ */
+static uint16_t
+nffs_gc_select_area(void)
+{
+ const struct nffs_area *area;
+ uint8_t best_area_idx;
+ int8_t diff;
+ int i;
+
+ best_area_idx = 0;
+ for (i = 1; i < nffs_num_areas; i++) {
+ if (i == nffs_scratch_area_idx) {
+ continue;
+ }
+
+ area = nffs_areas + i;
+ if (area->na_length > nffs_areas[best_area_idx].na_length) {
+ best_area_idx = i;
+ } else if (best_area_idx == nffs_scratch_area_idx) {
+ best_area_idx = i;
+ } else {
+ diff = nffs_areas[i].na_gc_seq -
+ nffs_areas[best_area_idx].na_gc_seq;
+ if (diff < 0) {
+ best_area_idx = i;
+ }
+ }
+ }
+
+ assert(best_area_idx != nffs_scratch_area_idx);
+
+ return best_area_idx;
+}
+
+static int
+nffs_gc_block_chain_copy(struct nffs_hash_entry *last_entry, uint32_t data_len,
+ uint8_t to_area_idx)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_block block;
+ uint32_t data_bytes_copied;
+ uint16_t copy_len;
+ int rc;
+
+ data_bytes_copied = 0;
+ entry = last_entry;
+
+ while (data_bytes_copied < data_len) {
+ assert(entry != NULL);
+
+ rc = nffs_block_from_hash_entry(&block, entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ copy_len = sizeof (struct nffs_disk_block) + block.nb_data_len;
+ rc = nffs_gc_copy_object(entry, copy_len, to_area_idx);
+ if (rc != 0) {
+ return rc;
+ }
+ data_bytes_copied += block.nb_data_len;
+
+ entry = block.nb_prev;
+ }
+
+ return 0;
+}
+
+/**
+ * Moves a chain of blocks from one area to another. This function attempts to
+ * collate the blocks into a single new block in the destination area.
+ *
+ * @param last_entry The last block entry in the chain.
+ * @param data_len The total length of data to collate.
+ * @param to_area_idx The index of the area to copy to.
+ * @param inout_next This parameter is only necessary if you are
+ * calling this function during an iteration
+ * of the entire hash table; pass null
+ * otherwise.
+ * On input, this points to the next hash entry
+ * you plan on processing.
+ * On output, this points to the next hash entry
+ * that should be processed.
+ *
+ * @return 0 on success;
+ * FS_ENOMEM if there is insufficient heap;
+ * other nonzero on failure.
+ */
+static int
+nffs_gc_block_chain_collate(struct nffs_hash_entry *last_entry,
+ uint32_t data_len, uint8_t to_area_idx,
+ struct nffs_hash_entry **inout_next)
+{
+ struct nffs_disk_block disk_block;
+ struct nffs_hash_entry *entry;
+ struct nffs_area *to_area;
+ struct nffs_block last_block;
+ struct nffs_block block;
+ uint32_t to_area_offset;
+ uint32_t from_area_offset;
+ uint32_t data_offset;
+ uint8_t *data;
+ uint8_t from_area_idx;
+ int rc;
+
+ memset(&last_block, 0, sizeof last_block);
+
+ data = malloc(data_len);
+ if (data == NULL) {
+ rc = FS_ENOMEM;
+ goto done;
+ }
+
+ to_area = nffs_areas + to_area_idx;
+
+ entry = last_entry;
+ data_offset = data_len;
+ while (data_offset > 0) {
+ rc = nffs_block_from_hash_entry(&block, entry);
+ if (rc != 0) {
+ goto done;
+ }
+ data_offset -= block.nb_data_len;
+
+ nffs_flash_loc_expand(block.nb_hash_entry->nhe_flash_loc,
+ &from_area_idx, &from_area_offset);
+ from_area_offset += sizeof disk_block;
+ STATS_INC(nffs_stats, nffs_readcnt_gccollate);
+ rc = nffs_flash_read(from_area_idx, from_area_offset,
+ data + data_offset, block.nb_data_len);
+ if (rc != 0) {
+ goto done;
+ }
+
+ if (entry != last_entry) {
+ if (inout_next != NULL && *inout_next == entry) {
+ *inout_next = SLIST_NEXT(entry, nhe_next);
+ }
+ nffs_block_delete_from_ram(entry);
+ } else {
+ last_block = block;
+ }
+ entry = block.nb_prev;
+ }
+
+ /* we had better have found the last block */
+ assert(last_block.nb_hash_entry);
+
+ /* The resulting block should inherit its ID from its last constituent
+ * block (this is the ID referenced by the parent inode and subsequent data
+ * block). The previous ID gets inherited from the first constituent
+ * block.
+ */
+ memset(&disk_block, 0, sizeof disk_block);
+ disk_block.ndb_id = last_block.nb_hash_entry->nhe_id;
+ disk_block.ndb_seq = last_block.nb_seq + 1;
+ disk_block.ndb_inode_id = last_block.nb_inode_entry->nie_hash_entry.nhe_id;
+ if (entry == NULL) {
+ disk_block.ndb_prev_id = NFFS_ID_NONE;
+ } else {
+ disk_block.ndb_prev_id = entry->nhe_id;
+ }
+ disk_block.ndb_data_len = data_len;
+ nffs_crc_disk_block_fill(&disk_block, data);
+
+ to_area_offset = to_area->na_cur;
+ rc = nffs_flash_write(to_area_idx, to_area_offset,
+ &disk_block, sizeof disk_block);
+ if (rc != 0) {
+ goto done;
+ }
+
+ rc = nffs_flash_write(to_area_idx, to_area_offset + sizeof disk_block,
+ data, data_len);
+ if (rc != 0) {
+ goto done;
+ }
+
+ last_entry->nhe_flash_loc = nffs_flash_loc(to_area_idx, to_area_offset);
+
+ rc = 0;
+
+ ASSERT_IF_TEST(nffs_crc_disk_block_validate(&disk_block, to_area_idx,
+ to_area_offset) == 0);
+
+done:
+ free(data);
+ return rc;
+}
+
+/**
+ * Moves a chain of blocks from one area to another. This function attempts to
+ * collate the blocks into a single new block in the destination area. If
+ * there is insufficient heap memory do to this, the function falls back to
+ * copying each block separately.
+ *
+ * @param last_entry The last block entry in the chain.
+ * @param multiple_blocks 0=single block; 1=more than one block.
+ * @param data_len The total length of data to collate.
+ * @param to_area_idx The index of the area to copy to.
+ * @param inout_next This parameter is only necessary if you are
+ * calling this function during an iteration
+ * of the entire hash table; pass null
+ * otherwise.
+ * On input, this points to the next hash entry
+ * you plan on processing.
+ * On output, this points to the next hash entry
+ * that should be processed.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_gc_block_chain(struct nffs_hash_entry *last_entry, int multiple_blocks,
+ uint32_t data_len, uint8_t to_area_idx,
+ struct nffs_hash_entry **inout_next)
+{
+ int rc;
+
+ if (!multiple_blocks) {
+ /* If there is only one block, collation has the same effect as a
+ * simple copy. Just perform the more efficient copy.
+ */
+ rc = nffs_gc_block_chain_copy(last_entry, data_len, to_area_idx);
+ } else {
+ rc = nffs_gc_block_chain_collate(last_entry, data_len, to_area_idx,
+ inout_next);
+ if (rc == FS_ENOMEM) {
+ /* Insufficient heap for collation; just copy each block one by
+ * one.
+ */
+ rc = nffs_gc_block_chain_copy(last_entry, data_len, to_area_idx);
+ }
+ }
+
+ return rc;
+}
+
+static int
+nffs_gc_inode_blocks(struct nffs_inode_entry *inode_entry,
+ uint8_t from_area_idx, uint8_t to_area_idx,
+ struct nffs_hash_entry **inout_next)
+{
+ struct nffs_hash_entry *last_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_block block;
+ uint32_t prospective_data_len;
+ uint32_t area_offset;
+ uint32_t data_len;
+ uint8_t area_idx;
+ int multiple_blocks;
+ int rc;
+
+ assert(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+
+ data_len = 0;
+ last_entry = NULL;
+ multiple_blocks = 0;
+ entry = inode_entry->nie_last_block_entry;
+ while (entry != NULL) {
+ rc = nffs_block_from_hash_entry(&block, entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ nffs_flash_loc_expand(entry->nhe_flash_loc, &area_idx, &area_offset);
+ if (area_idx == from_area_idx) {
+ if (last_entry == NULL) {
+ last_entry = entry;
+ }
+
+ prospective_data_len = data_len + block.nb_data_len;
+ if (prospective_data_len <= nffs_block_max_data_sz) {
+ data_len = prospective_data_len;
+ if (last_entry != entry) {
+ multiple_blocks = 1;
+ }
+ } else {
+ rc = nffs_gc_block_chain(last_entry, multiple_blocks, data_len,
+ to_area_idx, inout_next);
+ if (rc != 0) {
+ return rc;
+ }
+ last_entry = entry;
+ data_len = block.nb_data_len;
+ multiple_blocks = 0;
+ }
+ } else {
+ if (last_entry != NULL) {
+ rc = nffs_gc_block_chain(last_entry, multiple_blocks, data_len,
+ to_area_idx, inout_next);
+ if (rc != 0) {
+ return rc;
+ }
+
+ last_entry = NULL;
+ data_len = 0;
+ multiple_blocks = 0;
+ }
+ }
+
+ entry = block.nb_prev;
+ }
+
+ if (last_entry != NULL) {
+ rc = nffs_gc_block_chain(last_entry, multiple_blocks, data_len,
+ to_area_idx, inout_next);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Triggers a garbage collection cycle. This is implemented as follows:
+ *
+ * (1) The non-scratch area with the lowest garbage collection sequence
+ * number is selected as the "source area." If there are other areas
+ * with the same sequence number, the first one encountered is selected.
+ *
+ * (2) The source area's ID is written to the scratch area's header,
+ * transforming it into a non-scratch ID. The former scratch area is now
+ * known as the "destination area."
+ *
+ * (3) The RAM representation is exhaustively searched for objects which are
+ * resident in the source area. The copy is accomplished as follows:
+ *
+ * For each inode:
+ * (a) If the inode is resident in the source area, copy the inode
+ * record to the destination area.
+ *
+ * (b) Walk the inode's list of data blocks, starting with the last
+ * block in the file. Each block that is resident in the source
+ * area is copied to the destination area. If there is a run of
+ * two or more blocks that are resident in the source area, they
+ * are consolidated and copied to the destination area as a single
+ * new block.
+ *
+ * (4) The source area is reformatted as a scratch sector (i.e., its header
+ * indicates an ID of 0xffff). The area's garbage collection sequence
+ * number is incremented prior to rewriting the header. This area is now
+ * the new scratch sector.
+ *
+ * NOTE:
+ * Garbage collection invalidates all cached data blocks. Whenever this
+ * function is called, all existing nffs_cache_block pointers are rendered
+ * invalid. If you maintain any such pointers, you need to reset them
+ * after calling this function. Cached inodes are not invalidated by
+ * garbage collection.
+ *
+ * If a parent function potentially calls this function, the caller of the
+ * parent function needs to explicitly check if garbage collection
+ * occurred. This is done by inspecting the nffs_gc_count variable before
+ * and after calling the function.
+ *
+ * @param out_area_idx On success, the ID of the cleaned up area gets
+ * written here. Pass null if you do not need
+ * this information.
+ *
+ * @return 0 on success; nonzero on error.
+ */
+int
+nffs_gc(uint8_t *out_area_idx)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *next;
+ struct nffs_area *from_area;
+ struct nffs_area *to_area;
+ struct nffs_inode_entry *inode_entry;
+ uint32_t area_offset;
+ uint8_t from_area_idx;
+ uint8_t area_idx;
+ int rc;
+ int i;
+
+ from_area_idx = nffs_gc_select_area();
+ from_area = nffs_areas + from_area_idx;
+ to_area = nffs_areas + nffs_scratch_area_idx;
+
+ rc = nffs_format_from_scratch_area(nffs_scratch_area_idx,
+ from_area->na_id);
+ if (rc != 0) {
+ return rc;
+ }
+
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ entry = SLIST_FIRST(nffs_hash + i);
+ while (entry != NULL) {
+ next = SLIST_NEXT(entry, nhe_next);
+
+ if (nffs_hash_id_is_inode(entry->nhe_id)) {
+ /* The inode gets copied if it is in the source area. */
+ nffs_flash_loc_expand(entry->nhe_flash_loc,
+ &area_idx, &area_offset);
+ inode_entry = (struct nffs_inode_entry *)entry;
+ if (area_idx == from_area_idx) {
+ rc = nffs_gc_copy_inode(inode_entry,
+ nffs_scratch_area_idx);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ /* If the inode is a file, all constituent data blocks that are
+ * resident in the source area get copied.
+ */
+ if (nffs_hash_id_is_file(entry->nhe_id)) {
+ rc = nffs_gc_inode_blocks(inode_entry, from_area_idx,
+ nffs_scratch_area_idx, &next);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+ }
+
+ entry = next;
+ }
+ }
+
+ /* The amount of written data should never increase as a result of a gc
+ * cycle.
+ */
+ assert(to_area->na_cur <= from_area->na_cur);
+
+ /* Turn the source area into the new scratch area. */
+ from_area->na_gc_seq++;
+ rc = nffs_format_area(from_area_idx, 1);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (out_area_idx != NULL) {
+ *out_area_idx = nffs_scratch_area_idx;
+ }
+
+ nffs_scratch_area_idx = from_area_idx;
+
+ /* Garbage collection renders the cache invalid:
+ * o All cached blocks are now invalid; drop them.
+ * o Flash locations of inodes may have changed; the cached inodes need
+ * updated to reflect this.
+ */
+ rc = nffs_cache_inode_refresh();
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* Increment the garbage collection counter so that client code knows to
+ * reset its pointers to cached objects.
+ */
+ nffs_gc_count++;
+ STATS_INC(nffs_stats, nffs_gccnt);
+
+ return 0;
+}
+
+/**
+ * Repeatedly performs garbage collection cycles until there is enough free
+ * space to accommodate an object of the specified size. If there still isn't
+ * enough free space after every area has been garbage collected, this function
+ * fails.
+ *
+ * @param space The number of bytes of free space required.
+ * @param out_area_idx On success, the index of the area which can
+ * accommodate the necessary data.
+ *
+ * @return 0 on success;
+ * FS_EFULL if the necessary space could not be
+ * freed.
+ * nonzero on other failure.
+ */
+int
+nffs_gc_until(uint32_t space, uint8_t *out_area_idx)
+{
+ int rc;
+ int i;
+
+ for (i = 0; i < nffs_num_areas; i++) {
+ rc = nffs_gc(out_area_idx);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (nffs_area_free_space(nffs_areas + *out_area_idx) >= space) {
+ return 0;
+ }
+ }
+
+ return FS_EFULL;
+}
diff --git a/src/nffs_hash.c b/src/nffs_hash.c
new file mode 100644
index 0000000..00d5fa2
--- /dev/null
+++ b/src/nffs_hash.c
@@ -0,0 +1,214 @@
+/*
+ * 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 <stddef.h>
+#include <string.h>
+#include <assert.h>
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+struct nffs_hash_list *nffs_hash;
+
+uint32_t nffs_hash_next_dir_id;
+uint32_t nffs_hash_next_file_id;
+uint32_t nffs_hash_next_block_id;
+
+int
+nffs_hash_id_is_dir(uint32_t id)
+{
+ return id >= NFFS_ID_DIR_MIN && id < NFFS_ID_DIR_MAX;
+}
+
+int
+nffs_hash_id_is_file(uint32_t id)
+{
+ return id >= NFFS_ID_FILE_MIN && id < NFFS_ID_FILE_MAX;
+}
+
+int
+nffs_hash_id_is_inode(uint32_t id)
+{
+ return nffs_hash_id_is_dir(id) || nffs_hash_id_is_file(id);
+}
+
+int
+nffs_hash_id_is_block(uint32_t id)
+{
+ return id >= NFFS_ID_BLOCK_MIN && id < NFFS_ID_BLOCK_MAX;
+}
+
+static int
+nffs_hash_fn(uint32_t id)
+{
+ return id % NFFS_HASH_SIZE;
+}
+
+static struct nffs_hash_entry *
+nffs_hash_find_reorder(uint32_t id)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *prev;
+ struct nffs_hash_list *list;
+ int idx;
+
+ idx = nffs_hash_fn(id);
+ list = nffs_hash + idx;
+
+ prev = NULL;
+ SLIST_FOREACH(entry, list, nhe_next) {
+ if (entry->nhe_id == id) {
+ /* Put entry at the front of the list. */
+ if (prev != NULL) {
+ SLIST_NEXT(prev, nhe_next) = SLIST_NEXT(entry, nhe_next);
+ SLIST_INSERT_HEAD(list, entry, nhe_next);
+ }
+ return entry;
+ }
+
+ prev = entry;
+ }
+
+ return NULL;
+}
+
+struct nffs_hash_entry *
+nffs_hash_find(uint32_t id)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_list *list;
+ int idx;
+
+ idx = nffs_hash_fn(id);
+ list = nffs_hash + idx;
+
+ SLIST_FOREACH(entry, list, nhe_next) {
+ if (entry->nhe_id == id) {
+ return entry;
+ }
+ }
+
+ return NULL;
+}
+
+struct nffs_inode_entry *
+nffs_hash_find_inode(uint32_t id)
+{
+ struct nffs_hash_entry *entry;
+
+ assert(nffs_hash_id_is_inode(id));
+
+ entry = nffs_hash_find_reorder(id);
+ return (struct nffs_inode_entry *)entry;
+}
+
+struct nffs_hash_entry *
+nffs_hash_find_block(uint32_t id)
+{
+ struct nffs_hash_entry *entry;
+
+ assert(nffs_hash_id_is_block(id));
+
+ entry = nffs_hash_find_reorder(id);
+ return entry;
+}
+
+int
+nffs_hash_entry_is_dummy(struct nffs_hash_entry *he)
+{
+ return(he->nhe_flash_loc == NFFS_FLASH_LOC_NONE);
+}
+
+int
+nffs_hash_id_is_dummy(uint32_t id)
+{
+ struct nffs_hash_entry *he = nffs_hash_find(id);
+ if (he != NULL) {
+ return(he->nhe_flash_loc == NFFS_FLASH_LOC_NONE);
+ }
+ return 0;
+}
+
+void
+nffs_hash_insert(struct nffs_hash_entry *entry)
+{
+ struct nffs_hash_list *list;
+ struct nffs_inode_entry *nie;
+ int idx;
+
+ assert(nffs_hash_find(entry->nhe_id) == NULL);
+ idx = nffs_hash_fn(entry->nhe_id);
+ list = nffs_hash + idx;
+
+ SLIST_INSERT_HEAD(list, entry, nhe_next);
+ STATS_INC(nffs_stats, nffs_hashcnt_ins);
+
+ if (nffs_hash_id_is_inode(entry->nhe_id)) {
+ nie = nffs_hash_find_inode(entry->nhe_id);
+ assert(nie);
+ nffs_inode_setflags(nie, NFFS_INODE_FLAG_INHASH);
+ } else {
+ assert(nffs_hash_find(entry->nhe_id));
+ }
+}
+
+void
+nffs_hash_remove(struct nffs_hash_entry *entry)
+{
+ struct nffs_hash_list *list;
+ struct nffs_inode_entry *nie = NULL;
+ int idx;
+
+ if (nffs_hash_id_is_inode(entry->nhe_id)) {
+ nie = nffs_hash_find_inode(entry->nhe_id);
+ assert(nie);
+ assert(nffs_inode_getflags(nie, NFFS_INODE_FLAG_INHASH));
+ } else {
+ assert(nffs_hash_find(entry->nhe_id));
+ }
+
+ idx = nffs_hash_fn(entry->nhe_id);
+ list = nffs_hash + idx;
+
+ SLIST_REMOVE(list, entry, nffs_hash_entry, nhe_next);
+ STATS_INC(nffs_stats, nffs_hashcnt_rm);
+
+ if (nffs_hash_id_is_inode(entry->nhe_id) && nie) {
+ nffs_inode_unsetflags(nie, NFFS_INODE_FLAG_INHASH);
+ }
+ assert(nffs_hash_find(entry->nhe_id) == NULL);
+}
+
+int
+nffs_hash_init(void)
+{
+ int i;
+
+ free(nffs_hash);
+
+ nffs_hash = malloc(NFFS_HASH_SIZE * sizeof *nffs_hash);
+ if (nffs_hash == NULL) {
+ return FS_ENOMEM;
+ }
+
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ SLIST_INIT(nffs_hash + i);
+ }
+
+ return 0;
+}
diff --git a/src/nffs_inode.c b/src/nffs_inode.c
new file mode 100644
index 0000000..90285ce
--- /dev/null
+++ b/src/nffs_inode.c
@@ -0,0 +1,1293 @@
+/*
+ * 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 <stddef.h>
+#include <string.h>
+#include <assert.h>
+#include "testutil/testutil.h"
+#include "os/os_mempool.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+/* Partition the flash buffer into two equal halves; used for filename
+ * comparisons.
+ */
+#define NFFS_INODE_FILENAME_BUF_SZ (sizeof nffs_flash_buf / 2)
+static uint8_t *nffs_inode_filename_buf0 = nffs_flash_buf;
+static uint8_t *nffs_inode_filename_buf1 =
+ nffs_flash_buf + NFFS_INODE_FILENAME_BUF_SZ;
+
+/** A list of directory inodes with pending unlink operations. */
+static struct nffs_hash_list nffs_inode_unlink_list;
+
+struct nffs_inode_entry *
+nffs_inode_entry_alloc(void)
+{
+ struct nffs_inode_entry *inode_entry;
+
+ inode_entry = os_memblock_get(&nffs_inode_entry_pool);
+ if (inode_entry != NULL) {
+ memset(inode_entry, 0, sizeof *inode_entry);
+ }
+
+ return inode_entry;
+}
+
+void
+nffs_inode_entry_free(struct nffs_inode_entry *inode_entry)
+{
+ if (inode_entry != NULL) {
+ assert(!nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_INHASH));
+ assert(nffs_hash_id_is_inode(inode_entry->nie_hash_entry.nhe_id));
+ os_memblock_put(&nffs_inode_entry_pool, inode_entry);
+ }
+}
+
+/**
+ * Allocates a inode entry. If allocation fails due to memory exhaustion,
+ * garbage collection is performed and the allocation is retried. This
+ * process is repeated until allocation is successful or all areas have been
+ * garbage collected.
+ *
+ * @param out_inode_entry On success, the address of the allocated
+ * inode gets written here.
+ *
+ * @return 0 on successful allocation;
+ * FS_ENOMEM on memory exhaustion;
+ * other nonzero on garbage collection error.
+ */
+int
+nffs_inode_entry_reserve(struct nffs_inode_entry **out_inode_entry)
+{
+ int rc;
+
+ do {
+ *out_inode_entry = nffs_inode_entry_alloc();
+ } while (nffs_misc_gc_if_oom(*out_inode_entry, &rc));
+
+ return rc;
+}
+
+uint32_t
+nffs_inode_disk_size(const struct nffs_inode *inode)
+{
+ return sizeof (struct nffs_disk_inode) + inode->ni_filename_len;
+}
+
+int
+nffs_inode_read_disk(uint8_t area_idx, uint32_t offset,
+ struct nffs_disk_inode *out_disk_inode)
+{
+ int rc;
+
+ STATS_INC(nffs_stats, nffs_readcnt_inode);
+ rc = nffs_flash_read(area_idx, offset, out_disk_inode,
+ sizeof *out_disk_inode);
+ if (rc != 0) {
+ return rc;
+ }
+ if (!nffs_hash_id_is_inode(out_disk_inode->ndi_id)) {
+ return FS_EUNEXP;
+ }
+
+ return 0;
+}
+
+int
+nffs_inode_write_disk(const struct nffs_disk_inode *disk_inode,
+ const char *filename, uint8_t area_idx,
+ uint32_t area_offset)
+{
+ int rc;
+
+ /* Only the DELETED flag is ever written out to flash */
+ assert((disk_inode->ndi_flags & ~NFFS_INODE_FLAG_DELETED) == 0);
+
+ rc = nffs_flash_write(area_idx, area_offset, disk_inode,
+ sizeof *disk_inode);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (disk_inode->ndi_filename_len != 0) {
+ rc = nffs_flash_write(area_idx, area_offset + sizeof *disk_inode,
+ filename, disk_inode->ndi_filename_len);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ ASSERT_IF_TEST(nffs_crc_disk_inode_validate(disk_inode, area_idx,
+ area_offset) == 0);
+
+ return 0;
+}
+
+int
+nffs_inode_calc_data_length(struct nffs_inode_entry *inode_entry,
+ uint32_t *out_len)
+{
+ struct nffs_hash_entry *cur;
+ struct nffs_block block;
+ int rc;
+
+ assert(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+
+ *out_len = 0;
+
+ inode_entry->nie_blkcnt = 0;
+ cur = inode_entry->nie_last_block_entry;
+ while (cur != NULL) {
+ rc = nffs_block_from_hash_entry(&block, cur);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *out_len += block.nb_data_len;
+ inode_entry->nie_blkcnt++;
+
+ cur = block.nb_prev;
+ }
+
+ return 0;
+}
+
+int
+nffs_inode_data_len(struct nffs_inode_entry *inode_entry, uint32_t *out_len)
+{
+ struct nffs_cache_inode *cache_inode;
+ int rc;
+
+ rc = nffs_cache_inode_ensure(&cache_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *out_len = cache_inode->nci_file_size;
+
+ return 0;
+}
+
+static void
+nffs_inode_restore_from_dummy_entry(struct nffs_inode *out_inode,
+ struct nffs_inode_entry *inode_entry)
+{
+ memset(out_inode, 0, sizeof *out_inode);
+ out_inode->ni_inode_entry = inode_entry;
+}
+
+int
+nffs_inode_from_entry(struct nffs_inode *out_inode,
+ struct nffs_inode_entry *entry)
+{
+ struct nffs_disk_inode disk_inode;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int cached_name_len;
+ int rc;
+
+ memset(out_inode, 0, sizeof *out_inode);
+
+ if (nffs_inode_is_dummy(entry)) {
+ nffs_inode_restore_from_dummy_entry(out_inode, entry);
+ return FS_ENOENT;
+ }
+
+ nffs_flash_loc_expand(entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+
+ rc = nffs_inode_read_disk(area_idx, area_offset, &disk_inode);
+ if (rc != 0) {
+ return rc;
+ }
+
+ out_inode->ni_inode_entry = entry;
+ out_inode->ni_seq = disk_inode.ndi_seq;
+
+ /*
+ * Relink to parent if possible
+ * XXX does this belong here?
+ */
+ if (disk_inode.ndi_parent_id == NFFS_ID_NONE) {
+ out_inode->ni_parent = NULL;
+ } else {
+ out_inode->ni_parent = nffs_hash_find_inode(disk_inode.ndi_parent_id);
+ }
+ out_inode->ni_filename_len = disk_inode.ndi_filename_len;
+
+ if (out_inode->ni_filename_len > NFFS_SHORT_FILENAME_LEN) {
+ cached_name_len = NFFS_SHORT_FILENAME_LEN;
+ } else {
+ cached_name_len = out_inode->ni_filename_len;
+ }
+ if (cached_name_len != 0) {
+ STATS_INC(nffs_stats, nffs_readcnt_inodeent);
+ rc = nffs_flash_read(area_idx, area_offset + sizeof disk_inode,
+ out_inode->ni_filename, cached_name_len);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ if (disk_inode.ndi_flags & NFFS_INODE_FLAG_DELETED) {
+ nffs_inode_setflags(out_inode->ni_inode_entry, NFFS_INODE_FLAG_DELETED);
+ nffs_inode_setflags(entry, NFFS_INODE_FLAG_DELETED);
+ }
+
+ return 0;
+}
+
+uint32_t
+nffs_inode_parent_id(const struct nffs_inode *inode)
+{
+ if (inode->ni_parent == NULL) {
+ return NFFS_ID_NONE;
+ } else {
+ return inode->ni_parent->nie_hash_entry.nhe_id;
+ }
+}
+
+static int
+nffs_inode_delete_blocks_from_ram(struct nffs_inode_entry *inode_entry)
+{
+ int rc;
+
+ assert(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+
+ while (inode_entry->nie_last_block_entry != NULL) {
+ rc = nffs_block_delete_from_ram(inode_entry->nie_last_block_entry);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Deletes the specified inode entry from the RAM representation.
+ *
+ * @param inode_entry The inode entry to delete.
+ * @param ignore_corruption Whether to proceed, despite file system
+ * corruption errors (0/1). This should only
+ * be used when the file system is in a known
+ * bad state (e.g., during the sweep phase of
+ * the restore process). If corruption
+ * detected and ignored, this function deletes
+ * what it can and returns a success code.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_inode_delete_from_ram(struct nffs_inode_entry *inode_entry,
+ int ignore_corruption)
+{
+ int rc;
+
+ if (nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id)) {
+ /*
+ * Record the intention to delete the file
+ */
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DELETED);
+
+ rc = nffs_inode_delete_blocks_from_ram(inode_entry);
+ if (rc == FS_ECORRUPT && ignore_corruption) {
+ inode_entry->nie_last_block_entry = NULL;
+ } else if (rc != 0) {
+ return rc;
+ }
+ }
+
+ nffs_cache_inode_delete(inode_entry);
+ /*
+ * XXX Not deleting empty inode delete records from hash could prevent
+ * a case where we could lose delete records in a gc operation
+ */
+ nffs_hash_remove(&inode_entry->nie_hash_entry);
+ nffs_inode_entry_free(inode_entry);
+
+ return 0;
+}
+
+/**
+ * Inserts the specified inode entry into the unlink list. Because a hash
+ * entry only has a single 'next' pointer, this function removes the entry from
+ * the hash table prior to inserting it into the unlink list.
+ *
+ * @param inode_entry The inode entry to insert.
+ */
+static void
+nffs_inode_insert_unlink_list(struct nffs_inode_entry *inode_entry)
+{
+ nffs_hash_remove(&inode_entry->nie_hash_entry);
+ SLIST_INSERT_HEAD(&nffs_inode_unlink_list, &inode_entry->nie_hash_entry,
+ nhe_next);
+}
+
+static int
+nffs_inode_dec_refcnt_priv(struct nffs_inode_entry *inode_entry,
+ int ignore_corruption)
+{
+ int rc;
+
+ assert(inode_entry);
+ assert(inode_entry->nie_refcnt > 0);
+
+ inode_entry->nie_refcnt--;
+ if (inode_entry->nie_refcnt == 0) {
+ if (nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id)) {
+ rc = nffs_inode_delete_from_ram(inode_entry, ignore_corruption);
+ if (rc != 0) {
+ return rc;
+ }
+ } else {
+ nffs_inode_insert_unlink_list(inode_entry);
+ }
+ }
+
+ return 0;
+}
+
+int
+nffs_inode_inc_refcnt(struct nffs_inode_entry *inode_entry)
+{
+ assert(inode_entry);
+ inode_entry->nie_refcnt++;
+ return 0;
+}
+
+/**
+ * Decrements the reference count of the specified inode entry.
+ *
+ * @param inode_entry The inode entry whose reference count
+ * should be decremented.
+ */
+int
+nffs_inode_dec_refcnt(struct nffs_inode_entry *inode_entry)
+{
+ int rc;
+
+ rc = nffs_inode_dec_refcnt_priv(inode_entry, 0);
+ return rc;
+}
+
+/**
+ * Unlinks every directory inode entry present in the unlink list. After this
+ * function completes:
+ * o Each descendant directory is deleted from RAM.
+ * o Each descendant file has its reference count decremented (and deleted
+ * from RAM if its reference count reaches zero).
+ *
+ * @param inout_next This parameter is only necessary if you are
+ * calling this function during an iteration
+ * of the entire hash table; pass null
+ * otherwise.
+ * On input, this points to the next hash entry
+ * you plan on processing.
+ * On output, this points to the next hash entry
+ * that should be processed.
+ */
+static int
+nffs_inode_process_unlink_list(struct nffs_hash_entry **inout_next,
+ int ignore_corruption)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_inode_entry *child_next;
+ struct nffs_inode_entry *child;
+ struct nffs_hash_entry *hash_entry;
+ int rc;
+
+ while ((hash_entry = SLIST_FIRST(&nffs_inode_unlink_list)) != NULL) {
+ assert(nffs_hash_id_is_dir(hash_entry->nhe_id));
+
+ SLIST_REMOVE_HEAD(&nffs_inode_unlink_list, nhe_next);
+
+ inode_entry = (struct nffs_inode_entry *)hash_entry;
+
+ /* Recursively unlink each child. */
+ child = SLIST_FIRST(&inode_entry->nie_child_list);
+ while (child != NULL) {
+ child_next = SLIST_NEXT(child, nie_sibling_next);
+
+ if (inout_next != NULL && *inout_next == &child->nie_hash_entry) {
+ *inout_next = &child_next->nie_hash_entry;
+ }
+
+ rc = nffs_inode_dec_refcnt_priv(child, ignore_corruption);
+ if (rc != 0) {
+ return rc;
+ }
+
+ child = child_next;
+ }
+
+
+
+ /* The directory is already removed from the hash table; just free its
+ * memory.
+ */
+ nffs_inode_entry_free(inode_entry);
+ }
+
+ return 0;
+}
+
+int
+nffs_inode_delete_from_disk(struct nffs_inode *inode)
+{
+ struct nffs_disk_inode disk_inode;
+ uint32_t offset;
+ uint8_t area_idx;
+ int rc;
+
+ /* Make sure it isn't already deleted. */
+ assert(inode->ni_parent != NULL);
+
+ rc = nffs_misc_reserve_space(sizeof disk_inode, &area_idx, &offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ inode->ni_seq++;
+
+ memset(&disk_inode, 0, sizeof disk_inode);
+ disk_inode.ndi_id = inode->ni_inode_entry->nie_hash_entry.nhe_id;
+ disk_inode.ndi_seq = inode->ni_seq;
+ disk_inode.ndi_parent_id = NFFS_ID_NONE;
+ disk_inode.ndi_flags = NFFS_INODE_FLAG_DELETED;
+ if (inode->ni_inode_entry->nie_last_block_entry) {
+ disk_inode.ndi_lastblock_id =
+ inode->ni_inode_entry->nie_last_block_entry->nhe_id;
+ } else {
+ disk_inode.ndi_lastblock_id = NFFS_ID_NONE;
+ }
+ disk_inode.ndi_filename_len = 0;
+ nffs_crc_disk_inode_fill(&disk_inode, "");
+
+ rc = nffs_inode_write_disk(&disk_inode, "", area_idx, offset);
+ NFFS_LOG(DEBUG, "inode_del_disk: wrote unlinked ino %x to disk ref %d\n",
+ (unsigned int)disk_inode.ndi_id,
+ inode->ni_inode_entry->nie_refcnt);
+
+ /*
+ * Flag the incore inode as deleted to the inode won't get updated to
+ * disk. This could happen if the refcnt > 0 and there are future appends
+ * XXX only do this for files and not directories
+ */
+ if (nffs_hash_id_is_file(inode->ni_inode_entry->nie_hash_entry.nhe_id)) {
+ nffs_inode_setflags(inode->ni_inode_entry, NFFS_INODE_FLAG_DELETED);
+ NFFS_LOG(DEBUG, "inode_delete_from_disk: ino %x flag DELETE\n",
+ (unsigned int)inode->ni_inode_entry->nie_hash_entry.nhe_id);
+
+ }
+
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Determines if an inode is an ancestor of another.
+ *
+ * NOTE: If the two inodes are equal, a positive result is indicated.
+ *
+ * @param anc The potential ancestor.
+ * @param des The potential descendent.
+ * @param out_is_ancestor On success, the result gets written here
+ * (1 if an ancestor relationship is
+ * detected).
+ *
+ * @return 0 on success; FS_E[...] on error.
+ */
+static int
+nffs_inode_is_ancestor(struct nffs_inode_entry *anc,
+ struct nffs_inode_entry *des,
+ int *out_is_ancestor)
+{
+ struct nffs_inode_entry *cur;
+ struct nffs_inode inode;
+ int rc;
+
+ /* Only directories can be ancestors. */
+ if (!nffs_hash_id_is_dir(anc->nie_hash_entry.nhe_id)) {
+ *out_is_ancestor = 0;
+ return 0;
+ }
+
+ /* Trace des's heritage until we hit anc or there are no more parents. */
+ cur = des;
+ while (cur != NULL && cur != anc) {
+ rc = nffs_inode_from_entry(&inode, cur);
+ if (rc != 0) {
+ *out_is_ancestor = 0;
+ return rc;
+ }
+ cur = inode.ni_parent;
+ }
+
+ *out_is_ancestor = cur == anc;
+ return 0;
+}
+
+int
+nffs_inode_rename(struct nffs_inode_entry *inode_entry,
+ struct nffs_inode_entry *new_parent,
+ const char *new_filename)
+{
+ struct nffs_disk_inode disk_inode;
+ struct nffs_inode inode;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int filename_len;
+ int ancestor;
+ int rc;
+
+ /* Don't allow a directory to be moved into a descendent directory. */
+ rc = nffs_inode_is_ancestor(inode_entry, new_parent, &ancestor);
+ if (rc != 0) {
+ return rc;
+ }
+ if (ancestor) {
+ return FS_EINVAL;
+ }
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (inode.ni_parent != new_parent) {
+ if (inode.ni_parent != NULL) {
+ nffs_inode_remove_child(&inode);
+ }
+ if (new_parent != NULL) {
+ rc = nffs_inode_add_child(new_parent, inode.ni_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+ inode.ni_parent = new_parent;
+ }
+
+ if (new_filename != NULL) {
+ filename_len = strlen(new_filename);
+ } else {
+ filename_len = inode.ni_filename_len;
+ nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+
+ STATS_INC(nffs_stats, nffs_readcnt_rename);
+ rc = nffs_flash_read(area_idx,
+ area_offset + sizeof (struct nffs_disk_inode),
+ nffs_flash_buf, filename_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ new_filename = (char *)nffs_flash_buf;
+ }
+
+ rc = nffs_misc_reserve_space(sizeof disk_inode + filename_len,
+ &area_idx, &area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ memset(&disk_inode, 0, sizeof disk_inode);
+ disk_inode.ndi_id = inode_entry->nie_hash_entry.nhe_id;
+ disk_inode.ndi_seq = inode.ni_seq + 1;
+ disk_inode.ndi_parent_id = nffs_inode_parent_id(&inode);
+ disk_inode.ndi_flags = 0;
+ disk_inode.ndi_filename_len = filename_len;
+ if (inode_entry->nie_last_block_entry &&
+ inode_entry->nie_last_block_entry->nhe_id != NFFS_ID_NONE)
+ disk_inode.ndi_lastblock_id = inode_entry->nie_last_block_entry->nhe_id;
+ else
+ disk_inode.ndi_lastblock_id = NFFS_ID_NONE;
+ nffs_crc_disk_inode_fill(&disk_inode, new_filename);
+
+ rc = nffs_inode_write_disk(&disk_inode, new_filename, area_idx,
+ area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ inode_entry->nie_hash_entry.nhe_flash_loc =
+ nffs_flash_loc(area_idx, area_offset);
+
+ return 0;
+}
+
+int
+nffs_inode_update(struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_disk_inode disk_inode;
+ struct nffs_inode inode;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ char *filename;
+ int filename_len;
+ int rc;
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ /*
+ * if rc == FS_ENOENT, file is dummy is unlinked and so
+ * can not be updated to disk.
+ */
+ if (rc == FS_ENOENT)
+ assert(nffs_inode_is_dummy(inode_entry));
+ if (rc != 0) {
+ return rc;
+ }
+
+ assert(inode_entry->nie_hash_entry.nhe_flash_loc != NFFS_FLASH_LOC_NONE);
+
+ filename_len = inode.ni_filename_len;
+ nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+ STATS_INC(nffs_stats, nffs_readcnt_update);
+ rc = nffs_flash_read(area_idx,
+ area_offset + sizeof (struct nffs_disk_inode),
+ nffs_flash_buf, filename_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ filename = (char *)nffs_flash_buf;
+
+ rc = nffs_misc_reserve_space(sizeof disk_inode + filename_len,
+ &area_idx, &area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ memset(&disk_inode, 0, sizeof disk_inode);
+ disk_inode.ndi_id = inode_entry->nie_hash_entry.nhe_id;
+ disk_inode.ndi_seq = inode.ni_seq + 1;
+ disk_inode.ndi_parent_id = nffs_inode_parent_id(&inode);
+ disk_inode.ndi_flags = 0;
+ disk_inode.ndi_filename_len = filename_len;
+
+ assert(nffs_hash_id_is_block(inode_entry->nie_last_block_entry->nhe_id));
+ disk_inode.ndi_lastblock_id = inode_entry->nie_last_block_entry->nhe_id;
+
+ nffs_crc_disk_inode_fill(&disk_inode, filename);
+
+ NFFS_LOG(DEBUG, "nffs_inode_update writing inode %x last block %x\n",
+ (unsigned int)disk_inode.ndi_id,
+ (unsigned int)disk_inode.ndi_lastblock_id);
+
+ rc = nffs_inode_write_disk(&disk_inode, filename, area_idx,
+ area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ inode_entry->nie_hash_entry.nhe_flash_loc =
+ nffs_flash_loc(area_idx, area_offset);
+ return 0;
+}
+
+static int
+nffs_inode_read_filename_chunk(const struct nffs_inode *inode,
+ uint8_t filename_offset, void *buf, int len)
+{
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ assert(filename_offset + len <= inode->ni_filename_len);
+
+ nffs_flash_loc_expand(inode->ni_inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+ area_offset += sizeof (struct nffs_disk_inode) + filename_offset;
+
+ STATS_INC(nffs_stats, nffs_readcnt_filename);
+ rc = nffs_flash_read(area_idx, area_offset, buf, len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Retrieves the filename of the specified inode. The retrieved
+ * filename is always null-terminated. To ensure enough space to hold the full
+ * filename plus a null-termintor, a destination buffer of size
+ * (NFFS_FILENAME_MAX_LEN + 1) should be used.
+ *
+ * @param inode_entry The inode entry to query.
+ * @param max_len The size of the "out_name" character buffer.
+ * @param out_name On success, the entry's filename is written
+ * here; always null-terminated.
+ * @param out_name_len On success, contains the actual length of the
+ * filename, NOT including the
+ * null-terminator.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_read_filename(struct nffs_inode_entry *inode_entry, size_t max_len,
+ char *out_name, uint8_t *out_full_len)
+{
+ struct nffs_inode inode;
+ int read_len;
+ int rc;
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (max_len > inode.ni_filename_len) {
+ read_len = inode.ni_filename_len;
+ } else {
+ read_len = max_len - 1;
+ }
+
+ rc = nffs_inode_read_filename_chunk(&inode, 0, out_name, read_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ out_name[read_len] = '\0';
+
+ return 0;
+}
+
+int
+nffs_inode_add_child(struct nffs_inode_entry *parent,
+ struct nffs_inode_entry *child)
+{
+ struct nffs_inode_entry *prev;
+ struct nffs_inode_entry *cur;
+ struct nffs_inode child_inode;
+ struct nffs_inode cur_inode;
+ int cmp;
+ int rc;
+
+ assert(nffs_hash_id_is_dir(parent->nie_hash_entry.nhe_id));
+ assert(!nffs_inode_getflags(child, NFFS_INODE_FLAG_INTREE));
+
+ rc = nffs_inode_from_entry(&child_inode, child);
+ if (rc != 0) {
+ return rc;
+ }
+
+ prev = NULL;
+ SLIST_FOREACH(cur, &parent->nie_child_list, nie_sibling_next) {
+ assert(cur != child);
+ rc = nffs_inode_from_entry(&cur_inode, cur);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_filename_cmp_flash(&child_inode, &cur_inode, &cmp);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (cmp < 0) {
+ break;
+ }
+
+ prev = cur;
+ }
+
+ if (prev == NULL) {
+ SLIST_INSERT_HEAD(&parent->nie_child_list, child, nie_sibling_next);
+ } else {
+ SLIST_INSERT_AFTER(prev, child, nie_sibling_next);
+ }
+ nffs_inode_setflags(child, NFFS_INODE_FLAG_INTREE);
+
+ return 0;
+}
+
+void
+nffs_inode_remove_child(struct nffs_inode *child)
+{
+ struct nffs_inode_entry *parent;
+
+ assert(nffs_inode_getflags(child->ni_inode_entry, NFFS_INODE_FLAG_INTREE));
+ parent = child->ni_parent;
+ assert(parent != NULL);
+ assert(nffs_hash_id_is_dir(parent->nie_hash_entry.nhe_id));
+ SLIST_REMOVE(&parent->nie_child_list, child->ni_inode_entry,
+ nffs_inode_entry, nie_sibling_next);
+ SLIST_NEXT(child->ni_inode_entry, nie_sibling_next) = NULL;
+ nffs_inode_unsetflags(child->ni_inode_entry, NFFS_INODE_FLAG_INTREE);
+}
+
+int
+nffs_inode_filename_cmp_ram(const struct nffs_inode *inode,
+ const char *name, int name_len,
+ int *result)
+{
+ int short_len;
+ int chunk_len;
+ int rem_len;
+ int off;
+ int rc;
+
+ if (name_len < inode->ni_filename_len) {
+ short_len = name_len;
+ } else {
+ short_len = inode->ni_filename_len;
+ }
+
+ if (short_len <= NFFS_SHORT_FILENAME_LEN) {
+ chunk_len = short_len;
+ } else {
+ chunk_len = NFFS_SHORT_FILENAME_LEN;
+ }
+ *result = strncmp((char *)inode->ni_filename, name, chunk_len);
+
+ off = chunk_len;
+ while (*result == 0 && off < short_len) {
+ rem_len = short_len - off;
+ if (rem_len > NFFS_INODE_FILENAME_BUF_SZ) {
+ chunk_len = NFFS_INODE_FILENAME_BUF_SZ;
+ } else {
+ chunk_len = rem_len;
+ }
+
+ rc = nffs_inode_read_filename_chunk(inode, off,
+ nffs_inode_filename_buf0,
+ chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *result = strncmp((char *)nffs_inode_filename_buf0, name + off,
+ chunk_len);
+ off += chunk_len;
+ }
+
+ if (*result == 0) {
+ *result = inode->ni_filename_len - name_len;
+ }
+
+ return 0;
+}
+
+/*
+ * Compare filenames in flash
+ */
+int
+nffs_inode_filename_cmp_flash(const struct nffs_inode *inode1,
+ const struct nffs_inode *inode2,
+ int *result)
+{
+ int short_len;
+ int chunk_len;
+ int rem_len;
+ int off;
+ int rc;
+
+ if (inode1->ni_filename_len < inode2->ni_filename_len) {
+ short_len = inode1->ni_filename_len;
+ } else {
+ short_len = inode2->ni_filename_len;
+ }
+
+ if (short_len <= NFFS_SHORT_FILENAME_LEN) {
+ chunk_len = short_len;
+ } else {
+ chunk_len = NFFS_SHORT_FILENAME_LEN;
+ }
+ *result = strncmp((char *)inode1->ni_filename,
+ (char *)inode2->ni_filename,
+ chunk_len);
+
+ off = chunk_len;
+ while (*result == 0 && off < short_len) {
+ rem_len = short_len - off;
+ if (rem_len > NFFS_INODE_FILENAME_BUF_SZ) {
+ chunk_len = NFFS_INODE_FILENAME_BUF_SZ;
+ } else {
+ chunk_len = rem_len;
+ }
+
+ rc = nffs_inode_read_filename_chunk(inode1, off,
+ nffs_inode_filename_buf0,
+ chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_read_filename_chunk(inode2, off,
+ nffs_inode_filename_buf1,
+ chunk_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ *result = strncmp((char *)nffs_inode_filename_buf0,
+ (char *)nffs_inode_filename_buf1,
+ chunk_len);
+ off += chunk_len;
+ }
+
+ if (*result == 0) {
+ *result = inode1->ni_filename_len - inode2->ni_filename_len;
+ }
+
+ return 0;
+}
+
+/**
+ * Finds the set of blocks composing the specified address range within the
+ * supplied file inode. This information is returned in the form of a
+ * seek_info object.
+ *
+ * @param inode_entry The file inode to seek within.
+ * @param offset The start address of the region to seek to.
+ * @param length The length of the region to seek to.
+ * @param out_seek_info On success, this gets populated with the result
+ * of the seek operation.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_seek(struct nffs_inode_entry *inode_entry, uint32_t offset,
+ uint32_t length, struct nffs_seek_info *out_seek_info)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_hash_entry *cur_entry;
+ struct nffs_block block;
+ uint32_t block_start;
+ uint32_t cur_offset;
+ uint32_t seek_end;
+ int rc;
+
+ assert(length > 0);
+ assert(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+
+ rc = nffs_cache_inode_ensure(&cache_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (offset > cache_inode->nci_file_size) {
+ return FS_EOFFSET;
+ }
+ if (offset == cache_inode->nci_file_size) {
+ memset(&out_seek_info->nsi_last_block, 0,
+ sizeof out_seek_info->nsi_last_block);
+ out_seek_info->nsi_last_block.nb_hash_entry = NULL;
+ out_seek_info->nsi_block_file_off = 0;
+ out_seek_info->nsi_file_len = cache_inode->nci_file_size;
+ return 0;
+ }
+
+ seek_end = offset + length;
+
+ cur_entry = inode_entry->nie_last_block_entry;
+ cur_offset = cache_inode->nci_file_size;
+
+ while (1) {
+ rc = nffs_block_from_hash_entry(&block, cur_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ block_start = cur_offset - block.nb_data_len;
+ if (seek_end > block_start) {
+ out_seek_info->nsi_last_block = block;
+ out_seek_info->nsi_block_file_off = block_start;
+ out_seek_info->nsi_file_len = cache_inode->nci_file_size;
+ return 0;
+ }
+
+ cur_offset = block_start;
+ cur_entry = block.nb_prev;
+ }
+}
+
+/**
+ * Reads data from the specified file inode.
+ *
+ * @param inode_entry The inode to read from.
+ * @param offset The offset within the file to start the read
+ * at.
+ * @param len The number of bytes to attempt to read.
+ * @param out_data On success, the read data gets written here.
+ * @param out_len On success, the number of bytes actually read
+ * gets written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_read(struct nffs_inode_entry *inode_entry, uint32_t offset,
+ uint32_t len, void *out_data, uint32_t *out_len)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_cache_block *cache_block;
+ uint32_t block_end;
+ uint32_t dst_off;
+ uint32_t src_off;
+ uint32_t src_end;
+ uint16_t block_off;
+ uint16_t chunk_sz;
+ uint8_t *dptr;
+ int rc;
+
+ if (len == 0) {
+ if (out_len != NULL) {
+ *out_len = 0;
+ }
+ return 0;
+ }
+
+ rc = nffs_cache_inode_ensure(&cache_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ src_end = offset + len;
+ if (src_end > cache_inode->nci_file_size) {
+ src_end = cache_inode->nci_file_size;
+ }
+
+ /* Initialize variables for the first iteration. */
+ dst_off = src_end - offset;
+ src_off = src_end;
+ dptr = out_data;
+ cache_block = NULL;
+
+ /* Read each relevant block into the destination buffer, iterating in
+ * reverse.
+ */
+ while (dst_off > 0) {
+ if (cache_block == NULL) {
+ rc = nffs_cache_seek(cache_inode, src_off - 1, &cache_block);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ if (cache_block->ncb_file_offset < offset) {
+ block_off = offset - cache_block->ncb_file_offset;
+ } else {
+ block_off = 0;
+ }
+
+ block_end = cache_block->ncb_file_offset +
+ cache_block->ncb_block.nb_data_len;
+ chunk_sz = cache_block->ncb_block.nb_data_len - block_off;
+ if (block_end > src_end) {
+ chunk_sz -= block_end - src_end;
+ }
+
+ dst_off -= chunk_sz;
+ src_off -= chunk_sz;
+
+ rc = nffs_block_read_data(&cache_block->ncb_block, block_off, chunk_sz,
+ dptr + dst_off);
+ if (rc != 0) {
+ return rc;
+ }
+
+ cache_block = TAILQ_PREV(cache_block, nffs_cache_block_list, ncb_link);
+ }
+
+ if (out_len != NULL) {
+ *out_len = src_end - offset;
+ }
+
+ return 0;
+}
+
+static int
+nffs_inode_unlink_from_ram_priv(struct nffs_inode *inode,
+ int ignore_corruption,
+ struct nffs_hash_entry **out_next)
+{
+ int rc;
+
+ if (inode->ni_parent != NULL) {
+ nffs_inode_remove_child(inode);
+ }
+
+ /*
+ * Regardless of whether the inode is removed from hashlist, we record
+ * the intention to delete it here.
+ */
+ nffs_inode_setflags(inode->ni_inode_entry, NFFS_INODE_FLAG_DELETED);
+
+ if (nffs_hash_id_is_dir(inode->ni_inode_entry->nie_hash_entry.nhe_id)) {
+ nffs_inode_insert_unlink_list(inode->ni_inode_entry);
+ rc = nffs_inode_process_unlink_list(out_next, ignore_corruption);
+ } else {
+ rc = nffs_inode_dec_refcnt_priv(inode->ni_inode_entry,
+ ignore_corruption);
+ }
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Unlinks the specified inode from the RAM representation. If this procedure
+ * causes the inode's reference count to drop to zero, the inode is deleted
+ * from RAM. This function does not write anything to disk.
+ *
+ * @param inode The inode to unlink.
+ * @param out_next This parameter is only necessary if you are
+ * calling this function during an iteration
+ * of the entire hash table; pass null
+ * otherwise.
+ * On output, this points to the next hash entry
+ * that should be processed.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_unlink_from_ram(struct nffs_inode *inode,
+ struct nffs_hash_entry **out_next)
+{
+ int rc;
+
+ rc = nffs_inode_unlink_from_ram_priv(inode, 0, out_next);
+ return rc;
+}
+
+/**
+ * Deletes the specified inode entry from the RAM representation. If file
+ * system corruption is detected, this function completes as much of the unlink
+ * process as it cam and returns a success code. This should only be used when
+ * the file system is in a known bad state (e.g., during the sweep phase of the
+ * restore process).
+ *
+ * @param inode_entry The inode entry to delete.
+ * @param out_next This parameter is only necessary if you are
+ * calling this function during an iteration
+ * of the entire hash table; pass null
+ * otherwise.
+ * On output, this points to the next hash entry
+ * that should be processed.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_unlink_from_ram_corrupt_ok(struct nffs_inode *inode,
+ struct nffs_hash_entry **out_next)
+{
+ int rc;
+
+ rc = nffs_inode_unlink_from_ram_priv(inode, 1, out_next);
+ return rc;
+}
+
+
+/**
+ * Unlinks the file or directory represented by the specified inode. If the
+ * inode represents a directory, all the directory's descendants are
+ * recursively unlinked. Any open file handles refering to an unlinked file
+ * remain valid, and can be read from and written to.
+ *
+ * When an inode is unlinked, the following events occur:
+ * o inode deletion record is written to disk.
+ * o inode is removed from parent's child list.
+ * o inode's reference count is decreased (if this brings it to zero, the
+ * inode is fully deleted from RAM).
+ *
+ * @param inode The inode to unlink.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_inode_unlink(struct nffs_inode *inode)
+{
+ int rc;
+
+ rc = nffs_inode_delete_from_disk(inode);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_unlink_from_ram(inode, NULL);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/*
+ * Return true if inode is a dummy inode, that was allocated as a
+ * place holder in the case that an inode is restored before it's parent.
+ */
+int
+nffs_inode_is_dummy(struct nffs_inode_entry *inode_entry)
+{
+ if (inode_entry->nie_flash_loc == NFFS_FLASH_LOC_NONE) {
+ /*
+ * set if not already XXX can delete after debug
+ */
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DUMMY);
+ return 1;
+ }
+
+ if (inode_entry == nffs_root_dir) {
+ return 0;
+ } else {
+ return nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DUMMY);
+ }
+}
+
+/*
+ * Return true if inode is marked as deleted.
+ */
+int
+nffs_inode_is_deleted(struct nffs_inode_entry *inode_entry)
+{
+ assert(inode_entry);
+
+ return nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DELETED);
+}
+
+int
+nffs_inode_setflags(struct nffs_inode_entry *entry, uint8_t flag)
+{
+ /*
+ * We shouldn't be setting flags to already deleted inodes
+ */
+ entry->nie_flags |= flag;
+ return (int)entry->nie_flags;
+}
+
+int
+nffs_inode_unsetflags(struct nffs_inode_entry *entry, uint8_t flag)
+{
+ entry->nie_flags &= ~flag;
+ return (int)entry->nie_flags;
+}
+
+int
+nffs_inode_getflags(struct nffs_inode_entry *entry, uint8_t flag)
+{
+ return (int)(entry->nie_flags & flag);
+}
diff --git a/src/nffs_misc.c b/src/nffs_misc.c
new file mode 100644
index 0000000..f79d9df
--- /dev/null
+++ b/src/nffs_misc.c
@@ -0,0 +1,511 @@
+/*
+ * 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 <assert.h>
+#include "flash_map/flash_map.h"
+#include "hal/hal_bsp.h"
+#include "hal/hal_flash_int.h"
+#include "os/os_malloc.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+/**
+ * Determines if the file system contains a valid root directory. For the root
+ * directory to be valid, it must be present and have the following traits:
+ * o ID equal to NFFS_ID_ROOT_DIR.
+ * o No parent inode.
+ *
+ * @return 0 if there is a valid root directory;
+ * FS_ECORRUPT if there is not a valid root
+ * directory;
+ * nonzero on other error.
+ */
+int
+nffs_misc_validate_root_dir(void)
+{
+ struct nffs_inode inode;
+ int rc;
+
+ if (nffs_root_dir == NULL) {
+ return FS_ECORRUPT;
+ }
+
+ if (nffs_root_dir->nie_hash_entry.nhe_id != NFFS_ID_ROOT_DIR) {
+ return FS_ECORRUPT;
+ }
+
+ rc = nffs_inode_from_entry(&inode, nffs_root_dir);
+ /*
+ * nffs_root_dir is automatically flagged a "dummy" inode but it's special
+ */
+ if (rc != 0 && rc != FS_ENOENT) {
+ return rc;
+ }
+
+ if (inode.ni_parent != NULL) {
+ return FS_ECORRUPT;
+ }
+
+ return 0;
+}
+
+/**
+ * Determines if the system contains a valid scratch area. For a scratch area
+ * to be valid, it must be at least as large as the other areas in the file
+ * system.
+ *
+ * @return 0 if there is a valid scratch area;
+ * FS_ECORRUPT otherwise.
+ */
+int
+nffs_misc_validate_scratch(void)
+{
+ uint32_t scratch_len;
+ int i;
+
+ if (nffs_scratch_area_idx == NFFS_AREA_ID_NONE) {
+ /* No scratch area. */
+ return FS_ECORRUPT;
+ }
+
+ scratch_len = nffs_areas[nffs_scratch_area_idx].na_length;
+ for (i = 0; i < nffs_num_areas; i++) {
+ if (nffs_areas[i].na_length > scratch_len) {
+ return FS_ECORRUPT;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Performs a garbage cycle to free up memory, if necessary. This function
+ * should be called repeatedly until either:
+ * o The subsequent allocation is successful, or
+ * o Garbage collection is not successfully performed (indicated by a return
+ * code other than FS_EAGAIN).
+ *
+ * This function determines if garbage collection is necessary by inspecting
+ * the value of the supplied "resource" parameter. If resource is null, that
+ * implies that allocation failed.
+ *
+ * This function will not initiate garbage collection if all areas have already
+ * been collected in an attempt to free memory for the allocation in question.
+ *
+ * @param resource The result of the allocation attempt; null
+ * implies that garbage collection is
+ * necessary.
+ * @param out_rc The status of this operation gets written here.
+ * 0: garbage collection was successful or
+ * unnecessary.
+ * FS_EFULL: Garbage collection was not
+ * performed because all areas have
+ * already been collected.
+ * Other nonzero: garbage collection failed.
+ *
+ * @return FS_EAGAIN if garbage collection was
+ * successfully performed and the allocation
+ * should be retried;
+ * Other value if the allocation should not be
+ * retried; the value of the out_rc parameter
+ * indicates whether allocation was successful
+ * or there was an error.
+ */
+int
+nffs_misc_gc_if_oom(void *resource, int *out_rc)
+{
+ /**
+ * Keeps track of the number of repeated garbage collection cycles.
+ * Necessary for ensuring GC stops after all areas have been collected.
+ */
+ static uint8_t total_gc_cycles;
+
+ if (resource != NULL) {
+ /* Allocation succeeded. Reset cycle count in preparation for the next
+ * allocation failure.
+ */
+ total_gc_cycles = 0;
+ *out_rc = 0;
+ return 0;
+ }
+
+ /* If every area has already been garbage collected, there is nothing else
+ * that can be done ("- 1" to account for the scratch area).
+ */
+ if (total_gc_cycles >= nffs_num_areas - 1) {
+ *out_rc = FS_ENOMEM;
+ return 0;
+ }
+
+ /* Attempt a garbage collection on the next area. */
+ *out_rc = nffs_gc(NULL);
+ total_gc_cycles++;
+ STATS_INC(nffs_stats, nffs_gccnt);
+ if (*out_rc != 0) {
+ return 0;
+ }
+
+ /* Indicate that garbage collection was successfully performed. */
+ return 1;
+}
+
+/**
+ * Reserves the specified number of bytes within the specified area.
+ *
+ * @param area_idx The index of the area to reserve from.
+ * @param space The number of bytes of free space required.
+ * @param out_area_offset On success, the offset within the area gets
+ * written here.
+ *
+ * @return 0 on success;
+ * FS_EFULL if the area has insufficient free
+ * space.
+ */
+static int
+nffs_misc_reserve_space_area(uint8_t area_idx, uint16_t space,
+ uint32_t *out_area_offset)
+{
+ const struct nffs_area *area;
+ uint32_t available;
+
+ area = nffs_areas + area_idx;
+ available = area->na_length - area->na_cur;
+ if (available >= space) {
+ *out_area_offset = area->na_cur;
+ return 0;
+ }
+
+ return FS_EFULL;
+}
+
+/**
+ * Finds an area that can accommodate an object of the specified size. If no
+ * such area exists, this function performs a garbage collection cycle.
+ *
+ * @param space The number of bytes of free space required.
+ * @param out_area_idx On success, the index of the suitable area gets
+ * written here.
+ * @param out_area_offset On success, the offset within the suitable area
+ * gets written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_misc_reserve_space(uint16_t space,
+ uint8_t *out_area_idx, uint32_t *out_area_offset)
+{
+ uint8_t area_idx;
+ int rc;
+ int i;
+
+ /* Find the first area with sufficient free space. */
+ for (i = 0; i < nffs_num_areas; i++) {
+ if (i != nffs_scratch_area_idx) {
+ rc = nffs_misc_reserve_space_area(i, space, out_area_offset);
+ if (rc == 0) {
+ *out_area_idx = i;
+ return 0;
+ }
+ }
+ }
+
+ /* No area can accommodate the request. Garbage collect until an area
+ * has enough space.
+ */
+ rc = nffs_gc_until(space, &area_idx);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* Now try to reserve space. If insufficient space was reclaimed with
+ * garbage collection, the above call would have failed, so this should
+ * succeed.
+ */
+ rc = nffs_misc_reserve_space_area(area_idx, space, out_area_offset);
+ assert(rc == 0);
+
+ *out_area_idx = area_idx;
+
+ return rc;
+}
+
+int
+nffs_misc_set_num_areas(uint8_t num_areas)
+{
+ if (num_areas == 0) {
+ free(nffs_areas);
+ nffs_areas = NULL;
+ } else {
+ nffs_areas = realloc(nffs_areas, num_areas * sizeof *nffs_areas);
+ if (nffs_areas == NULL) {
+ return FS_ENOMEM;
+ }
+ }
+
+ nffs_num_areas = num_areas;
+
+ return 0;
+}
+
+/**
+ * Calculates the data length of the largest block that could fit in an area of
+ * the specified size.
+ */
+static uint32_t
+nffs_misc_area_capacity_one(uint32_t area_length)
+{
+ return area_length -
+ sizeof (struct nffs_disk_area) -
+ sizeof (struct nffs_disk_block);
+}
+
+/**
+ * Calculates the data length of the largest block that could fit as a pair in
+ * an area of the specified size.
+ */
+static uint32_t
+nffs_misc_area_capacity_two(uint32_t area_length)
+{
+ return (area_length - sizeof (struct nffs_disk_area)) / 2 -
+ sizeof (struct nffs_disk_block);
+}
+
+/**
+ * Calculates and sets the maximum block data length that the system supports.
+ * The result of the calculation is the greatest number which satisfies all of
+ * the following restrictions:
+ * o No more than half the size of the smallest area.
+ * o No more than 2048.
+ * o No smaller than the data length of any existing data block.
+ *
+ * @param min_size The minimum allowed data length. This is the
+ * data length of the largest block currently
+ * in the file system.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_misc_set_max_block_data_len(uint16_t min_data_len)
+{
+ uint32_t smallest_area;
+ uint32_t half_smallest;
+ int i;
+
+ smallest_area = -1;
+ for (i = 0; i < nffs_num_areas; i++) {
+ if (nffs_areas[i].na_length < smallest_area) {
+ smallest_area = nffs_areas[i].na_length;
+ }
+ }
+
+ /* Don't allow a data block size bigger than the smallest area. */
+ if (nffs_misc_area_capacity_one(smallest_area) < min_data_len) {
+ return FS_ECORRUPT;
+ }
+
+ half_smallest = nffs_misc_area_capacity_two(smallest_area);
+ if (half_smallest < NFFS_BLOCK_MAX_DATA_SZ_MAX) {
+ nffs_block_max_data_sz = half_smallest;
+ } else {
+ nffs_block_max_data_sz = NFFS_BLOCK_MAX_DATA_SZ_MAX;
+ }
+
+ if (nffs_block_max_data_sz < min_data_len) {
+ nffs_block_max_data_sz = min_data_len;
+ }
+
+ return 0;
+}
+
+int
+nffs_misc_create_lost_found_dir(void)
+{
+ int rc;
+
+ rc = nffs_path_new_dir("/lost+found", &nffs_lost_found_dir);
+ switch (rc) {
+ case 0:
+ return 0;
+
+ case FS_EEXIST:
+ rc = nffs_path_find_inode_entry("/lost+found", &nffs_lost_found_dir);
+ return rc;
+
+ default:
+ return rc;
+ }
+}
+
+
+/**
+ * Fully resets the nffs RAM representation.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_misc_reset(void)
+{
+ int rc;
+
+ nffs_cache_clear();
+
+ rc = os_mempool_init(&nffs_file_pool, nffs_config.nc_num_files,
+ sizeof (struct nffs_file), nffs_file_mem,
+ "nffs_file_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mempool_init(&nffs_inode_entry_pool, nffs_config.nc_num_inodes,
+ sizeof (struct nffs_inode_entry), nffs_inode_mem,
+ "nffs_inode_entry_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mempool_init(&nffs_block_entry_pool, nffs_config.nc_num_blocks,
+ sizeof (struct nffs_hash_entry), nffs_block_entry_mem,
+ "nffs_block_entry_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mempool_init(&nffs_cache_inode_pool,
+ nffs_config.nc_num_cache_inodes,
+ sizeof (struct nffs_cache_inode),
+ nffs_cache_inode_mem, "nffs_cache_inode_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mempool_init(&nffs_cache_block_pool,
+ nffs_config.nc_num_cache_blocks,
+ sizeof (struct nffs_cache_block),
+ nffs_cache_block_mem, "nffs_cache_block_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = os_mempool_init(&nffs_dir_pool,
+ nffs_config.nc_num_dirs,
+ sizeof (struct nffs_dir),
+ nffs_dir_mem, "nffs_dir_pool");
+ if (rc != 0) {
+ return FS_EOS;
+ }
+
+ rc = nffs_hash_init();
+ if (rc != 0) {
+ return rc;
+ }
+
+ free(nffs_areas);
+ nffs_areas = NULL;
+ nffs_num_areas = 0;
+
+ nffs_root_dir = NULL;
+ nffs_lost_found_dir = NULL;
+ nffs_scratch_area_idx = NFFS_AREA_ID_NONE;
+
+ nffs_hash_next_file_id = NFFS_ID_FILE_MIN;
+ nffs_hash_next_dir_id = NFFS_ID_DIR_MIN;
+ nffs_hash_next_block_id = NFFS_ID_BLOCK_MIN;
+
+ return 0;
+}
+
+/**
+ * Indicates whether a valid filesystem has been initialized, either via
+ * detection or formatting.
+ *
+ * @return 1 if a file system is present; 0 otherwise.
+ */
+int
+nffs_misc_ready(void)
+{
+ return nffs_root_dir != NULL;
+}
+
+
+/*
+ * Turn flash region into a set of areas for NFFS use.
+ *
+ * Limit the number of regions we return to be less than *cnt.
+ * If sector count within region exceeds that, collect multiple sectors
+ * to a region.
+ */
+int
+nffs_misc_desc_from_flash_area(int id, int *cnt, struct nffs_area_desc *nad)
+{
+ int i, j;
+ const struct hal_flash *hf;
+ const struct flash_area *fa;
+ int max_cnt, move_on;
+ int first_idx, last_idx;
+ uint32_t start, size;
+ uint32_t min_size;
+ int rc;
+
+ first_idx = last_idx = -1;
+ max_cnt = *cnt;
+ *cnt = 0;
+
+ rc = flash_area_open(id, &fa);
+ if (rc != 0) {
+ return -1;
+ }
+
+ hf = hal_bsp_flash_dev(fa->fa_device_id);
+ for (i = 0; i < hf->hf_sector_cnt; i++) {
+ hf->hf_itf->hff_sector_info(hf, i, &start, &size);
+ if (start >= fa->fa_off && start < fa->fa_off + fa->fa_size) {
+ if (first_idx == -1) {
+ first_idx = i;
+ }
+ last_idx = i;
+ *cnt = *cnt + 1;
+ }
+ }
+ if (*cnt > max_cnt) {
+ min_size = fa->fa_size / max_cnt;
+ } else {
+ min_size = 0;
+ }
+ *cnt = 0;
+
+ move_on = 1;
+ for (i = first_idx, j = 0; i < last_idx + 1; i++) {
+ hf->hf_itf->hff_sector_info(hf, i, &start, &size);
+ if (move_on) {
+ nad[j].nad_flash_id = fa->fa_device_id;
+ nad[j].nad_offset = start;
+ nad[j].nad_length = size;
+ *cnt = *cnt + 1;
+ move_on = 0;
+ } else {
+ nad[j].nad_length += size;
+ }
+ if (nad[j].nad_length >= min_size) {
+ j++;
+ move_on = 1;
+ }
+ }
+ nad[*cnt].nad_length = 0;
+ return 0;
+}
diff --git a/src/nffs_path.c b/src/nffs_path.c
new file mode 100644
index 0000000..03a8a99
--- /dev/null
+++ b/src/nffs_path.c
@@ -0,0 +1,353 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+int
+nffs_path_parse_next(struct nffs_path_parser *parser)
+{
+ const char *slash_start;
+ int token_end;
+ int token_len;
+
+ if (parser->npp_token_type == NFFS_PATH_TOKEN_LEAF) {
+ return FS_EINVAL;
+ }
+
+ slash_start = strchr(parser->npp_path + parser->npp_off, '/');
+ if (slash_start == NULL) {
+ if (parser->npp_token_type == NFFS_PATH_TOKEN_NONE) {
+ return FS_EINVAL;
+ }
+ parser->npp_token_type = NFFS_PATH_TOKEN_LEAF;
+ token_len = strlen(parser->npp_path + parser->npp_off);
+ } else {
+ parser->npp_token_type = NFFS_PATH_TOKEN_BRANCH;
+ token_end = slash_start - parser->npp_path;
+ token_len = token_end - parser->npp_off;
+ }
+
+ if (token_len > NFFS_FILENAME_MAX_LEN) {
+ return FS_EINVAL;
+ }
+
+ parser->npp_token = parser->npp_path + parser->npp_off;
+ parser->npp_token_len = token_len;
+ parser->npp_off += token_len + 1;
+
+ return 0;
+}
+
+void
+nffs_path_parser_new(struct nffs_path_parser *parser, const char *path)
+{
+ parser->npp_token_type = NFFS_PATH_TOKEN_NONE;
+ parser->npp_path = path;
+ parser->npp_off = 0;
+}
+
+static int
+nffs_path_find_child(struct nffs_inode_entry *parent,
+ const char *name, int name_len,
+ struct nffs_inode_entry **out_inode_entry)
+{
+ struct nffs_inode_entry *cur;
+ struct nffs_inode inode;
+ int cmp;
+ int rc;
+
+ SLIST_FOREACH(cur, &parent->nie_child_list, nie_sibling_next) {
+ rc = nffs_inode_from_entry(&inode, cur);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_filename_cmp_ram(&inode, name, name_len, &cmp);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (cmp == 0) {
+ *out_inode_entry = cur;
+ return 0;
+ }
+ if (cmp > 0) {
+ break;
+ }
+ }
+
+ return FS_ENOENT;
+}
+
+/*
+ * Return the inode and optionally it's parent associated with the input path
+ * nffs_path_parser struct used to track location in hierarchy
+ */
+int
+nffs_path_find(struct nffs_path_parser *parser,
+ struct nffs_inode_entry **out_inode_entry,
+ struct nffs_inode_entry **out_parent)
+{
+ struct nffs_inode_entry *parent;
+ struct nffs_inode_entry *inode_entry;
+ int rc;
+
+ *out_inode_entry = NULL;
+ if (out_parent != NULL) {
+ *out_parent = NULL;
+ }
+
+ inode_entry = NULL;
+ while (1) {
+ parent = inode_entry;
+ rc = nffs_path_parse_next(parser);
+ if (rc != 0) {
+ return rc;
+ }
+
+ switch (parser->npp_token_type) {
+ case NFFS_PATH_TOKEN_BRANCH:
+ if (parent == NULL) {
+ /* First directory must be root. */
+ if (parser->npp_token_len != 0) {
+ return FS_ENOENT;
+ }
+
+ inode_entry = nffs_root_dir;
+ } else {
+ /* Ignore empty intermediate directory names. */
+ if (parser->npp_token_len == 0) {
+ break;
+ }
+
+ rc = nffs_path_find_child(parent, parser->npp_token,
+ parser->npp_token_len, &inode_entry);
+ if (rc != 0) {
+ goto done;
+ }
+ }
+ break;
+ case NFFS_PATH_TOKEN_LEAF:
+ if (parent == NULL) {
+ /* First token must be root directory. */
+ return FS_ENOENT;
+ }
+
+ if (parser->npp_token_len == 0) {
+ /* If the path ends with a slash, the leaf is the parent, not
+ * the trailing empty token.
+ */
+ inode_entry = parent;
+ rc = 0;
+ } else {
+ rc = nffs_path_find_child(parent, parser->npp_token,
+ parser->npp_token_len, &inode_entry);
+ }
+ goto done;
+ }
+ }
+
+done:
+ *out_inode_entry = inode_entry;
+ if (out_parent != NULL) {
+ *out_parent = parent;
+ }
+ return rc;
+}
+
+int
+nffs_path_find_inode_entry(const char *filename,
+ struct nffs_inode_entry **out_inode_entry)
+{
+ struct nffs_path_parser parser;
+ int rc;
+
+ nffs_path_parser_new(&parser, filename);
+ rc = nffs_path_find(&parser, out_inode_entry, NULL);
+
+ return rc;
+}
+
+/**
+ * Unlinks the file or directory at the specified path. If the path refers to
+ * a directory, all the directory's descendants are recursively unlinked. Any
+ * open file handles refering to an unlinked file remain valid, and can be
+ * read from and written to.
+ *
+ * @path The path of the file or directory to unlink.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_path_unlink(const char *path)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_inode inode;
+ int rc;
+
+ rc = nffs_path_find_inode_entry(path, &inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_unlink(&inode);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Performs a rename and / or move of the specified source path to the
+ * specified destination. The source path can refer to either a file or a
+ * directory. All intermediate directories in the destination path must
+ * already have been created. If the source path refers to a file, the
+ * destination path must contain a full filename path (i.e., if performing a
+ * move, the destination path should end with the same filename in the source
+ * path). If an object already exists at the specified destination path, this
+ * function causes it to be unlinked prior to the rename (i.e., the destination
+ * gets clobbered).
+ *
+ * @param from The source path.
+ * @param to The destination path.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+int
+nffs_path_rename(const char *from, const char *to)
+{
+ struct nffs_path_parser parser;
+ struct nffs_inode_entry *from_inode_entry;
+ struct nffs_inode_entry *to_inode_entry;
+ struct nffs_inode_entry *from_parent;
+ struct nffs_inode_entry *to_parent;
+ struct nffs_inode inode;
+ int rc;
+
+ nffs_path_parser_new(&parser, from);
+ rc = nffs_path_find(&parser, &from_inode_entry, &from_parent);
+ if (rc != 0) {
+ return rc;
+ }
+
+ nffs_path_parser_new(&parser, to);
+ rc = nffs_path_find(&parser, &to_inode_entry, &to_parent);
+ switch (rc) {
+ case 0:
+ /* The user is clobbering something with the rename. */
+ if (nffs_hash_id_is_dir(from_inode_entry->nie_hash_entry.nhe_id) ^
+ nffs_hash_id_is_dir(to_inode_entry->nie_hash_entry.nhe_id)) {
+
+ /* Cannot clobber one type of file with another. */
+ return FS_EINVAL;
+ }
+
+ rc = nffs_inode_from_entry(&inode, to_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /*
+ * Don't allow renames if the inode has been deleted
+ * Side-effect is that we've restored the inode as needed.
+ */
+ if (nffs_inode_is_deleted(from_inode_entry)) {
+ assert(0);
+ return FS_ENOENT;
+ }
+
+ rc = nffs_inode_unlink(&inode);
+ if (rc != 0) {
+ return rc;
+ }
+ break;
+
+ case FS_ENOENT:
+ assert(to_parent != NULL);
+ if (parser.npp_token_type != NFFS_PATH_TOKEN_LEAF) {
+ /* Intermediate directory doesn't exist. */
+ return FS_EINVAL;
+ }
+ break;
+
+ default:
+ return rc;
+ }
+
+ rc = nffs_inode_rename(from_inode_entry, to_parent, parser.npp_token);
+ if (rc != 0) {
+ return rc;
+ }
+
+ return 0;
+}
+
+/**
+ * Creates a new directory at the specified path.
+ *
+ * @param path The path of the directory to create.
+ *
+ * @return 0 on success;
+ * FS_EEXIST if there is another file or
+ * directory at the specified path.
+ * FS_ENONT if a required intermediate directory
+ * does not exist.
+ */
+int
+nffs_path_new_dir(const char *path, struct nffs_inode_entry **out_inode_entry)
+{
+ struct nffs_path_parser parser;
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_inode_entry *parent;
+ int rc;
+
+ nffs_path_parser_new(&parser, path);
+ rc = nffs_path_find(&parser, &inode_entry, &parent);
+ if (rc == 0) {
+ return FS_EEXIST;
+ }
+ if (rc != FS_ENOENT) {
+ return rc;
+ }
+ if (parser.npp_token_type != NFFS_PATH_TOKEN_LEAF || parent == NULL) {
+ return FS_ENOENT;
+ }
+
+ rc = nffs_file_new(parent, parser.npp_token, parser.npp_token_len, 1,
+ &inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ if (out_inode_entry != NULL) {
+ *out_inode_entry = inode_entry;
+ }
+
+ return 0;
+}
diff --git a/src/nffs_priv.h b/src/nffs_priv.h
new file mode 100644
index 0000000..887850e
--- /dev/null
+++ b/src/nffs_priv.h
@@ -0,0 +1,534 @@
+/*
+ * 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 H_NFFS_PRIV_
+#define H_NFFS_PRIV_
+
+#include <inttypes.h>
+#include "log/log.h"
+#include "os/queue.h"
+#include "os/os_mempool.h"
+#include "nffs/nffs.h"
+#include "fs/fs.h"
+#include "crc/crc16.h"
+#include "stats/stats.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NFFS_HASH_SIZE 256
+
+#define NFFS_ID_DIR_MIN 0
+#define NFFS_ID_DIR_MAX 0x10000000
+#define NFFS_ID_FILE_MIN 0x10000000
+#define NFFS_ID_FILE_MAX 0x80000000
+#define NFFS_ID_BLOCK_MIN 0x80000000
+#define NFFS_ID_BLOCK_MAX 0xffffffff
+
+#define NFFS_ID_ROOT_DIR 0
+#define NFFS_ID_NONE 0xffffffff
+#define NFFS_HASH_ENTRY_NONE 0xffffffff
+
+#define NFFS_AREA_MAGIC0 0xb98a31e2
+#define NFFS_AREA_MAGIC1 0x7fb0428c
+#define NFFS_AREA_MAGIC2 0xace08253
+#define NFFS_AREA_MAGIC3 0xb185fc8e
+#define NFFS_BLOCK_MAGIC 0x53ba23b9
+#define NFFS_INODE_MAGIC 0x925f8bc0
+
+#define NFFS_AREA_ID_NONE 0xff
+#define NFFS_AREA_VER_0 0
+#define NFFS_AREA_VER_1 1
+#define NFFS_AREA_VER NFFS_AREA_VER_1
+#define NFFS_AREA_OFFSET_ID 23
+
+#define NFFS_SHORT_FILENAME_LEN 3
+
+#define NFFS_BLOCK_MAX_DATA_SZ_MAX 2048
+
+#define NFFS_DETECT_FAIL_IGNORE 1
+#define NFFS_DETECT_FAIL_FORMAT 2
+
+/** On-disk representation of an area header. */
+struct nffs_disk_area {
+ uint32_t nda_magic[4]; /* NFFS_AREA_MAGIC{0,1,2,3} */
+ uint32_t nda_length; /* Total size of area, in bytes. */
+ uint8_t nda_ver; /* Current nffs version: 0 */
+ uint8_t nda_gc_seq; /* Garbage collection count. */
+ uint8_t reserved8;
+ uint8_t nda_id; /* 0xff if scratch area. */
+};
+
+/** On-disk representation of an inode (file or directory). */
+struct nffs_disk_inode {
+ uint32_t ndi_id; /* Unique object ID. */
+ uint32_t ndi_parent_id; /* Object ID of parent directory inode. */
+ uint32_t ndi_lastblock_id; /* Object ID of parent directory inode. */
+ uint16_t ndi_seq; /* Sequence number; greater supersedes
+ lesser. */
+ uint16_t reserved16;
+ uint8_t ndi_flags; /* flags */
+ uint8_t ndi_filename_len; /* Length of filename, in bytes. */
+ uint16_t ndi_crc16; /* Covers rest of header and filename. */
+ /* Followed by filename. */
+};
+
+#define NFFS_DISK_INODE_OFFSET_CRC 18
+
+/** On-disk representation of a data block. */
+struct nffs_disk_block {
+ uint32_t ndb_id; /* Unique object ID. */
+ uint32_t ndb_inode_id; /* Object ID of owning inode. */
+ uint32_t ndb_prev_id; /* Object ID of previous block in file;
+ NFFS_ID_NONE if this is the first block. */
+ uint16_t ndb_seq; /* Sequence number; greater supersedes lesser. */
+ uint16_t reserved16;
+ uint16_t ndb_data_len; /* Length of data contents, in bytes. */
+ uint16_t ndb_crc16; /* Covers rest of header and data. */
+ /* Followed by 'ndb_data_len' bytes of data. */
+};
+
+#define NFFS_DISK_BLOCK_OFFSET_CRC 18
+
+/**
+ * What gets stored in the hash table. Each entry represents a data block or
+ * an inode.
+ */
+struct nffs_hash_entry {
+ SLIST_ENTRY(nffs_hash_entry) nhe_next;
+ uint32_t nhe_id; /* 0 - 0x7fffffff if inode; else if block. */
+ uint32_t nhe_flash_loc; /* Upper-byte = area idx; rest = area offset. */
+};
+
+
+SLIST_HEAD(nffs_hash_list, nffs_hash_entry);
+SLIST_HEAD(nffs_inode_list, nffs_inode_entry);
+
+/** Each inode hash entry is actually one of these. */
+struct nffs_inode_entry {
+ struct nffs_hash_entry nie_hash_entry;
+ SLIST_ENTRY(nffs_inode_entry) nie_sibling_next;
+ union {
+ struct nffs_inode_list nie_child_list; /* If directory */
+ struct nffs_hash_entry *nie_last_block_entry; /* If file */
+ uint32_t nie_lastblock_id;
+ };
+ uint8_t nie_refcnt;
+ uint8_t nie_flags;
+ uint8_t nie_blkcnt;
+ uint8_t reserved8;
+};
+
+#define NFFS_INODE_FLAG_FREE 0x00
+#define NFFS_INODE_FLAG_DUMMY 0x01 /* inode is a dummy */
+#define NFFS_INODE_FLAG_DUMMYPARENT 0x02 /* parent not in cache */
+#define NFFS_INODE_FLAG_DUMMYLSTBLK 0x04 /* lastblock not in cache */
+#define NFFS_INODE_FLAG_DUMMYINOBLK 0x08 /* dummy inode for blk */
+#define NFFS_INODE_FLAG_OBSOLETE 0x10 /* always replace if same ID */
+#define NFFS_INODE_FLAG_INTREE 0x20 /* in directory structure */
+#define NFFS_INODE_FLAG_INHASH 0x40 /* in hash table */
+#define NFFS_INODE_FLAG_DELETED 0x80 /* inode deleted */
+
+#define nie_id nie_hash_entry.nhe_id
+#define nie_flash_loc nie_hash_entry.nhe_flash_loc
+
+/** Full inode representation; not stored permanently RAM. */
+struct nffs_inode {
+ struct nffs_inode_entry *ni_inode_entry; /* Points to real inode entry. */
+ uint32_t ni_seq; /* Sequence number; greater
+ supersedes lesser. */
+ struct nffs_inode_entry *ni_parent; /* Points to parent directory. */
+ uint8_t ni_filename_len; /* # chars in filename. */
+ uint8_t ni_filename[NFFS_SHORT_FILENAME_LEN]; /* First 3 bytes. */
+};
+
+/** Full data block representation; not stored permanently RAM. */
+struct nffs_block {
+ struct nffs_hash_entry *nb_hash_entry; /* Points to real block entry. */
+ uint32_t nb_seq; /* Sequence number; greater
+ supersedes lesser. */
+ struct nffs_inode_entry *nb_inode_entry; /* Owning inode. */
+ struct nffs_hash_entry *nb_prev; /* Previous block in file. */
+ uint16_t nb_data_len; /* # of data bytes in block. */
+};
+
+struct nffs_file {
+ struct fs_ops *fops;
+ struct nffs_inode_entry *nf_inode_entry;
+ uint32_t nf_offset;
+ uint8_t nf_access_flags;
+};
+
+struct nffs_area {
+ uint32_t na_offset;
+ uint32_t na_length;
+ uint32_t na_cur;
+ uint16_t na_id;
+ uint8_t na_gc_seq;
+ uint8_t na_flash_id;
+ uint32_t na_obsolete; /* deleted bytecount */
+};
+
+struct nffs_disk_object {
+ int ndo_type;
+ uint8_t ndo_area_idx;
+ uint32_t ndo_offset;
+ union {
+ struct nffs_disk_inode ndo_disk_inode;
+ struct nffs_disk_block ndo_disk_block;
+ } ndo_un_obj;
+};
+
+#define ndo_disk_inode ndo_un_obj.ndo_disk_inode
+#define ndo_disk_block ndo_un_obj.ndo_disk_block
+
+struct nffs_seek_info {
+ struct nffs_block nsi_last_block;
+ uint32_t nsi_block_file_off;
+ uint32_t nsi_file_len;
+};
+
+#define NFFS_OBJECT_TYPE_INODE 1
+#define NFFS_OBJECT_TYPE_BLOCK 2
+
+#define NFFS_PATH_TOKEN_NONE 0
+#define NFFS_PATH_TOKEN_BRANCH 1
+#define NFFS_PATH_TOKEN_LEAF 2
+
+struct nffs_path_parser {
+ int npp_token_type;
+ const char *npp_path;
+ const char *npp_token;
+ int npp_token_len;
+ int npp_off;
+};
+
+/** Represents a single cached data block. */
+struct nffs_cache_block {
+ TAILQ_ENTRY(nffs_cache_block) ncb_link; /* Next / prev cached block. */
+ struct nffs_block ncb_block; /* Full data block. */
+ uint32_t ncb_file_offset; /* File offset of this block. */
+};
+
+TAILQ_HEAD(nffs_cache_block_list, nffs_cache_block);
+
+/** Represents a single cached file inode. */
+struct nffs_cache_inode {
+ TAILQ_ENTRY(nffs_cache_inode) nci_link; /* Sorted; LRU at tail. */
+ struct nffs_inode nci_inode; /* Full inode. */
+ struct nffs_cache_block_list nci_block_list; /* List of cached blocks. */
+ uint32_t nci_file_size; /* Total file size. */
+};
+
+struct nffs_dirent {
+ struct fs_ops *fops;
+ struct nffs_inode_entry *nde_inode_entry;
+};
+
+struct nffs_dir {
+ struct fs_ops *fops;
+ struct nffs_inode_entry *nd_parent_inode_entry;
+ struct nffs_dirent nd_dirent;
+};
+
+STATS_SECT_START(nffs_stats)
+ STATS_SECT_ENTRY(nffs_hashcnt_ins)
+ STATS_SECT_ENTRY(nffs_hashcnt_rm)
+ STATS_SECT_ENTRY(nffs_object_count)
+ STATS_SECT_ENTRY(nffs_iocnt_read)
+ STATS_SECT_ENTRY(nffs_iocnt_write)
+ STATS_SECT_ENTRY(nffs_gccnt)
+ STATS_SECT_ENTRY(nffs_readcnt_data)
+ STATS_SECT_ENTRY(nffs_readcnt_block)
+ STATS_SECT_ENTRY(nffs_readcnt_crc)
+ STATS_SECT_ENTRY(nffs_readcnt_copy)
+ STATS_SECT_ENTRY(nffs_readcnt_format)
+ STATS_SECT_ENTRY(nffs_readcnt_gccollate)
+ STATS_SECT_ENTRY(nffs_readcnt_inode)
+ STATS_SECT_ENTRY(nffs_readcnt_inodeent)
+ STATS_SECT_ENTRY(nffs_readcnt_rename)
+ STATS_SECT_ENTRY(nffs_readcnt_update)
+ STATS_SECT_ENTRY(nffs_readcnt_filename)
+ STATS_SECT_ENTRY(nffs_readcnt_object)
+ STATS_SECT_ENTRY(nffs_readcnt_detect)
+STATS_SECT_END
+extern STATS_SECT_DECL(nffs_stats) nffs_stats;
+
+extern void *nffs_file_mem;
+extern void *nffs_block_entry_mem;
+extern void *nffs_inode_mem;
+extern void *nffs_cache_inode_mem;
+extern void *nffs_cache_block_mem;
+extern void *nffs_dir_mem;
+extern struct os_mempool nffs_file_pool;
+extern struct os_mempool nffs_dir_pool;
+extern struct os_mempool nffs_inode_entry_pool;
+extern struct os_mempool nffs_block_entry_pool;
+extern struct os_mempool nffs_cache_inode_pool;
+extern struct os_mempool nffs_cache_block_pool;
+extern uint32_t nffs_hash_next_file_id;
+extern uint32_t nffs_hash_next_dir_id;
+extern uint32_t nffs_hash_next_block_id;
+extern struct nffs_area *nffs_areas;
+extern uint8_t nffs_num_areas;
+extern uint8_t nffs_scratch_area_idx;
+extern uint16_t nffs_block_max_data_sz;
+extern unsigned int nffs_gc_count;
+extern struct nffs_area_desc *nffs_current_area_descs;
+
+#define NFFS_FLASH_BUF_SZ 256
+extern uint8_t nffs_flash_buf[NFFS_FLASH_BUF_SZ];
+
+extern struct nffs_hash_list *nffs_hash;
+extern struct nffs_inode_entry *nffs_root_dir;
+extern struct nffs_inode_entry *nffs_lost_found_dir;
+
+extern struct log nffs_log;
+
+/* @area */
+int nffs_area_magic_is_set(const struct nffs_disk_area *disk_area);
+int nffs_area_is_scratch(const struct nffs_disk_area *disk_area);
+int nffs_area_is_current_version(const struct nffs_disk_area *disk_area);
+void nffs_area_to_disk(const struct nffs_area *area,
+ struct nffs_disk_area *out_disk_area);
+uint32_t nffs_area_free_space(const struct nffs_area *area);
+int nffs_area_find_corrupt_scratch(uint16_t *out_good_idx,
+ uint16_t *out_bad_idx);
+
+/* @block */
+struct nffs_hash_entry *nffs_block_entry_alloc(void);
+void nffs_block_entry_free(struct nffs_hash_entry *entry);
+int nffs_block_entry_reserve(struct nffs_hash_entry **out_block_entry);
+int nffs_block_read_disk(uint8_t area_idx, uint32_t area_offset,
+ struct nffs_disk_block *out_disk_block);
+int nffs_block_write_disk(const struct nffs_disk_block *disk_block,
+ const void *data,
+ uint8_t *out_area_idx, uint32_t *out_area_offset);
+int nffs_block_delete_from_ram(struct nffs_hash_entry *entry);
+void nffs_block_delete_list_from_ram(struct nffs_block *first,
+ struct nffs_block *last);
+void nffs_block_delete_list_from_disk(const struct nffs_block *first,
+ const struct nffs_block *last);
+void nffs_block_to_disk(const struct nffs_block *block,
+ struct nffs_disk_block *out_disk_block);
+int nffs_block_find_predecessor(struct nffs_hash_entry *start,
+ uint32_t sought_id);
+int nffs_block_from_hash_entry_no_ptrs(struct nffs_block *out_block,
+ struct nffs_hash_entry *entry);
+int nffs_block_from_hash_entry(struct nffs_block *out_block,
+ struct nffs_hash_entry *entry);
+int nffs_block_read_data(const struct nffs_block *block, uint16_t offset,
+ uint16_t length, void *dst);
+int nffs_block_is_dummy(struct nffs_hash_entry *entry);
+
+/* @cache */
+void nffs_cache_inode_delete(const struct nffs_inode_entry *inode_entry);
+int nffs_cache_inode_ensure(struct nffs_cache_inode **out_entry,
+ struct nffs_inode_entry *inode_entry);
+int nffs_cache_inode_refresh(void);
+void nffs_cache_inode_range(const struct nffs_cache_inode *cache_inode,
+ uint32_t *out_start, uint32_t *out_end);
+int nffs_cache_seek(struct nffs_cache_inode *cache_inode, uint32_t to,
+ struct nffs_cache_block **out_cache_block);
+void nffs_cache_clear(void);
+
+/* @crc */
+int nffs_crc_flash(uint16_t initial_crc, uint8_t area_idx,
+ uint32_t area_offset, uint32_t len, uint16_t *out_crc);
+uint16_t nffs_crc_disk_block_hdr(const struct nffs_disk_block *disk_block);
+int nffs_crc_disk_block_validate(const struct nffs_disk_block *disk_block,
+ uint8_t area_idx, uint32_t area_offset);
+void nffs_crc_disk_block_fill(struct nffs_disk_block *disk_block,
+ const void *data);
+int nffs_crc_disk_inode_validate(const struct nffs_disk_inode *disk_inode,
+ uint8_t area_idx, uint32_t area_offset);
+void nffs_crc_disk_inode_fill(struct nffs_disk_inode *disk_inode,
+ const char *filename);
+
+/* @config */
+void nffs_config_init(void);
+
+/* @dir */
+int nffs_dir_open(const char *path, struct nffs_dir **out_dir);
+int nffs_dir_read(struct nffs_dir *dir, struct nffs_dirent **out_dirent);
+int nffs_dir_close(struct nffs_dir *dir);
+
+/* @file */
+int nffs_file_open(struct nffs_file **out_file, const char *filename,
+ uint8_t access_flags);
+int nffs_file_seek(struct nffs_file *file, uint32_t offset);
+int nffs_file_read(struct nffs_file *file, uint32_t len, void *out_data,
+ uint32_t *out_len);
+int nffs_file_close(struct nffs_file *file);
+int nffs_file_new(struct nffs_inode_entry *parent, const char *filename,
+ uint8_t filename_len, int is_dir,
+ struct nffs_inode_entry **out_inode_entry);
+
+/* @format */
+int nffs_format_area(uint8_t area_idx, int is_scratch);
+int nffs_format_from_scratch_area(uint8_t area_idx, uint8_t area_id);
+int nffs_format_full(const struct nffs_area_desc *area_descs);
+
+/* @gc */
+int nffs_gc(uint8_t *out_area_idx);
+int nffs_gc_until(uint32_t space, uint8_t *out_area_idx);
+
+/* @flash */
+struct nffs_area *nffs_flash_find_area(uint16_t logical_id);
+int nffs_flash_read(uint8_t area_idx, uint32_t offset,
+ void *data, uint32_t len);
+int nffs_flash_write(uint8_t area_idx, uint32_t offset,
+ const void *data, uint32_t len);
+int nffs_flash_copy(uint8_t area_id_from, uint32_t offset_from,
+ uint8_t area_id_to, uint32_t offset_to,
+ uint32_t len);
+uint32_t nffs_flash_loc(uint8_t area_idx, uint32_t offset);
+void nffs_flash_loc_expand(uint32_t flash_loc, uint8_t *out_area_idx,
+ uint32_t *out_area_offset);
+
+/* @hash */
+int nffs_hash_id_is_dir(uint32_t id);
+int nffs_hash_id_is_file(uint32_t id);
+int nffs_hash_id_is_inode(uint32_t id);
+int nffs_hash_id_is_block(uint32_t id);
+struct nffs_hash_entry *nffs_hash_find(uint32_t id);
+struct nffs_inode_entry *nffs_hash_find_inode(uint32_t id);
+struct nffs_hash_entry *nffs_hash_find_block(uint32_t id);
+void nffs_hash_insert(struct nffs_hash_entry *entry);
+void nffs_hash_remove(struct nffs_hash_entry *entry);
+int nffs_hash_init(void);
+int nffs_hash_entry_is_dummy(struct nffs_hash_entry *he);
+int nffs_hash_id_is_dummy(uint32_t id);
+
+/* @inode */
+struct nffs_inode_entry *nffs_inode_entry_alloc(void);
+void nffs_inode_entry_free(struct nffs_inode_entry *inode_entry);
+int nffs_inode_entry_reserve(struct nffs_inode_entry **out_inode_entry);
+int nffs_inode_calc_data_length(struct nffs_inode_entry *inode_entry,
+ uint32_t *out_len);
+int nffs_inode_data_len(struct nffs_inode_entry *inode_entry,
+ uint32_t *out_len);
+uint32_t nffs_inode_parent_id(const struct nffs_inode *inode);
+int nffs_inode_delete_from_disk(struct nffs_inode *inode);
+int nffs_inode_entry_from_disk(struct nffs_inode_entry *out_inode,
+ const struct nffs_disk_inode *disk_inode,
+ uint8_t area_idx, uint32_t offset);
+int nffs_inode_rename(struct nffs_inode_entry *inode_entry,
+ struct nffs_inode_entry *new_parent,
+ const char *new_filename);
+int nffs_inode_update(struct nffs_inode_entry *inode_entry);
+void nffs_inode_insert_block(struct nffs_inode *inode,
+ struct nffs_block *block);
+int nffs_inode_read_disk(uint8_t area_idx, uint32_t offset,
+ struct nffs_disk_inode *out_disk_inode);
+int nffs_inode_write_disk(const struct nffs_disk_inode *disk_inode,
+ const char *filename, uint8_t area_idx,
+ uint32_t offset);
+int nffs_inode_inc_refcnt(struct nffs_inode_entry *inode_entry);
+int nffs_inode_dec_refcnt(struct nffs_inode_entry *inode_entry);
+int nffs_inode_add_child(struct nffs_inode_entry *parent,
+ struct nffs_inode_entry *child);
+void nffs_inode_remove_child(struct nffs_inode *child);
+int nffs_inode_is_root(const struct nffs_disk_inode *disk_inode);
+int nffs_inode_read_filename(struct nffs_inode_entry *inode_entry,
+ size_t max_len, char *out_name,
+ uint8_t *out_full_len);
+int nffs_inode_filename_cmp_ram(const struct nffs_inode *inode,
+ const char *name, int name_len,
+ int *result);
+int nffs_inode_filename_cmp_flash(const struct nffs_inode *inode1,
+ const struct nffs_inode *inode2,
+ int *result);
+int nffs_inode_read(struct nffs_inode_entry *inode_entry, uint32_t offset,
+ uint32_t len, void *data, uint32_t *out_len);
+int nffs_inode_seek(struct nffs_inode_entry *inode_entry, uint32_t offset,
+ uint32_t length, struct nffs_seek_info *out_seek_info);
+int nffs_inode_from_entry(struct nffs_inode *out_inode,
+ struct nffs_inode_entry *entry);
+int nffs_inode_unlink_from_ram(struct nffs_inode *inode,
+ struct nffs_hash_entry **out_next);
+int nffs_inode_unlink_from_ram_corrupt_ok(struct nffs_inode *inode,
+ struct nffs_hash_entry **out_next);
+int nffs_inode_unlink(struct nffs_inode *inode);
+int nffs_inode_is_dummy(struct nffs_inode_entry *inode_entry);
+int nffs_inode_is_deleted(struct nffs_inode_entry *inode_entry);
+int nffs_inode_setflags(struct nffs_inode_entry *entry, uint8_t flag);
+int nffs_inode_unsetflags(struct nffs_inode_entry *entry, uint8_t flag);
+int nffs_inode_getflags(struct nffs_inode_entry *entry, uint8_t flag);
+
+/* @misc */
+int nffs_misc_gc_if_oom(void *resource, int *out_rc);
+int nffs_misc_reserve_space(uint16_t space,
+ uint8_t *out_area_idx, uint32_t *out_area_offset);
+int nffs_misc_set_num_areas(uint8_t num_areas);
+int nffs_misc_validate_root_dir(void);
+int nffs_misc_validate_scratch(void);
+int nffs_misc_create_lost_found_dir(void);
+int nffs_misc_set_max_block_data_len(uint16_t min_data_len);
+int nffs_misc_reset(void);
+int nffs_misc_ready(void);
+
+/* @path */
+int nffs_path_parse_next(struct nffs_path_parser *parser);
+void nffs_path_parser_new(struct nffs_path_parser *parser, const char *path);
+int nffs_path_find(struct nffs_path_parser *parser,
+ struct nffs_inode_entry **out_inode_entry,
+ struct nffs_inode_entry **out_parent);
+int nffs_path_find_inode_entry(const char *filename,
+ struct nffs_inode_entry **out_inode_entry);
+int nffs_path_unlink(const char *filename);
+int nffs_path_rename(const char *from, const char *to);
+int nffs_path_new_dir(const char *path,
+ struct nffs_inode_entry **out_inode_entry);
+
+/* @restore */
+int nffs_restore_full(const struct nffs_area_desc *area_descs);
+
+/* @write */
+int nffs_write_to_file(struct nffs_file *file, const void *data, int len);
+
+
+#define NFFS_HASH_FOREACH(entry, i, next) \
+ for ((i) = 0; (i) < NFFS_HASH_SIZE; (i)++) \
+ for ((entry) = SLIST_FIRST(nffs_hash + (i)); \
+ (entry) && (((next)) = SLIST_NEXT((entry), nhe_next), 1); \
+ (entry) = ((next)))
+
+#define NFFS_FLASH_LOC_NONE nffs_flash_loc(NFFS_AREA_ID_NONE, 0)
+
+#if 0
+#ifdef ARCH_sim
+#include <stdio.h>
+#define NFFS_LOG(lvl, ...) \
+ printf(__VA_ARGS__)
+#else
+#define NFFS_LOG(lvl, ...) \
+ LOG_ ## lvl(&nffs_log, LOG_MODULE_NFFS, __VA_ARGS__)
+#endif
+#endif /* 0 */
+
+#define NFFS_LOG(lvl, ...) \
+ LOG_ ## lvl(&nffs_log, LOG_MODULE_NFFS, __VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/nffs_restore.c b/src/nffs_restore.c
new file mode 100644
index 0000000..0a3253c
--- /dev/null
+++ b/src/nffs_restore.c
@@ -0,0 +1,1420 @@
+/*
+ * 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 <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include "hal/hal_flash.h"
+#include "os/os_mempool.h"
+#include "os/os_malloc.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+/**
+ * The size of the largest data block encountered during detection. This is
+ * used to ensure that the maximum block data size is not set lower than the
+ * size of an existing block.
+ */
+static uint16_t nffs_restore_largest_block_data_len;
+
+/**
+ * Checks that each block a chain of data blocks was properly restored.
+ *
+ * @param last_block_entry The entry corresponding to the last block in
+ * the chain.
+ *
+ * @return 0 if the block chain is OK;
+ * FS_ECORRUPT if corruption is detected;
+ * nonzero on other error.
+ */
+static int
+nffs_restore_validate_block_chain(struct nffs_hash_entry *last_block_entry)
+{
+ struct nffs_disk_block disk_block;
+ struct nffs_hash_entry *cur;
+ struct nffs_block block;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ cur = last_block_entry;
+
+ while (cur != NULL) {
+ if (nffs_hash_entry_is_dummy(cur)) {
+ return FS_ENOENT;
+ }
+
+ nffs_flash_loc_expand(cur->nhe_flash_loc, &area_idx, &area_offset);
+
+ rc = nffs_block_read_disk(area_idx, area_offset, &disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_block_from_hash_entry(&block, cur);
+ if (rc != 0) {
+ return rc;
+ }
+
+ cur = block.nb_prev;
+ }
+
+ return 0;
+}
+
+static void
+u32toa(char *dst, uint32_t val)
+{
+ uint8_t tmp;
+ int idx = 0;
+ int i;
+ int print = 0;
+
+ for (i = 0; i < 8; i++) {
+ tmp = val >> 28;
+ if (tmp || i == 7) {
+ print = 1;
+ }
+ if (tmp < 10) {
+ tmp += '0';
+ } else {
+ tmp += 'a' - 10;
+ }
+ if (print) {
+ dst[idx++] = tmp;
+ }
+ val <<= 4;
+ }
+ dst[idx++] = '\0';
+}
+
+/**
+ * If the specified inode entry is a dummy directory, this function moves
+ * all its children to the lost+found directory.
+ *
+ * @param inode_entry The parent inode to test and empty.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_migrate_orphan_children(struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_inode_entry *lost_found_sub;
+ struct nffs_inode_entry *child_entry;
+ char buf[32];
+ int rc;
+
+ if (!nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) {
+ /* Not a directory. */
+ return 0;
+ }
+
+ if (!nffs_inode_is_dummy(inode_entry)) {
+ /* Not a dummy. */
+ return 0;
+ }
+
+ if (SLIST_EMPTY(&inode_entry->nie_child_list)) {
+ /* No children to migrate. */
+ return 0;
+ }
+
+ /* Create a directory in lost+found to hold the dummy directory's
+ * contents.
+ */
+ strcpy(buf, "/lost+found/");
+ u32toa(&buf[strlen(buf)], inode_entry->nie_hash_entry.nhe_id);
+
+ rc = nffs_path_new_dir(buf, &lost_found_sub);
+ if (rc != 0 && rc != FS_EEXIST) {
+ return rc;
+ }
+
+ /* Move each child into the new subdirectory. */
+ while ((child_entry = SLIST_FIRST(&inode_entry->nie_child_list)) != NULL) {
+ rc = nffs_inode_rename(child_entry, lost_found_sub, NULL);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+static int
+nffs_restore_should_sweep_inode_entry(struct nffs_inode_entry *inode_entry,
+ int *out_should_sweep)
+{
+ struct nffs_inode inode;
+ int rc;
+
+
+ /*
+ * if this inode was tagged to have a dummy block entry and the
+ * flag is still set, that means we didn't find the block and so
+ * should remove this inode and all associated blocks.
+ */
+ if (nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DUMMYLSTBLK)) {
+ *out_should_sweep = 1;
+ /*nffs_inode_inc_refcnt(inode_entry);*/
+ inode_entry->nie_refcnt = 1;
+ assert(inode_entry->nie_refcnt >= 1);
+ return 0;
+ }
+
+ /*
+ * This inode was originally created to hold a block that was restored
+ * before the owning inode. If the flag is still set, it means we never
+ * restored the inode from disk and so this entry should be deleted.
+ */
+ if (nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DUMMYINOBLK)) {
+ *out_should_sweep = 2;
+ inode_entry->nie_refcnt = 1;
+ assert(inode_entry->nie_refcnt >= 1);
+ return 0;
+ }
+
+ /*
+ * Determine if the inode is a dummy. Dummy inodes have a flash
+ * location set to LOC_NONE and should have a flag set for the reason.
+ * The presence of a dummy inode during the final sweep step indicates
+ * file system corruption. It's assumed that directories have
+ * previously migrated all children to /lost+found.
+ */
+ if (nffs_inode_is_dummy(inode_entry)) {
+ *out_should_sweep = 3;
+ nffs_inode_inc_refcnt(inode_entry);
+ assert(inode_entry->nie_refcnt >= 1);
+ return 0;
+ }
+
+ /* Determine if the inode has been deleted. If an inode has no parent (and
+ * it isn't the root directory), it has been deleted from the disk and
+ * should be swept from the RAM representation.
+ */
+ if (inode_entry->nie_hash_entry.nhe_id != NFFS_ID_ROOT_DIR) {
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0 && rc != FS_ENOENT) {
+ *out_should_sweep = 0;
+ return rc;
+ }
+ if (inode.ni_parent == NULL) {
+ *out_should_sweep = 4;
+ return 0;
+ }
+ }
+
+ /*
+ * If this inode has been marked as deleted, we can unlink it here.
+ *
+ * XXX Note that the record of a deletion could be lost if garbage
+ * collection erases the delete but leaves inode updates on other
+ * partitions which can then be restored.
+ */
+ if (nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DELETED)) {
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ *out_should_sweep = 0;
+ return rc;
+ }
+ *out_should_sweep = 5;
+ }
+
+ /* If this is a file inode, verify that all of its constituent blocks are
+ * present.
+ */
+ if (nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id)) {
+ rc = nffs_restore_validate_block_chain(
+ inode_entry->nie_last_block_entry);
+ if (rc == FS_ECORRUPT) {
+ *out_should_sweep = 6;
+ return 0;
+ } else if (rc == FS_ENOENT) {
+ *out_should_sweep = 7;
+ return 0;
+ } else if (rc != 0) {
+ *out_should_sweep = 0;
+ return rc;
+ }
+ }
+
+ /* This is a valid inode; don't sweep it. */
+ *out_should_sweep = 0;
+ return 0;
+}
+
+/**
+ * Performs a sweep of the RAM representation at the end of a successful
+ * restore. The sweep phase performs the following actions of each inode in
+ * the file system:
+ * 1. If the inode is a dummy directory, its children are migrated to the
+ * lost+found directory.
+ * 2. Else if the inode is a dummy file, it is fully deleted from RAM.
+ * 3. Else, a CRC check is performed on each of the inode's constituent
+ * blocks. If corruption is detected, the inode is fully deleted from
+ * RAM.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_restore_sweep(void)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *next;
+ struct nffs_hash_list *list;
+ struct nffs_inode inode;
+ struct nffs_block block;
+ int del = 0;
+ int rc;
+ int i;
+
+ /* Iterate through every object in the hash table, deleting all inodes that
+ * should be removed.
+ */
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ list = nffs_hash + i;
+
+ entry = SLIST_FIRST(list);
+ while (entry != NULL) {
+ next = SLIST_NEXT(entry, nhe_next);
+ if (nffs_hash_id_is_inode(entry->nhe_id)) {
+ inode_entry = (struct nffs_inode_entry *)entry;
+
+ /*
+ * If this is a dummy inode directory, the file system
+ * is corrupt. Move the directory's children inodes to
+ * the lost+found directory.
+ */
+ rc = nffs_restore_migrate_orphan_children(inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* Determine if this inode needs to be deleted. */
+ rc = nffs_restore_should_sweep_inode_entry(inode_entry, &del);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0 && rc != FS_ENOENT) {
+ return rc;
+ }
+
+ if (del) {
+
+ /* Remove the inode and all its children from RAM. We
+ * expect some file system corruption; the children are
+ * subject to garbage collection and may not exist in the
+ * hash. Remove what is actually present and ignore
+ * corruption errors.
+ */
+ rc = nffs_inode_unlink_from_ram_corrupt_ok(&inode, &next);
+ if (rc != 0) {
+ return rc;
+ }
+ next = SLIST_FIRST(list);
+ }
+ } else if (nffs_hash_id_is_block(entry->nhe_id)) {
+ if (nffs_hash_id_is_dummy(entry->nhe_id)) {
+ del = 1;
+ nffs_block_delete_from_ram(entry);
+ } else {
+ rc = nffs_block_from_hash_entry(&block, entry);
+ if (rc != 0 && rc != FS_ENOENT) {
+ del = 1;
+ nffs_block_delete_from_ram(entry);
+ }
+ }
+ if (del) {
+ del = 0;
+ next = SLIST_FIRST(list);
+ }
+ }
+
+ entry = next;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Creates a dummy inode and inserts it into the hash table. A dummy inode is
+ * a temporary placeholder for a real inode that has not been restored yet.
+ * These are necessary so that the inter-object links can be maintained until
+ * the absent inode is eventually restored. Dummy inodes are identified by a
+ * inaccessible flash location (NFFS_FLASH_LOC_NONE). When the real inode
+ * is restored, this flash location will be udpated.
+ *
+ * @param id The ID of the dummy inode to create.
+ * @param out_inode_entry On success, the dummy inode gets written here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_dummy_inode(uint32_t id,
+ struct nffs_inode_entry **out_inode_entry)
+{
+ struct nffs_inode_entry *inode_entry;
+
+ inode_entry = nffs_inode_entry_alloc();
+ if (inode_entry == NULL) {
+ return FS_ENOMEM;
+ }
+ inode_entry->nie_hash_entry.nhe_id = id;
+ inode_entry->nie_hash_entry.nhe_flash_loc = NFFS_FLASH_LOC_NONE;
+ inode_entry->nie_refcnt = 0;
+ inode_entry->nie_last_block_entry = NULL; /* lastblock not available yet */
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DUMMY);
+
+ nffs_hash_insert(&inode_entry->nie_hash_entry);
+
+ *out_inode_entry = inode_entry;
+
+ return 0;
+}
+
+/**
+ * Determines if an already-restored inode should be replaced by another inode
+ * just read from flash. This function should only be called if both inodes
+ * share the same ID. The existing inode gets replaced if:
+ * o It is a dummy inode.
+ * o Its sequence number is less than that of the new inode.
+ *
+ * @param old_inode_entry The already-restored inode to test.
+ * @param disk_inode The inode just read from flash.
+ * @param out_should_replace On success, 0=don't replace; 1=do replace.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_inode_gets_replaced(struct nffs_inode_entry *old_inode_entry,
+ const struct nffs_disk_inode *disk_inode,
+ int *out_should_replace)
+{
+ struct nffs_inode old_inode;
+ int rc;
+
+ assert(old_inode_entry->nie_hash_entry.nhe_id == disk_inode->ndi_id);
+
+
+ if (nffs_inode_is_dummy(old_inode_entry)) {
+ NFFS_LOG(DEBUG, "inode_gets_replaced dummy!\n");
+ *out_should_replace = 1;
+ return 0;
+ }
+
+ /*
+ * inode is known to be obsolete and needs to be replaced no matter what
+ */
+ if (nffs_inode_getflags(old_inode_entry, NFFS_INODE_FLAG_OBSOLETE)) {
+ NFFS_LOG(DEBUG, "inode_gets_replaced obsolete\n");
+ *out_should_replace = 2;
+ return 0;
+ }
+
+ rc = nffs_inode_from_entry(&old_inode, old_inode_entry);
+ if (rc != 0) {
+ *out_should_replace = 0;
+ return rc;
+ }
+
+ if (old_inode.ni_seq < disk_inode->ndi_seq) {
+ NFFS_LOG(DEBUG, "inode_gets_replaced seq\n");
+ *out_should_replace = 3;
+ return 0;
+ }
+
+ if (old_inode.ni_seq == disk_inode->ndi_seq) {
+ /* This is a duplicate of a previously-read inode. This should never
+ * happen.
+ */
+ *out_should_replace = 0;
+ return FS_EEXIST;
+ }
+
+ *out_should_replace = 0;
+ return 0;
+}
+
+/**
+ * Determines if the specified inode should be added to the RAM representation
+ * and adds it if appropriate.
+ *
+ * @param disk_inode The inode just read from flash.
+ * @param area_idx The index of the area containing the inode.
+ * @param area_offset The offset within the area of the inode.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_inode(const struct nffs_disk_inode *disk_inode, uint8_t area_idx,
+ uint32_t area_offset)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_inode_entry *parent;
+ struct nffs_inode inode;
+ struct nffs_hash_entry *lastblock_entry = NULL;
+ int new_inode;
+ int do_add;
+ int rc;
+
+ new_inode = 0;
+
+ /* Check the inode's CRC. If the inode is corrupt, discard it. */
+ rc = nffs_crc_disk_inode_validate(disk_inode, area_idx, area_offset);
+ if (rc != 0) {
+ goto err;
+ }
+
+ inode_entry = nffs_hash_find_inode(disk_inode->ndi_id);
+
+ /*
+ * Inode has already been restored. Determine whether this version
+ * from disk should replace the previous version referenced in RAM.
+ */
+ if (inode_entry != NULL) {
+
+ if (disk_inode->ndi_flags & NFFS_INODE_FLAG_DELETED) {
+ /*
+ * Restore this inode even though deleted on disk
+ * so the additional restored blocks have a place to go
+ */
+ NFFS_LOG(DEBUG, "restoring deleted inode %x\n",
+ (unsigned int)disk_inode->ndi_id);
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DELETED);
+ }
+
+ /*
+ * inodes get replaced if they're dummy entries (i.e. allocated
+ * as place holders until the actual inode is restored), or this is
+ * a more recent version of the inode which supercedes the old.
+ */
+ rc = nffs_restore_inode_gets_replaced(inode_entry, disk_inode, &do_add);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if (do_add) { /* replace in this case */
+ if (!nffs_inode_is_dummy(inode_entry)) {
+ /*
+ * if it's not a dummy, read block from flash
+ */
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /*
+ * inode is known to be obsolete
+ */
+ if (nffs_inode_getflags(inode_entry,
+ NFFS_INODE_FLAG_OBSOLETE)) {
+ nffs_inode_unsetflags(inode_entry,
+ NFFS_INODE_FLAG_OBSOLETE);
+ }
+
+ if (inode.ni_parent != NULL) {
+ nffs_inode_remove_child(&inode);
+ }
+
+ /*
+ * If this is a delete record, subsequent inode and restore
+ * records from flash may be ignored.
+ * If the parent is NULL, this inode has been deleted. (old)
+ * XXX if we could count on delete records for every inode,
+ * we wouldn't need to check for the root directory looking
+ * like a delete record because of it's parent ID.
+ */
+ if (inode_entry->nie_hash_entry.nhe_id != NFFS_ID_ROOT_DIR) {
+ if (disk_inode->ndi_flags & NFFS_INODE_FLAG_DELETED ||
+ disk_inode->ndi_parent_id == NFFS_ID_NONE) {
+
+ nffs_inode_setflags(inode_entry,
+ NFFS_INODE_FLAG_DELETED);
+ }
+ }
+
+ } else {
+ /*
+ * The existing inode entry was added as dummy.
+ * The restore operation clears that state.
+ */
+
+ /* If it's a directory, it was added as a parent to
+ * one of it's children who were restored first.
+ */
+ if (nffs_inode_getflags(inode_entry,
+ NFFS_INODE_FLAG_DUMMYPARENT)) {
+ assert(nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id));
+ nffs_inode_unsetflags(inode_entry,
+ NFFS_INODE_FLAG_DUMMYPARENT);
+ }
+
+ /*
+ * If it's a file, it was added to store a lastblock
+ */
+ if (nffs_inode_getflags(inode_entry,
+ NFFS_INODE_FLAG_DUMMYINOBLK)) {
+ assert(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+ nffs_inode_unsetflags(inode_entry,
+ NFFS_INODE_FLAG_DUMMYINOBLK);
+ }
+
+ /*
+ * Also, since it's a dummy, clear this flag too
+ */
+ if (nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DUMMY)) {
+ nffs_inode_unsetflags(inode_entry, NFFS_INODE_FLAG_DUMMY);
+ }
+ }
+
+ /*
+ * Update location to reference new location in flash
+ */
+ inode_entry->nie_hash_entry.nhe_flash_loc =
+ nffs_flash_loc(area_idx, area_offset);
+ }
+
+ } else {
+ inode_entry = nffs_inode_entry_alloc();
+ if (inode_entry == NULL) {
+ rc = FS_ENOMEM;
+ goto err;
+ }
+ new_inode = 1;
+ do_add = 1;
+
+ inode_entry->nie_hash_entry.nhe_id = disk_inode->ndi_id;
+ inode_entry->nie_hash_entry.nhe_flash_loc =
+ nffs_flash_loc(area_idx, area_offset);
+ inode_entry->nie_last_block_entry = NULL; /* for now */
+
+ nffs_hash_insert(&inode_entry->nie_hash_entry);
+ }
+
+ /*
+ * inode object has been restored and the entry is in the hash
+ * Check whether the lastblock and parent have also been restored
+ * and link up or allocate dummy entries as appropriate.
+ */
+ if (do_add) {
+ inode_entry->nie_refcnt = 1;
+
+ if (disk_inode->ndi_flags & NFFS_INODE_FLAG_DELETED) {
+ /*
+ * Restore this inode even though deleted on disk
+ * so the additional restored blocks have a place to go
+ */
+ NFFS_LOG(DEBUG, "restoring deleted inode %x\n",
+ (unsigned int)disk_inode->ndi_id);
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DELETED);
+ }
+
+ /*
+ * Inode has a lastblock on disk.
+ * Add reference to last block entry if in hash table
+ * otherwise add a dummy block entry for later update
+ */
+ if (disk_inode->ndi_lastblock_id != NFFS_ID_NONE &&
+ nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id)) {
+ lastblock_entry =
+ nffs_hash_find_block(disk_inode->ndi_lastblock_id);
+
+ /*
+ * Lastblock has already been restored.
+ */
+ if (lastblock_entry != NULL) {
+ if (lastblock_entry->nhe_id == disk_inode->ndi_lastblock_id) {
+ inode_entry->nie_last_block_entry = lastblock_entry;
+ }
+
+ } else {
+ /*
+ * Insert a temporary reference to a 'dummy' block entry
+ * When block is restored, it will update this dummy and
+ * the entry of this inode is updated to flash location
+ */
+ rc = nffs_block_entry_reserve(&lastblock_entry);
+ if (lastblock_entry == NULL) {
+ rc = FS_ENOMEM;
+ goto err;
+ }
+
+ lastblock_entry->nhe_id = disk_inode->ndi_lastblock_id;
+ lastblock_entry->nhe_flash_loc = NFFS_FLASH_LOC_NONE;
+ inode_entry->nie_last_block_entry = lastblock_entry;
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DUMMYLSTBLK);
+ nffs_hash_insert(lastblock_entry);
+
+ if (lastblock_entry->nhe_id >= nffs_hash_next_block_id) {
+ nffs_hash_next_block_id = lastblock_entry->nhe_id + 1;
+ }
+ }
+ }
+
+ if (disk_inode->ndi_parent_id != NFFS_ID_NONE) {
+
+ parent = nffs_hash_find_inode(disk_inode->ndi_parent_id);
+ /*
+ * The parent directory for this inode hasn't been restored yet.
+ * Add a dummy directory so it can be added as a child.
+ * When the parent inode is restored, it's hash entry will be
+ * updated with the flash location.
+ */
+ if (parent == NULL) {
+ rc = nffs_restore_dummy_inode(disk_inode->ndi_parent_id,
+ &parent);
+ /*
+ * Set the dummy parent flag in the new parent.
+ * It's turned off above when restored.
+ */
+ nffs_inode_setflags(parent, NFFS_INODE_FLAG_DUMMYPARENT);
+ if (rc != 0) {
+ goto err;
+ }
+ }
+
+ rc = nffs_inode_add_child(parent, inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+ }
+
+ if (inode_entry->nie_hash_entry.nhe_id == NFFS_ID_ROOT_DIR) {
+ nffs_root_dir = inode_entry;
+ nffs_inode_setflags(nffs_root_dir, NFFS_INODE_FLAG_INTREE);
+ }
+ }
+
+ if (nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id)) {
+ NFFS_LOG(DEBUG, "restoring file; id=0x%08x\n",
+ (unsigned int)inode_entry->nie_hash_entry.nhe_id);
+ if (inode_entry->nie_hash_entry.nhe_id >= nffs_hash_next_file_id) {
+ nffs_hash_next_file_id = inode_entry->nie_hash_entry.nhe_id + 1;
+ }
+ } else {
+ NFFS_LOG(DEBUG, "restoring dir; id=0x%08x\n",
+ (unsigned int)inode_entry->nie_hash_entry.nhe_id);
+ if (inode_entry->nie_hash_entry.nhe_id >= nffs_hash_next_dir_id) {
+ nffs_hash_next_dir_id = inode_entry->nie_hash_entry.nhe_id + 1;
+ }
+ }
+
+ return 0;
+
+err:
+ if (new_inode) {
+ assert(nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_INHASH));
+ nffs_hash_remove(&inode_entry->nie_hash_entry);
+ nffs_inode_entry_free(inode_entry);
+ }
+ return rc;
+}
+
+/**
+ * Indicates whether the specified data block is superseded by the just-read
+ * disk data block. A data block supersedes another if its ID is equal and its
+ * sequence number is greater than that of the other block.
+ *
+ * @param out_should_replace On success, 0 or 1 gets written here, to
+ * indicate whether replacement should occur.
+ * @param old_block The data block which has already been read and
+ * converted to its RAM representation. This
+ * is the block that may be superseded.
+ * @param disk_block The disk data block that was just read from
+ * flash. This is the block which may
+ * supersede the other.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_block_gets_replaced(const struct nffs_block *old_block,
+ const struct nffs_disk_block *disk_block,
+ int *out_should_replace)
+{
+ assert(old_block->nb_hash_entry->nhe_id == disk_block->ndb_id);
+
+ if (nffs_block_is_dummy(old_block->nb_hash_entry)) {
+ assert(0);
+ *out_should_replace = 1;
+ return 0;
+ }
+
+ if (old_block->nb_seq < disk_block->ndb_seq) {
+ *out_should_replace = 2;
+ return 0;
+ }
+
+ if (old_block->nb_seq == disk_block->ndb_seq) {
+ /* This is a duplicate of an previously-read block. This should never
+ * happen.
+ */
+ return FS_EEXIST;
+ }
+
+ *out_should_replace = 0;
+ return 0;
+}
+
+/**
+ * Populates the nffs RAM state with the memory representation of the specified
+ * disk data block.
+ *
+ * @param disk_block The source disk block to insert.
+ * @param area_idx The ID of the area containing the block.
+ * @param area_offset The area_offset within the area of the block.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_block(const struct nffs_disk_block *disk_block, uint8_t area_idx,
+ uint32_t area_offset)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_block block;
+ int do_replace;
+ int new_block;
+ int rc;
+
+ new_block = 0;
+
+ /* Check the block's CRC. If the block is corrupt, discard it. If this
+ * block would have superseded another, the old block becomes current.
+ */
+ rc = nffs_crc_disk_block_validate(disk_block, area_idx, area_offset);
+ if (rc != 0) {
+ goto err;
+ }
+
+ entry = nffs_hash_find_block(disk_block->ndb_id);
+ if (entry != NULL) {
+
+ rc = nffs_block_from_hash_entry_no_ptrs(&block, entry);
+ if (rc != 0 && rc != FS_ENOENT) {
+ goto err;
+ }
+
+ /*
+ * If the old block reference is for a 'dummy' block, it was added
+ * because the owning inode's lastblock was not yet restored.
+ * Update the block hash entry and inode to reference the entry.
+ */
+ if (nffs_block_is_dummy(entry)) {
+
+ assert(entry->nhe_id == disk_block->ndb_id);
+
+ /*
+ * Entry is no longer dummy as it references the correct location
+ */
+ entry->nhe_flash_loc = nffs_flash_loc(area_idx, area_offset);
+
+ inode_entry = nffs_hash_find_inode(disk_block->ndb_inode_id);
+
+ /*
+ * Turn off flags in previously restored inode recording the
+ * allocation of a dummy block
+ */
+ if (inode_entry) {
+ nffs_inode_unsetflags(inode_entry, NFFS_INODE_FLAG_DUMMYLSTBLK);
+ }
+ }
+
+ rc = nffs_restore_block_gets_replaced(&block, disk_block,
+ &do_replace);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if (!do_replace) {
+ /* The new block is superseded by the old; nothing to do. */
+ return 0;
+ }
+
+ /*
+ * update the existing hash entry to reference the new flash location
+ */
+ entry->nhe_flash_loc = nffs_flash_loc(area_idx, area_offset);
+
+ } else {
+ entry = nffs_block_entry_alloc();
+ if (entry == NULL) {
+ rc = FS_ENOMEM;
+ goto err;
+ }
+ new_block = 1;
+ entry->nhe_id = disk_block->ndb_id;
+ entry->nhe_flash_loc = nffs_flash_loc(area_idx, area_offset);
+
+ /* The block is ready to be inserted into the hash. */
+
+ nffs_hash_insert(entry);
+
+ if (disk_block->ndb_id >= nffs_hash_next_block_id) {
+ nffs_hash_next_block_id = disk_block->ndb_id + 1;
+ }
+ }
+
+ /* Make sure the maximum block data size is not set lower than the size of
+ * an existing block.
+ */
+ if (disk_block->ndb_data_len > nffs_restore_largest_block_data_len) {
+ nffs_restore_largest_block_data_len = disk_block->ndb_data_len;
+ }
+
+ NFFS_LOG(DEBUG, "restoring block; id=0x%08x seq=%u inode_id=%u prev_id=%u "
+ "data_len=%u\n",
+ (unsigned int)disk_block->ndb_id,
+ (unsigned int)disk_block->ndb_seq,
+ (unsigned int)disk_block->ndb_inode_id,
+ (unsigned int)disk_block->ndb_prev_id,
+ disk_block->ndb_data_len);
+
+ inode_entry = nffs_hash_find_inode(disk_block->ndb_inode_id);
+
+ if (inode_entry == NULL) {
+ /*
+ * Owning inode not yet restored.
+ * Allocate a dummy inode which temporarily owns this block.
+ * It is not yet linked to a parent.
+ */
+ rc = nffs_restore_dummy_inode(disk_block->ndb_inode_id, &inode_entry);
+ if (rc != 0) {
+ goto err;
+ }
+ /*
+ * Record that this inode was created because a block was restored
+ * before the inode
+ */
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_DUMMYINOBLK);
+ inode_entry->nie_last_block_entry = entry;
+ } else {
+ if (nffs_inode_getflags(inode_entry, NFFS_INODE_FLAG_DELETED)) {
+ /*
+ * don't restore blocks for deleted inodes
+ */
+ rc = FS_ENOENT;
+ goto err;
+ }
+ }
+
+ return 0;
+
+err:
+ if (new_block) {
+ nffs_hash_remove(entry);
+ nffs_block_entry_free(entry);
+ }
+ return rc;
+}
+
+/**
+ * Populates the nffs RAM state with the memory representation of the specified
+ * disk object.
+ *
+ * @param disk_object The source disk object to convert.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_object(const struct nffs_disk_object *disk_object)
+{
+ int rc;
+
+ switch (disk_object->ndo_type) {
+ case NFFS_OBJECT_TYPE_INODE:
+ rc = nffs_restore_inode(&disk_object->ndo_disk_inode,
+ disk_object->ndo_area_idx,
+ disk_object->ndo_offset);
+ break;
+
+ case NFFS_OBJECT_TYPE_BLOCK:
+ rc = nffs_restore_block(&disk_object->ndo_disk_block,
+ disk_object->ndo_area_idx,
+ disk_object->ndo_offset);
+ break;
+
+ default:
+ rc = FS_EINVAL;
+ break;
+ }
+
+ return rc;
+}
+
+/**
+ * Reads a single disk object from flash.
+ *
+ * @param area_idx The area to read the object from.
+ * @param area_offset The offset within the area to read from.
+ * @param out_disk_object On success, the restored object gets written
+ * here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_disk_object(int area_idx, uint32_t area_offset,
+ struct nffs_disk_object *out_disk_object)
+{
+ int rc;
+
+ memset(out_disk_object, 0, sizeof *out_disk_object);
+
+ rc = nffs_flash_read(area_idx, area_offset,
+ &out_disk_object->ndo_un_obj,
+ sizeof(out_disk_object->ndo_un_obj));
+ if (rc != 0) {
+ return rc;
+ }
+ STATS_INC(nffs_stats, nffs_readcnt_object);
+
+ if (nffs_hash_id_is_inode(out_disk_object->ndo_disk_inode.ndi_id)) {
+ out_disk_object->ndo_type = NFFS_OBJECT_TYPE_INODE;
+
+ } else if (nffs_hash_id_is_block(out_disk_object->ndo_disk_block.ndb_id)) {
+ out_disk_object->ndo_type = NFFS_OBJECT_TYPE_BLOCK;
+
+ } else if (out_disk_object->ndo_disk_block.ndb_id == NFFS_ID_NONE) {
+ return FS_EEMPTY;
+
+ } else {
+ return FS_ECORRUPT;
+ }
+
+ out_disk_object->ndo_area_idx = area_idx;
+ out_disk_object->ndo_offset = area_offset;
+
+ return 0;
+}
+
+/**
+ * Calculates the disk space occupied by the specified disk object.
+ *
+ * @param disk_object
+ */
+static int
+nffs_restore_disk_object_size(const struct nffs_disk_object *disk_object)
+{
+ switch (disk_object->ndo_type) {
+ case NFFS_OBJECT_TYPE_INODE:
+ return sizeof disk_object->ndo_disk_inode +
+ disk_object->ndo_disk_inode.ndi_filename_len;
+
+ case NFFS_OBJECT_TYPE_BLOCK:
+ return sizeof disk_object->ndo_disk_block +
+ disk_object->ndo_disk_block.ndb_data_len;
+
+ default:
+ assert(0);
+ return 1;
+ }
+}
+
+/**
+ * Reads the specified area from disk and loads its contents into the RAM
+ * representation.
+ *
+ * @param area_idx The index of the area to read.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_area_contents(int area_idx)
+{
+ struct nffs_disk_object disk_object;
+ struct nffs_area *area;
+ int rc;
+
+ area = nffs_areas + area_idx;
+
+ area->na_cur = sizeof (struct nffs_disk_area);
+ while (1) {
+ rc = nffs_restore_disk_object(area_idx, area->na_cur, &disk_object);
+ switch (rc) {
+ case 0:
+
+ /* Valid object; restore it into the RAM representation. */
+ rc = nffs_restore_object(&disk_object);
+
+ /*
+ * If the restore fails the CRC check, the object length field
+ * can't be trusted so just start looking for the next valid
+ * object in the flash area.
+ * XXX Deal with file system corruption
+ */
+ if (rc == FS_ECORRUPT) {
+ area->na_cur++;
+ } else {
+ STATS_INC(nffs_stats, nffs_object_count); /* restored objects */
+ area->na_cur += nffs_restore_disk_object_size(&disk_object);
+ }
+ break;
+
+ case FS_ECORRUPT:
+ /*
+ * Invalid object; keep scanning for a valid object ID and CRC
+ * Can nffs_restore_disk_object return FS_ECORRUPT? XXX
+ */
+ area->na_cur++;
+ break;
+
+ case FS_EEMPTY:
+ case FS_EOFFSET:
+ /* End of disk encountered; area fully restored. */
+ return 0;
+
+ default:
+ return rc;
+ }
+ }
+}
+
+/**
+ * Reads and parses one area header. This function does not read the area's
+ * contents.
+ *
+ * @param out_is_scratch On success, 0 or 1 gets written here,
+ * indicating whether the area is a scratch
+ * area.
+ * @param area_offset The flash offset of the start of the area.
+ *
+ * @return 0 on success;
+ * nonzero on failure.
+ */
+static int
+nffs_restore_detect_one_area(uint8_t flash_id, uint32_t area_offset,
+ struct nffs_disk_area *out_disk_area)
+{
+ int rc;
+
+ STATS_INC(nffs_stats, nffs_readcnt_detect);
+ rc = hal_flash_read(flash_id, area_offset, out_disk_area,
+ sizeof *out_disk_area);
+ if (rc != 0) {
+ return FS_EHW;
+ }
+
+ if (!nffs_area_magic_is_set(out_disk_area)) {
+ return FS_ECORRUPT;
+ }
+
+ if (!nffs_area_is_current_version(out_disk_area)) {
+ return FS_EUNEXP;
+ }
+
+ return 0;
+}
+
+/**
+ * Repairs the effects of a corrupt scratch area. Scratch area corruption can
+ * occur when the system resets while a garbage collection cycle is in
+ * progress.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_restore_corrupt_scratch(void)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *next;
+ uint32_t area_offset;
+ uint16_t good_idx;
+ uint16_t bad_idx;
+ uint8_t area_idx;
+ int rc;
+ int i;
+
+ /* Search for a pair of areas with identical IDs. If found, these areas
+ * represent the source and destination areas of a garbage collection
+ * cycle. The shorter of the two areas was the destination area. Since
+ * the garbage collection cycle did not finish, the source area contains a
+ * more complete set of objects than the destination area.
+ *
+ * good_idx = index of source area.
+ * bad_idx = index of destination area; this will be turned into the
+ * scratch area.
+ */
+ rc = nffs_area_find_corrupt_scratch(&good_idx, &bad_idx);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* Invalidate all objects resident in the bad area. */
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ entry = SLIST_FIRST(&nffs_hash[i]);
+ while (entry != NULL) {
+ next = SLIST_NEXT(entry, nhe_next);
+
+ nffs_flash_loc_expand(entry->nhe_flash_loc,
+ &area_idx, &area_offset);
+ if (area_idx == bad_idx) {
+ if (nffs_hash_id_is_block(entry->nhe_id)) {
+ rc = nffs_block_delete_from_ram(entry);
+ if (rc != 0) {
+ return rc;
+ }
+ } else {
+ inode_entry = (struct nffs_inode_entry *)entry;
+ nffs_inode_setflags(inode_entry, NFFS_INODE_FLAG_OBSOLETE);
+ }
+ }
+
+ entry = next;
+ }
+ }
+
+ /* Now that the objects in the scratch area have been invalidated, reload
+ * everything from the good area.
+ */
+ rc = nffs_restore_area_contents(good_idx);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* Convert the bad area into a scratch area. */
+ rc = nffs_format_area(bad_idx, 1);
+ if (rc != 0) {
+ return rc;
+ }
+ nffs_scratch_area_idx = bad_idx;
+
+ return 0;
+}
+
+static void
+nffs_log_contents(void)
+{
+#if MYNEWT_VAL(LOG_LEVEL) > LOG_LEVEL_DEBUG
+ return;
+#endif
+
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *next;
+ struct nffs_block block;
+ struct nffs_inode inode;
+ int rc;
+ int i;
+
+ NFFS_HASH_FOREACH(entry, i, next) {
+ if (nffs_hash_id_is_block(entry->nhe_id)) {
+ rc = nffs_block_from_hash_entry(&block, entry);
+ assert(rc == 0 || rc == FS_ENOENT);
+ NFFS_LOG(DEBUG, "block; id=%u inode_id=",
+ (unsigned int)entry->nhe_id);
+ if (block.nb_inode_entry == NULL) {
+ NFFS_LOG(DEBUG, "null ");
+ } else {
+ NFFS_LOG(DEBUG, "%u ",
+ (unsigned int)block.nb_inode_entry->nie_hash_entry.nhe_id);
+ }
+
+ NFFS_LOG(DEBUG, "prev_id=");
+ if (block.nb_prev == NULL) {
+ NFFS_LOG(DEBUG, "null ");
+ } else {
+ NFFS_LOG(DEBUG, "%u ", (unsigned int)block.nb_prev->nhe_id);
+ }
+
+ NFFS_LOG(DEBUG, "data_len=%u\n", block.nb_data_len);
+ } else {
+ inode_entry = (void *)entry;
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ if (rc == FS_ENOENT) {
+ NFFS_LOG(DEBUG, "DUMMY file; id=%x ref=%d block_id=",
+ (unsigned int)entry->nhe_id, inode_entry->nie_refcnt);
+ if (inode_entry->nie_last_block_entry == NULL) {
+ NFFS_LOG(DEBUG, "null");
+ } else {
+ NFFS_LOG(DEBUG, "%x",
+ (unsigned int)inode_entry->nie_last_block_entry->nhe_id);
+ }
+ } else if (rc != 0) {
+ continue;
+ }
+ /*assert(rc == 0);*/
+
+ if (nffs_hash_id_is_file(entry->nhe_id)) {
+ NFFS_LOG(DEBUG, "file; id=%u name=%.3s block_id=",
+ (unsigned int)entry->nhe_id, inode.ni_filename);
+ if (inode_entry->nie_last_block_entry == NULL) {
+ NFFS_LOG(DEBUG, "null");
+ } else {
+ NFFS_LOG(DEBUG, "%u",
+ (unsigned int)inode_entry->nie_last_block_entry->nhe_id);
+ }
+ NFFS_LOG(DEBUG, "\n");
+ } else {
+ inode_entry = (void *)entry;
+ NFFS_LOG(DEBUG, "dir; id=%u name=%.3s\n",
+ (unsigned int)entry->nhe_id, inode.ni_filename);
+
+ }
+ }
+ }
+}
+
+/**
+ * Searches for a valid nffs file system among the specified areas. This
+ * function succeeds if a file system is detected among any subset of the
+ * supplied areas. If the area set does not contain a valid file system,
+ * a new one can be created via a call to nffs_format().
+ *
+ * @param area_descs The area set to search. This array must be
+ * terminated with a 0-length area.
+ *
+ * @return 0 on success;
+ * FS_ECORRUPT if no valid file system was detected;
+ * other nonzero on error.
+ */
+int
+nffs_restore_full(const struct nffs_area_desc *area_descs)
+{
+ struct nffs_disk_area disk_area;
+ int cur_area_idx;
+ int use_area;
+ int rc;
+ int i;
+
+ /* Start from a clean state. */
+ rc = nffs_misc_reset();
+ if (rc) {
+ return rc;
+ }
+ nffs_restore_largest_block_data_len = 0;
+ nffs_current_area_descs = (struct nffs_area_desc*) area_descs;
+
+ /* Read each area from flash. */
+ for (i = 0; area_descs[i].nad_length != 0; i++) {
+ if (i > NFFS_MAX_AREAS) {
+ rc = FS_EINVAL;
+ goto err;
+ }
+
+ rc = nffs_restore_detect_one_area(area_descs[i].nad_flash_id,
+ area_descs[i].nad_offset,
+ &disk_area);
+ switch (rc) {
+ case 0:
+ use_area = 1;
+ break;
+
+ case FS_EUNEXP: /* not formatted with current on-disk NFFS format */
+ case FS_ECORRUPT:
+ use_area = 0;
+ break;
+
+ default:
+ goto err;
+ }
+
+ if (use_area) {
+ if (disk_area.nda_id == NFFS_AREA_ID_NONE &&
+ nffs_scratch_area_idx != NFFS_AREA_ID_NONE) {
+
+ /* Don't allow more than one scratch area. */
+ use_area = 0;
+ }
+ }
+
+ if (use_area) {
+ /* Populate RAM with a representation of this area. */
+ cur_area_idx = nffs_num_areas;
+
+ rc = nffs_misc_set_num_areas(nffs_num_areas + 1);
+ if (rc != 0) {
+ goto err;
+ }
+
+ nffs_areas[cur_area_idx].na_offset = area_descs[i].nad_offset;
+ nffs_areas[cur_area_idx].na_length = area_descs[i].nad_length;
+ nffs_areas[cur_area_idx].na_flash_id = area_descs[i].nad_flash_id;
+ nffs_areas[cur_area_idx].na_gc_seq = disk_area.nda_gc_seq;
+ nffs_areas[cur_area_idx].na_id = disk_area.nda_id;
+
+ if (disk_area.nda_id == NFFS_AREA_ID_NONE) {
+ nffs_areas[cur_area_idx].na_cur = NFFS_AREA_OFFSET_ID;
+ nffs_scratch_area_idx = cur_area_idx;
+ } else {
+ nffs_areas[cur_area_idx].na_cur =
+ sizeof (struct nffs_disk_area);
+ nffs_restore_area_contents(cur_area_idx);
+ }
+ }
+ }
+
+ /* All areas have been restored from flash. */
+
+ if (nffs_scratch_area_idx == NFFS_AREA_ID_NONE) {
+ /* No scratch area. The system may have been rebooted in the middle of
+ * a garbage collection cycle. Look for a candidate scratch area.
+ */
+ rc = nffs_restore_corrupt_scratch();
+ if (rc != 0) {
+ if (rc == FS_ENOENT) {
+ rc = FS_ECORRUPT;
+ }
+ goto err;
+ }
+ }
+
+ /* Ensure this file system contains a valid scratch area. */
+ rc = nffs_misc_validate_scratch();
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* Make sure the file system contains a valid root directory. */
+ rc = nffs_misc_validate_root_dir();
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* Ensure there is a "/lost+found" directory. */
+ rc = nffs_misc_create_lost_found_dir();
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* Delete from RAM any objects that were invalidated when subsequent areas
+ * were restored.
+ */
+ nffs_restore_sweep();
+
+ /* Set the maximum data block size according to the size of the smallest
+ * area.
+ */
+ rc = nffs_misc_set_max_block_data_len(nffs_restore_largest_block_data_len);
+ if (rc != 0) {
+ goto err;
+ }
+
+ NFFS_LOG(DEBUG, "CONTENTS\n");
+ nffs_log_contents();
+
+ return 0;
+
+err:
+ nffs_misc_reset();
+ return rc;
+}
diff --git a/src/nffs_write.c b/src/nffs_write.c
new file mode 100644
index 0000000..2ce2248
--- /dev/null
+++ b/src/nffs_write.c
@@ -0,0 +1,434 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include "testutil/testutil.h"
+#include "nffs/nffs.h"
+#include "nffs_priv.h"
+
+static int
+nffs_write_fill_crc16_overwrite(struct nffs_disk_block *disk_block,
+ uint8_t src_area_idx, uint32_t src_area_offset,
+ uint16_t left_copy_len, uint16_t right_copy_len,
+ const void *new_data, uint16_t new_data_len)
+{
+ uint16_t block_off;
+ uint16_t crc16;
+ int rc;
+
+ block_off = 0;
+
+ crc16 = nffs_crc_disk_block_hdr(disk_block);
+ block_off += sizeof *disk_block;
+
+ /* Copy data from the start of the old block, in case the new data starts
+ * at a non-zero offset.
+ */
+ if (left_copy_len > 0) {
+ rc = nffs_crc_flash(crc16, src_area_idx, src_area_offset + block_off,
+ left_copy_len, &crc16);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += left_copy_len;
+ }
+
+ /* Write the new data into the data block. This may extend the block's
+ * length beyond its old value.
+ */
+ crc16 = crc16_ccitt(crc16, new_data, new_data_len);
+ block_off += new_data_len;
+
+ /* Copy data from the end of the old block, in case the new data doesn't
+ * extend to the end of the block.
+ */
+ if (right_copy_len > 0) {
+ rc = nffs_crc_flash(crc16, src_area_idx, src_area_offset + block_off,
+ right_copy_len, &crc16);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += right_copy_len;
+ }
+
+ assert(block_off == sizeof *disk_block + disk_block->ndb_data_len);
+
+ disk_block->ndb_crc16 = crc16;
+
+ return 0;
+}
+
+/**
+ * Overwrites an existing data block. The resulting block has the same ID as
+ * the old one, but it supersedes it with a greater sequence number.
+ *
+ * @param entry The data block to overwrite.
+ * @param left_copy_len The number of bytes of existing data to retain
+ * before the new data begins.
+ * @param new_data The new data to write to the block.
+ * @param new_data_len The number of new bytes to write to the block.
+ * If this value plus left_copy_len is less
+ * than the existing block's data length,
+ * previous data at the end of the block is
+ * retained.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_write_over_block(struct nffs_hash_entry *entry, uint16_t left_copy_len,
+ const void *new_data, uint16_t new_data_len)
+{
+ struct nffs_disk_block disk_block;
+ struct nffs_block block;
+ uint32_t src_area_offset;
+ uint32_t dst_area_offset;
+ uint16_t right_copy_len;
+ uint16_t block_off;
+ uint8_t src_area_idx;
+ uint8_t dst_area_idx;
+ int rc;
+
+ rc = nffs_block_from_hash_entry(&block, entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ assert(left_copy_len <= block.nb_data_len);
+
+ /* Determine how much old data at the end of the block needs to be
+ * retained. If the new data doesn't extend to the end of the block, the
+ * the rest of the block retains its old contents.
+ */
+ if (left_copy_len + new_data_len > block.nb_data_len) {
+ right_copy_len = 0;
+ } else {
+ right_copy_len = block.nb_data_len - left_copy_len - new_data_len;
+ }
+
+ block.nb_seq++;
+ block.nb_data_len = left_copy_len + new_data_len + right_copy_len;
+ nffs_block_to_disk(&block, &disk_block);
+
+ nffs_flash_loc_expand(entry->nhe_flash_loc,
+ &src_area_idx, &src_area_offset);
+
+ rc = nffs_write_fill_crc16_overwrite(&disk_block,
+ src_area_idx, src_area_offset,
+ left_copy_len, right_copy_len,
+ new_data, new_data_len);
+ if (rc != 0) {
+ return rc;
+ }
+
+ rc = nffs_misc_reserve_space(sizeof disk_block + disk_block.ndb_data_len,
+ &dst_area_idx, &dst_area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ block_off = 0;
+
+ /* Write the block header. */
+ rc = nffs_flash_write(dst_area_idx, dst_area_offset + block_off,
+ &disk_block, sizeof disk_block);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += sizeof disk_block;
+
+ /* Copy data from the start of the old block, in case the new data starts
+ * at a non-zero offset.
+ */
+ if (left_copy_len > 0) {
+ rc = nffs_flash_copy(src_area_idx, src_area_offset + block_off,
+ dst_area_idx, dst_area_offset + block_off,
+ left_copy_len);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += left_copy_len;
+ }
+
+ /* Write the new data into the data block. This may extend the block's
+ * length beyond its old value.
+ */
+ rc = nffs_flash_write(dst_area_idx, dst_area_offset + block_off,
+ new_data, new_data_len);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += new_data_len;
+
+ /* Copy data from the end of the old block, in case the new data doesn't
+ * extend to the end of the block.
+ */
+ if (right_copy_len > 0) {
+ rc = nffs_flash_copy(src_area_idx, src_area_offset + block_off,
+ dst_area_idx, dst_area_offset + block_off,
+ right_copy_len);
+ if (rc != 0) {
+ return rc;
+ }
+ block_off += right_copy_len;
+ }
+
+ assert(block_off == sizeof disk_block + block.nb_data_len);
+
+ entry->nhe_flash_loc = nffs_flash_loc(dst_area_idx, dst_area_offset);
+
+ ASSERT_IF_TEST(nffs_crc_disk_block_validate(&disk_block, dst_area_idx,
+ dst_area_offset) == 0);
+
+ return 0;
+}
+
+/**
+ * Appends a new block to an inode block chain.
+ *
+ * @param inode_entry The inode to append a block to.
+ * @param data The contents of the new block.
+ * @param len The number of bytes of data to write.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_write_append(struct nffs_cache_inode *cache_inode, const void *data,
+ uint16_t len)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_disk_block disk_block;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ rc = nffs_block_entry_reserve(&entry);
+ if (entry == NULL) {
+ return FS_ENOMEM;
+ }
+
+ inode_entry = cache_inode->nci_inode.ni_inode_entry;
+
+ memset(&disk_block, 0, sizeof disk_block);
+ disk_block.ndb_id = nffs_hash_next_block_id++;
+ disk_block.ndb_seq = 0;
+ disk_block.ndb_inode_id = inode_entry->nie_hash_entry.nhe_id;
+ if (inode_entry->nie_last_block_entry == NULL) {
+ disk_block.ndb_prev_id = NFFS_ID_NONE;
+ } else {
+ disk_block.ndb_prev_id = inode_entry->nie_last_block_entry->nhe_id;
+ }
+ disk_block.ndb_data_len = len;
+ nffs_crc_disk_block_fill(&disk_block, data);
+
+ rc = nffs_block_write_disk(&disk_block, data, &area_idx, &area_offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ entry->nhe_id = disk_block.ndb_id;
+ entry->nhe_flash_loc = nffs_flash_loc(area_idx, area_offset);
+ nffs_hash_insert(entry);
+
+ inode_entry->nie_last_block_entry = entry;
+
+ /*
+ * When a new block is appended to a file, the inode must be written
+ * out to flash so the last block id is is stored persistently.
+ * Need to be written atomically with writing the block out so filesystem
+ * remains consistent. nffs_lock is held in nffs_write().
+ * The inode will not be updated if it's been unlinked on disk and this
+ * is signaled by setting the hash entry's flash location to NONE
+ */
+ if (inode_entry->nie_hash_entry.nhe_flash_loc != NFFS_FLASH_LOC_NONE) {
+ rc = nffs_inode_update(inode_entry);
+ }
+
+ /* Update cached inode with the new file size. */
+ cache_inode->nci_file_size += len;
+
+ /* Add appended block to the cache. */
+ nffs_cache_seek(cache_inode, cache_inode->nci_file_size - 1, NULL);
+
+ return 0;
+}
+
+/**
+ * Performs a single write operation. The data written must be no greater
+ * than the maximum block data length. If old data gets overwritten, then
+ * the existing data blocks are superseded as necessary.
+ *
+ * @param write_info Describes the write operation being perfomred.
+ * @param inode_entry The file inode to write to.
+ * @param data The new data to write.
+ * @param data_len The number of bytes of new data to write.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+nffs_write_chunk(struct nffs_inode_entry *inode_entry, uint32_t file_offset,
+ const void *data, uint16_t data_len)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_cache_block *cache_block;
+ unsigned int gc_count;
+ uint32_t append_len;
+ uint32_t data_offset;
+ uint32_t block_end;
+ uint32_t dst_off;
+ uint16_t chunk_off;
+ uint16_t chunk_sz;
+ int rc;
+
+ assert(data_len <= nffs_block_max_data_sz);
+
+ rc = nffs_cache_inode_ensure(&cache_inode, inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /** Handle the simple append case first. */
+ if (file_offset == cache_inode->nci_file_size) {
+ rc = nffs_write_append(cache_inode, data, data_len);
+ return rc;
+ }
+
+ /** This is not an append; i.e., old data is getting overwritten. */
+
+ dst_off = file_offset + data_len;
+ data_offset = data_len;
+ cache_block = NULL;
+
+ if (dst_off > cache_inode->nci_file_size) {
+ append_len = dst_off - cache_inode->nci_file_size;
+ } else {
+ append_len = 0;
+ }
+
+ do {
+ if (cache_block == NULL) {
+ rc = nffs_cache_seek(cache_inode, dst_off - 1, &cache_block);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+
+ if (cache_block->ncb_file_offset < file_offset) {
+ chunk_off = file_offset - cache_block->ncb_file_offset;
+ } else {
+ chunk_off = 0;
+ }
+
+ chunk_sz = cache_block->ncb_block.nb_data_len - chunk_off;
+ block_end = cache_block->ncb_file_offset +
+ cache_block->ncb_block.nb_data_len;
+ if (block_end != dst_off) {
+ chunk_sz += (int)(dst_off - block_end);
+ }
+
+ /* Remember the current garbage collection count. If the count
+ * increases during the write, then the block cache has been
+ * invalidated and we need to reset our pointers.
+ */
+ gc_count = nffs_gc_count;
+
+ data_offset = cache_block->ncb_file_offset + chunk_off - file_offset;
+ rc = nffs_write_over_block(cache_block->ncb_block.nb_hash_entry,
+ chunk_off, data + data_offset, chunk_sz);
+ if (rc != 0) {
+ return rc;
+ }
+
+ dst_off -= chunk_sz;
+
+ if (gc_count != nffs_gc_count) {
+ /* Garbage collection occurred; the current cached block pointer is
+ * invalid, so reset it. The cached inode is still valid.
+ */
+ cache_block = NULL;
+ } else {
+ cache_block = TAILQ_PREV(cache_block, nffs_cache_block_list,
+ ncb_link);
+ }
+ } while (data_offset > 0);
+
+ cache_inode->nci_file_size += append_len;
+ return 0;
+}
+
+/**
+ * Writes a chunk of contiguous data to a file.
+ *
+ * @param file The file to write to.
+ * @param data The data to write.
+ * @param len The length of data to write.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+nffs_write_to_file(struct nffs_file *file, const void *data, int len)
+{
+ struct nffs_cache_inode *cache_inode;
+ const uint8_t *data_ptr;
+ uint16_t chunk_size;
+ int rc;
+
+ if (!(file->nf_access_flags & FS_ACCESS_WRITE)) {
+ return FS_EACCESS;
+ }
+
+ if (len == 0) {
+ return 0;
+ }
+
+ rc = nffs_cache_inode_ensure(&cache_inode, file->nf_inode_entry);
+ if (rc != 0) {
+ return rc;
+ }
+
+ /* The append flag forces all writes to the end of the file, regardless of
+ * seek position.
+ */
+ if (file->nf_access_flags & FS_ACCESS_APPEND) {
+ file->nf_offset = cache_inode->nci_file_size;
+ }
+
+ /* Write data as a sequence of blocks. */
+ data_ptr = data;
+ while (len > 0) {
+ if (len > nffs_block_max_data_sz) {
+ chunk_size = nffs_block_max_data_sz;
+ } else {
+ chunk_size = len;
+ }
+
+ rc = nffs_write_chunk(file->nf_inode_entry, file->nf_offset, data_ptr,
+ chunk_size);
+ if (rc != 0) {
+ return rc;
+ }
+
+ len -= chunk_size;
+ data_ptr += chunk_size;
+ file->nf_offset += chunk_size;
+ }
+
+ return 0;
+}
diff --git a/syscfg.yml b/syscfg.yml
new file mode 100644
index 0000000..33358d4
--- /dev/null
+++ b/syscfg.yml
@@ -0,0 +1,37 @@
+# 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.
+#
+
+# Package: fs/nffs
+
+syscfg.defs:
+ NFFS_FLASH_AREA:
+ description: 'Flash area to use for NFFS.'
+ type: flash_owner
+ value:
+ restrictions:
+ - $notnull
+
+ NFFS_DETECT_FAIL:
+ description: 'Controls behaviour when encountering corrupt NFFS area.'
+ value: 'NFFS_DETECT_FAIL_FORMAT'
+
+ NFFS_NUM_AREAS:
+ description: >
+ Number of areas to allocate in the NFFS disk. A smaller number is
+ used if the flash hardware cannot support this value.
+ value: 8
diff --git a/test/pkg.yml b/test/pkg.yml
new file mode 100644
index 0000000..9e64e71
--- /dev/null
+++ b/test/pkg.yml
@@ -0,0 +1,32 @@
+# 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/nffs/test
+pkg.type: unittest
+pkg.description: "NFFS unit tests."
+pkg.author: "Apache Mynewt <dev@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - fs/nffs
+ - test/testutil
+
+pkg.deps.SELFTEST:
+ - sys/console/stub
+ - sys/log/full
+ - sys/stats/stub
diff --git a/test/src/nffs_test.c b/test/src/nffs_test.c
new file mode 100644
index 0000000..369fc1c
--- /dev/null
+++ b/test/src/nffs_test.c
@@ -0,0 +1,739 @@
+/*
+ * 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.
+ */
+
+/*
+ * 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
+ *
+ * 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 <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "sysinit/sysinit.h"
+#include "syscfg/syscfg.h"
+#include "hal/hal_flash.h"
+#include "testutil/testutil.h"
+#include "fs/fs.h"
+#include "nffs/nffs.h"
+#include "nffs/nffs_test.h"
+#include "nffs_test_priv.h"
+#include "nffs_priv.h"
+#include "nffs_test.h"
+
+#if MYNEWT_VAL(SELFTEST)
+struct nffs_area_desc nffs_selftest_area_descs[] = {
+ { 0x00000000, 16 * 1024 },
+ { 0x00004000, 16 * 1024 },
+ { 0x00008000, 16 * 1024 },
+ { 0x0000c000, 16 * 1024 },
+ { 0x00010000, 64 * 1024 },
+ { 0x00020000, 128 * 1024 },
+ { 0x00040000, 128 * 1024 },
+ { 0x00060000, 128 * 1024 },
+ { 0x00080000, 128 * 1024 },
+ { 0x000a0000, 128 * 1024 },
+ { 0x000c0000, 128 * 1024 },
+ { 0x000e0000, 128 * 1024 },
+ { 0, 0 },
+};
+
+struct nffs_area_desc *save_area_descs;
+
+void
+nffs_testcase_pre(void* arg)
+{
+ save_area_descs = nffs_current_area_descs;
+ nffs_current_area_descs = nffs_selftest_area_descs;
+ return;
+}
+
+void
+nffs_testcase_post(void* arg)
+{
+ nffs_current_area_descs = save_area_descs;
+ return;
+}
+
+TEST_CASE_DECL(nffs_test_unlink)
+TEST_CASE_DECL(nffs_test_mkdir)
+TEST_CASE_DECL(nffs_test_rename)
+TEST_CASE_DECL(nffs_test_truncate)
+TEST_CASE_DECL(nffs_test_append)
+TEST_CASE_DECL(nffs_test_read)
+TEST_CASE_DECL(nffs_test_open)
+TEST_CASE_DECL(nffs_test_overwrite_one)
+TEST_CASE_DECL(nffs_test_overwrite_two)
+TEST_CASE_DECL(nffs_test_overwrite_three)
+TEST_CASE_DECL(nffs_test_overwrite_many)
+TEST_CASE_DECL(nffs_test_long_filename)
+TEST_CASE_DECL(nffs_test_large_write)
+TEST_CASE_DECL(nffs_test_many_children)
+TEST_CASE_DECL(nffs_test_gc)
+TEST_CASE_DECL(nffs_test_wear_level)
+TEST_CASE_DECL(nffs_test_corrupt_scratch)
+TEST_CASE_DECL(nffs_test_incomplete_block)
+TEST_CASE_DECL(nffs_test_corrupt_block)
+TEST_CASE_DECL(nffs_test_large_unlink)
+TEST_CASE_DECL(nffs_test_large_system)
+TEST_CASE_DECL(nffs_test_lost_found)
+TEST_CASE_DECL(nffs_test_readdir)
+TEST_CASE_DECL(nffs_test_split_file)
+TEST_CASE_DECL(nffs_test_gc_on_oom)
+
+void
+nffs_test_suite_gen_1_1_init(void)
+{
+ nffs_config.nc_num_cache_inodes = 1;
+ nffs_config.nc_num_cache_blocks = 1;
+
+ tu_suite_set_pre_test_cb(nffs_testcase_pre, NULL);
+ tu_suite_set_post_test_cb(nffs_testcase_post, NULL);
+ return;
+}
+
+void
+nffs_test_suite_gen_4_32_init(void)
+{
+ nffs_config.nc_num_cache_inodes = 4;
+ nffs_config.nc_num_cache_blocks = 32;
+
+ tu_suite_set_pre_test_cb(nffs_testcase_pre, NULL);
+ tu_suite_set_post_test_cb(nffs_testcase_post, NULL);
+ return;
+}
+
+void
+nffs_test_suite_gen_32_1024_init(void)
+{
+ nffs_config.nc_num_cache_inodes = 32;
+ nffs_config.nc_num_cache_blocks = 1024;
+
+ tu_suite_set_pre_test_cb(nffs_testcase_pre, NULL);
+ tu_suite_set_post_test_cb(nffs_testcase_post, NULL);
+ return;
+}
+
+TEST_SUITE(nffs_test_suite)
+{
+ int rc;
+
+ rc = nffs_init();
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_unlink();
+ nffs_test_mkdir();
+ nffs_test_rename();
+ nffs_test_truncate();
+ nffs_test_append();
+ nffs_test_read();
+ nffs_test_open();
+ nffs_test_overwrite_one();
+ nffs_test_overwrite_two();
+ nffs_test_overwrite_three();
+ nffs_test_overwrite_many();
+ nffs_test_long_filename();
+ nffs_test_large_write();
+ nffs_test_many_children();
+ nffs_test_gc();
+ nffs_test_wear_level();
+ nffs_test_corrupt_scratch();
+ nffs_test_incomplete_block();
+ nffs_test_corrupt_block();
+ nffs_test_large_unlink();
+ nffs_test_large_system();
+ nffs_test_lost_found();
+ nffs_test_readdir();
+ nffs_test_split_file();
+ nffs_test_gc_on_oom();
+}
+
+TEST_CASE_DECL(nffs_test_cache_large_file)
+
+TEST_SUITE(nffs_suite_cache)
+{
+ int rc;
+
+ rc = nffs_init();
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_cache_large_file();
+}
+
+void
+nffs_test_suite_cache_init(void)
+{
+ memset(&nffs_config, 0, sizeof nffs_config);
+ nffs_config.nc_num_cache_inodes = 4;
+ nffs_config.nc_num_cache_blocks = 64;
+
+ tu_suite_set_pre_test_cb(nffs_testcase_pre, NULL);
+ tu_suite_set_post_test_cb(nffs_testcase_post, NULL);
+ return;
+}
+
+int
+main(void)
+{
+ nffs_config.nc_num_inodes = 1024 * 8;
+ nffs_config.nc_num_blocks = 1024 * 20;
+ nffs_current_area_descs = nffs_selftest_area_descs;
+
+ sysinit();
+
+ tu_suite_set_init_cb((void*)nffs_test_suite_gen_1_1_init, NULL);
+ nffs_test_suite();
+
+ tu_suite_set_init_cb((void*)nffs_test_suite_gen_4_32_init, NULL);
+ nffs_test_suite();
+
+ tu_suite_set_init_cb((void*)nffs_test_suite_gen_32_1024_init, NULL);
+ nffs_test_suite();
+
+ tu_suite_set_init_cb((void*)nffs_test_suite_cache_init, NULL);
+ nffs_suite_cache();
+
+ return tu_any_failed;
+}
+
+#if 0
+#include <unistd.h>
+
+void
+nffs_assert_handler(const char *file, int line, const char *func, const char *e)
+{
+ char msg[256];
+
+ snprintf(msg, sizeof(msg), "assert at %s:%d\n", file, line);
+ write(1, msg, strlen(msg));
+ _exit(1);
+}
+#endif
+
+#ifdef NFFS_DEBUG
+/*
+ * All debug stuff below this
+ */
+int print_verbose;
+
+void
+print_inode_entry(struct nffs_inode_entry *inode_entry, int indent)
+{
+ struct nffs_inode inode;
+ char name[NFFS_FILENAME_MAX_LEN + 1];
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ if (inode_entry == nffs_root_dir) {
+ printf("%*s/\n", indent, "");
+ return;
+ }
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ /*
+ * Dummy inode
+ */
+ if (rc == FS_ENOENT) {
+ printf(" DUMMY %d\n", rc);
+ return;
+ }
+
+ nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+
+ rc = nffs_flash_read(area_idx,
+ area_offset + sizeof (struct nffs_disk_inode),
+ name, inode.ni_filename_len);
+
+ name[inode.ni_filename_len] = '\0';
+
+ /*printf("%*s%s\n", indent, "", name[0] == '\0' ? "/" : name);*/
+ printf("%*s%s %d %d %x\n", indent, "", name[0] == '\0' ? "/" : name,
+ inode.ni_filename_len, inode.ni_seq,
+ inode.ni_inode_entry->nie_flags);
+}
+
+void
+process_inode_entry(struct nffs_inode_entry *inode_entry, int indent)
+{
+ struct nffs_inode_entry *child;
+
+ print_inode_entry(inode_entry, indent);
+
+ if (nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) {
+ SLIST_FOREACH(child, &inode_entry->nie_child_list, nie_sibling_next) {
+ process_inode_entry(child, indent + 2);
+ }
+ }
+}
+
+int
+print_nffs_flash_inode(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_inode ndi;
+ char filename[128];
+ int len;
+ int rc;
+
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndi, sizeof(ndi));
+ assert(rc == 0);
+
+ memset(filename, 0, sizeof(filename));
+ len = min(sizeof(filename) - 1, ndi.ndi_filename_len);
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off + sizeof(ndi),
+ filename, len);
+
+ printf(" off %x %s id %x flen %d seq %d last %x prnt %x flgs %x %s\n",
+ off,
+ (nffs_hash_id_is_file(ndi.ndi_id) ? "File" :
+ (nffs_hash_id_is_dir(ndi.ndi_id) ? "Dir" : "???")),
+ ndi.ndi_id,
+ ndi.ndi_filename_len,
+ ndi.ndi_seq,
+ ndi.ndi_lastblock_id,
+ ndi.ndi_parent_id,
+ ndi.ndi_flags,
+ filename);
+ return sizeof(ndi) + ndi.ndi_filename_len;
+}
+
+int
+print_nffs_flash_block(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_block ndb;
+ int rc;
+
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndb, sizeof(ndb));
+ assert(rc == 0);
+
+ printf(" off %x Block id %x len %d seq %d prev %x own ino %x\n",
+ off,
+ ndb.ndb_id,
+ ndb.ndb_data_len,
+ ndb.ndb_seq,
+ ndb.ndb_prev_id,
+ ndb.ndb_inode_id);
+ return sizeof(ndb) + ndb.ndb_data_len;
+}
+
+int
+print_nffs_flash_object(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_object ndo;
+
+ hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndo.ndo_un_obj, sizeof(ndo.ndo_un_obj));
+
+ if (nffs_hash_id_is_inode(ndo.ndo_disk_inode.ndi_id)) {
+ return print_nffs_flash_inode(area, off);
+
+ } else if (nffs_hash_id_is_block(ndo.ndo_disk_block.ndb_id)) {
+ return print_nffs_flash_block(area, off);
+
+ } else if (ndo.ndo_disk_block.ndb_id == 0xffffffff) {
+ return area->na_length;
+
+ } else {
+ return 1;
+ }
+}
+
+void
+print_nffs_flash_areas(int verbose)
+{
+ struct nffs_area area;
+ struct nffs_disk_area darea;
+ int off;
+ int i;
+
+ for (i = 0; nffs_current_area_descs[i].nad_length != 0; i++) {
+ if (i > NFFS_MAX_AREAS) {
+ return;
+ }
+ area.na_offset = nffs_current_area_descs[i].nad_offset;
+ area.na_length = nffs_current_area_descs[i].nad_length;
+ area.na_flash_id = nffs_current_area_descs[i].nad_flash_id;
+ hal_flash_read(area.na_flash_id, area.na_offset, &darea, sizeof(darea));
+ area.na_id = darea.nda_id;
+ area.na_cur = nffs_areas[i].na_cur;
+ if (!nffs_area_magic_is_set(&darea)) {
+ printf("Area header corrupt!\n");
+ }
+ printf("area %d: id %d %x-%x cur %x len %d flashid %x gc-seq %d %s%s\n",
+ i, area.na_id, area.na_offset, area.na_offset + area.na_length,
+ area.na_cur, area.na_length, area.na_flash_id, darea.nda_gc_seq,
+ nffs_scratch_area_idx == i ? "(scratch)" : "",
+ !nffs_area_magic_is_set(&darea) ? "corrupt" : "");
+ if (verbose < 2) {
+ off = sizeof (struct nffs_disk_area);
+ while (off < area.na_length) {
+ off += print_nffs_flash_object(&area, off);
+ }
+ }
+ }
+}
+
+static int
+nffs_hash_fn(uint32_t id)
+{
+ return id % NFFS_HASH_SIZE;
+}
+
+void
+print_hashlist(struct nffs_hash_entry *he)
+{
+ struct nffs_hash_list *list;
+ int idx = nffs_hash_fn(he->nhe_id);
+ list = nffs_hash + idx;
+
+ SLIST_FOREACH(he, list, nhe_next) {
+ printf("hash_entry %s 0x%x: id 0x%x flash_loc 0x%x next 0x%x\n",
+ nffs_hash_id_is_inode(he->nhe_id) ? "inode" : "block",
+ (unsigned int)he,
+ he->nhe_id, he->nhe_flash_loc,
+ (unsigned int)he->nhe_next.sle_next);
+ }
+}
+
+void
+print_hash(void)
+{
+ int i;
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+ struct nffs_inode ni;
+ struct nffs_disk_inode di;
+ struct nffs_block nb;
+ struct nffs_disk_block db;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ NFFS_HASH_FOREACH(he, i, next) {
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ printf("hash_entry inode %d 0x%x: id 0x%x flash_loc 0x%x next 0x%x\n",
+ i, (unsigned int)he,
+ he->nhe_id, he->nhe_flash_loc,
+ (unsigned int)he->nhe_next.sle_next);
+ if (he->nhe_id == NFFS_ID_ROOT_DIR) {
+ continue;
+ }
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_inode_read_disk(area_idx, area_offset, &di);
+ if (rc) {
+ printf("%d: fail inode read id 0x%x rc %d\n",
+ i, he->nhe_id, rc);
+ }
+ printf(" Disk inode: id %x seq %d parent %x last %x flgs %x\n",
+ di.ndi_id,
+ di.ndi_seq,
+ di.ndi_parent_id,
+ di.ndi_lastblock_id,
+ di.ndi_flags);
+ ni.ni_inode_entry = (struct nffs_inode_entry *)he;
+ ni.ni_seq = di.ndi_seq;
+ ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id);
+ printf(" RAM inode: entry 0x%x seq %d parent %x filename %s\n",
+ (unsigned int)ni.ni_inode_entry,
+ ni.ni_seq,
+ (unsigned int)ni.ni_parent,
+ ni.ni_filename);
+
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ printf("hash_entry block %d 0x%x: id 0x%x flash_loc 0x%x next 0x%x\n",
+ i, (unsigned int)he,
+ he->nhe_id, he->nhe_flash_loc,
+ (unsigned int)he->nhe_next.sle_next);
+ rc = nffs_block_from_hash_entry(&nb, he);
+ if (rc) {
+ printf("%d: fail block read id 0x%x rc %d\n",
+ i, he->nhe_id, rc);
+ }
+ printf(" block: id %x seq %d inode %x prev %x\n",
+ nb.nb_hash_entry->nhe_id, nb.nb_seq,
+ nb.nb_inode_entry->nie_hash_entry.nhe_id,
+ nb.nb_prev->nhe_id);
+ nffs_flash_loc_expand(nb.nb_hash_entry->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &db);
+ if (rc) {
+ printf("%d: fail disk block read id 0x%x rc %d\n",
+ i, nb.nb_hash_entry->nhe_id, rc);
+ }
+ printf(" disk block: id %x seq %d inode %x prev %x len %d\n",
+ db.ndb_id,
+ db.ndb_seq,
+ db.ndb_inode_id,
+ db.ndb_prev_id,
+ db.ndb_data_len);
+ } else {
+ printf("hash_entry UNKNONN %d 0x%x: id 0x%x flash_loc 0x%x next 0x%x\n",
+ i, (unsigned int)he,
+ he->nhe_id, he->nhe_flash_loc,
+ (unsigned int)he->nhe_next.sle_next);
+ }
+ }
+
+}
+
+void
+nffs_print_object(struct nffs_disk_object *dobj)
+{
+ struct nffs_disk_inode *di = &dobj->ndo_disk_inode;
+ struct nffs_disk_block *db = &dobj->ndo_disk_block;
+
+ if (dobj->ndo_type == NFFS_OBJECT_TYPE_INODE) {
+ printf(" %s id %x seq %d prnt %x last %x\n",
+ nffs_hash_id_is_file(di->ndi_id) ? "File" :
+ nffs_hash_id_is_dir(di->ndi_id) ? "Dir" : "???",
+ di->ndi_id, di->ndi_seq, di->ndi_parent_id,
+ di->ndi_lastblock_id);
+ } else if (dobj->ndo_type != NFFS_OBJECT_TYPE_BLOCK) {
+ printf(" %s: id %x seq %d ino %x prev %x len %d\n",
+ nffs_hash_id_is_block(db->ndb_id) ? "Block" : "Block?",
+ db->ndb_id, db->ndb_seq, db->ndb_inode_id,
+ db->ndb_prev_id, db->ndb_data_len);
+ }
+}
+
+void
+print_nffs_hash_block(struct nffs_hash_entry *he, int verbose)
+{
+ struct nffs_block nb;
+ struct nffs_disk_block db;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ if (he == NULL) {
+ return;
+ }
+ if (!nffs_hash_entry_is_dummy(he)) {
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &db);
+ if (rc) {
+ printf("%p: fail block read id 0x%x rc %d\n",
+ he, he->nhe_id, rc);
+ }
+ nb.nb_hash_entry = he;
+ nb.nb_seq = db.ndb_seq;
+ if (db.ndb_inode_id != NFFS_ID_NONE) {
+ nb.nb_inode_entry = nffs_hash_find_inode(db.ndb_inode_id);
+ } else {
+ nb.nb_inode_entry = (void*)db.ndb_inode_id;
+ }
+ if (db.ndb_prev_id != NFFS_ID_NONE) {
+ nb.nb_prev = nffs_hash_find_block(db.ndb_prev_id);
+ } else {
+ nb.nb_prev = (void*)db.ndb_prev_id;
+ }
+ nb.nb_data_len = db.ndb_data_len;
+ } else {
+ nb.nb_inode_entry = NULL;
+ db.ndb_id = 0;
+ }
+ if (!verbose) {
+ printf("%s%s id %x idx/off %d/%x seq %d ino %x prev %x len %d\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_block(he->nhe_id) ? "Block" : "Unknown",
+ he->nhe_id, area_idx, area_offset, nb.nb_seq,
+ nb.nb_inode_entry->nie_hash_entry.nhe_id,
+ (unsigned int)db.ndb_prev_id, db.ndb_data_len);
+ return;
+ }
+ printf("%s%s id %x loc %x/%x %x ent %p\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_block(he->nhe_id) ? "Block:" : "Unknown:",
+ he->nhe_id, area_idx, area_offset, he->nhe_flash_loc, he);
+ if (nb.nb_inode_entry) {
+ printf(" Ram: ent %p seq %d ino %p prev %p len %d\n",
+ nb.nb_hash_entry, nb.nb_seq,
+ nb.nb_inode_entry, nb.nb_prev, nb.nb_data_len);
+ }
+ if (db.ndb_id) {
+ printf(" Disk %s id %x seq %d ino %x prev %x len %d\n",
+ nffs_hash_id_is_block(db.ndb_id) ? "Block:" : "???:",
+ db.ndb_id, db.ndb_seq, db.ndb_inode_id,
+ db.ndb_prev_id, db.ndb_data_len);
+ }
+}
+
+void
+print_nffs_hash_inode(struct nffs_hash_entry *he, int verbose)
+{
+ struct nffs_inode ni;
+ struct nffs_disk_inode di;
+ struct nffs_inode_entry *nie = (struct nffs_inode_entry*)he;
+ int cached_name_len;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ if (he == NULL) {
+ return;
+ }
+ if (!nffs_hash_entry_is_dummy(he)) {
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_inode_read_disk(area_idx, area_offset, &di);
+ if (rc) {
+ printf("Entry %p: fail inode read id 0x%x rc %d\n",
+ he, he->nhe_id, rc);
+ }
+ ni.ni_inode_entry = (struct nffs_inode_entry *)he;
+ ni.ni_seq = di.ndi_seq;
+ if (di.ndi_parent_id != NFFS_ID_NONE) {
+ ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id);
+ } else {
+ ni.ni_parent = NULL;
+ }
+ if (ni.ni_filename_len > NFFS_SHORT_FILENAME_LEN) {
+ cached_name_len = NFFS_SHORT_FILENAME_LEN;
+ } else {
+ cached_name_len = ni.ni_filename_len;
+ }
+ if (cached_name_len != 0) {
+ rc = nffs_flash_read(area_idx, area_offset + sizeof di,
+ ni.ni_filename, cached_name_len);
+ if (rc != 0) {
+ printf("entry %p: fail filename read id 0x%x rc %d\n",
+ he, he->nhe_id, rc);
+ return;
+ }
+ }
+ } else {
+ ni.ni_inode_entry = NULL;
+ di.ndi_id = 0;
+ }
+ if (!verbose) {
+ printf("%s%s id %x idx/off %x/%x seq %d prnt %x last %x flags %x",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+
+ nffs_hash_id_is_file(he->nhe_id) ? "File" :
+ he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir" :
+ nffs_hash_id_is_dir(he->nhe_id) ? "Dir" : "Inode",
+
+ he->nhe_id, area_idx, area_offset, ni.ni_seq, di.ndi_parent_id,
+ di.ndi_lastblock_id, nie->nie_flags);
+ if (ni.ni_inode_entry) {
+ printf(" ref %d\n", ni.ni_inode_entry->nie_refcnt);
+ } else {
+ printf("\n");
+ }
+ return;
+ }
+ printf("%s%s id %x loc %x/%x %x entry %p\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_file(he->nhe_id) ? "File:" :
+ he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir:" :
+ nffs_hash_id_is_dir(he->nhe_id) ? "Dir:" : "Inode:",
+ he->nhe_id, area_idx, area_offset, he->nhe_flash_loc, he);
+ if (ni.ni_inode_entry) {
+ printf(" ram: ent %p seq %d prnt %p lst %p ref %d flgs %x nm %s\n",
+ ni.ni_inode_entry, ni.ni_seq, ni.ni_parent,
+ ni.ni_inode_entry->nie_last_block_entry,
+ ni.ni_inode_entry->nie_refcnt, ni.ni_inode_entry->nie_flags,
+ ni.ni_filename);
+ }
+ if (rc == 0) {
+ printf(" Disk %s: id %x seq %d prnt %x lst %x flgs %x\n",
+ nffs_hash_id_is_file(di.ndi_id) ? "File" :
+ nffs_hash_id_is_dir(di.ndi_id) ? "Dir" : "???",
+ di.ndi_id, di.ndi_seq, di.ndi_parent_id,
+ di.ndi_lastblock_id, di.ndi_flags);
+ }
+}
+
+void
+print_hash_entries(int verbose)
+{
+ int i;
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+
+ printf("\nnffs_hash_entries:\n");
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ he = SLIST_FIRST(nffs_hash + i);
+ while (he != NULL) {
+ next = SLIST_NEXT(he, nhe_next);
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ print_nffs_hash_inode(he, verbose);
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ print_nffs_hash_block(he, verbose);
+ } else {
+ printf("UNKNOWN type hash entry %d: id 0x%x loc 0x%x\n",
+ i, he->nhe_id, he->nhe_flash_loc);
+ }
+ he = next;
+ }
+ }
+}
+
+void
+print_nffs_hashlist(int verbose)
+{
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+ int i;
+
+ NFFS_HASH_FOREACH(he, i, next) {
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ print_nffs_hash_inode(he, verbose);
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ print_nffs_hash_block(he, verbose);
+ } else {
+ printf("UNKNOWN type hash entry %d: id 0x%x loc 0x%x\n",
+ i, he->nhe_id, he->nhe_flash_loc);
+ }
+ }
+}
+
+void
+printfs()
+{
+ if (nffs_misc_ready()) {
+ printf("NFFS directory:\n");
+ process_inode_entry(nffs_root_dir, print_verbose);
+
+ printf("\nNFFS hash list:\n");
+ print_nffs_hashlist(print_verbose);
+ }
+ printf("\nNFFS flash areas:\n");
+ print_nffs_flash_areas(print_verbose);
+}
+#endif /* NFFS_DEBUG */
+#endif /* MYNEWT_VAL */
diff --git a/test/src/nffs_test.h b/test/src/nffs_test.h
new file mode 100644
index 0000000..a7b5c3c
--- /dev/null
+++ b/test/src/nffs_test.h
@@ -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.
+ */
+
+#ifndef H_NFFS_TEST_
+#define H_NFFS_TEST_
+
+#define LOG_BUILD_STRING "{{TARGET}} Build {{BUILD_NUMBER}}:"
+
+int nffs_test_all(void);
+
+#endif
diff --git a/test/src/nffs_test_debug.c b/test/src/nffs_test_debug.c
new file mode 100644
index 0000000..2e2965d
--- /dev/null
+++ b/test/src/nffs_test_debug.c
@@ -0,0 +1,579 @@
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "hal/hal_flash.h"
+#include "testutil/testutil.h"
+#include "fs/fs.h"
+#include "nffs/nffs.h"
+#include "nffs_test.h"
+#include "nffs_test_priv.h"
+#include "nffs_priv.h"
+
+int print_verbose;
+
+void
+print_inode_entry(struct nffs_inode_entry *inode_entry, int indent)
+{
+ struct nffs_inode inode;
+ char name[NFFS_FILENAME_MAX_LEN + 1];
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ if (inode_entry == nffs_root_dir) {
+ printf("%*s/\n", indent, "");
+ return;
+ }
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ /*
+ * Dummy inode
+ */
+ if (rc == FS_ENOENT) {
+ printf(" DUMMY %d\n", rc);
+ return;
+ }
+
+ nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+
+
+ rc = nffs_flash_read(area_idx,
+ area_offset + sizeof (struct nffs_disk_inode),
+ name, inode.ni_filename_len);
+
+ name[inode.ni_filename_len] = '\0';
+
+ printf("%*s%s %ju %jx\n", indent, "", name[0] == '\0' ? "/" : name,
+ (uintmax_t) inode.ni_seq,
+ (uintmax_t) inode.ni_inode_entry->nie_flags);
+}
+
+void
+process_inode_entry(struct nffs_inode_entry *inode_entry, int indent)
+{
+ struct nffs_inode_entry *child;
+
+ print_inode_entry(inode_entry, indent);
+
+ if (nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) {
+ SLIST_FOREACH(child, &inode_entry->nie_child_list, nie_sibling_next) {
+ process_inode_entry(child, indent + 2);
+ }
+ }
+}
+
+int
+print_nffs_flash_inode(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_inode ndi;
+ char filename[128];
+ int len;
+ int rc;
+
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndi, sizeof(ndi));
+ assert(rc == 0);
+
+ memset(filename, 0, sizeof(filename));
+ len = min(sizeof(filename) - 1, ndi.ndi_filename_len);
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off + sizeof(ndi),
+ filename, len);
+
+ printf(" off %jx %s id %jx flen %ju seq %ju last %jx prnt %jx "
+ "flgs %jx %s\n",
+ (uintmax_t) off,
+ (nffs_hash_id_is_file(ndi.ndi_id) ? "File" :
+ (nffs_hash_id_is_dir(ndi.ndi_id) ? "Dir" : "???")),
+ (uintmax_t) ndi.ndi_id,
+ (uintmax_t) ndi.ndi_filename_len,
+ (uintmax_t) ndi.ndi_seq,
+ (uintmax_t) ndi.ndi_lastblock_id,
+ (uintmax_t) ndi.ndi_parent_id,
+ (uintmax_t) ndi.ndi_flags,
+ filename);
+ return sizeof(ndi) + ndi.ndi_filename_len;
+}
+
+int
+print_nffs_flash_block(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_block ndb;
+ int rc;
+
+ rc = hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndb, sizeof(ndb));
+ assert(rc == 0);
+
+ printf(" off %jx Block id %jx len %ju seq %ju prev %jx own ino %jx\n",
+ (uintmax_t) off,
+ (uintmax_t) ndb.ndb_id,
+ (uintmax_t) ndb.ndb_data_len,
+ (uintmax_t) ndb.ndb_seq,
+ (uintmax_t) ndb.ndb_prev_id,
+ (uintmax_t) ndb.ndb_inode_id);
+ return sizeof(ndb) + ndb.ndb_data_len;
+}
+
+int
+print_nffs_flash_object(struct nffs_area *area, uint32_t off)
+{
+ struct nffs_disk_object ndo;
+
+ hal_flash_read(area->na_flash_id, area->na_offset + off,
+ &ndo.ndo_un_obj, sizeof(ndo.ndo_un_obj));
+
+ if (nffs_hash_id_is_inode(ndo.ndo_disk_inode.ndi_id)) {
+ return print_nffs_flash_inode(area, off);
+
+ } else if (nffs_hash_id_is_block(ndo.ndo_disk_block.ndb_id)) {
+ return print_nffs_flash_block(area, off);
+
+ } else if (ndo.ndo_disk_block.ndb_id == 0xffffffff) {
+ return area->na_length;
+
+ } else {
+ return 1;
+ }
+}
+
+void
+print_nffs_flash_areas(int verbose)
+{
+ struct nffs_area area;
+ struct nffs_disk_area darea;
+ int off;
+ int i;
+
+ for (i = 0; nffs_current_area_descs[i].nad_length != 0; i++) {
+ if (i > NFFS_MAX_AREAS) {
+ return;
+ }
+ area.na_offset = nffs_current_area_descs[i].nad_offset;
+ area.na_length = nffs_current_area_descs[i].nad_length;
+ area.na_flash_id = nffs_current_area_descs[i].nad_flash_id;
+ hal_flash_read(area.na_flash_id, area.na_offset, &darea, sizeof(darea));
+ area.na_id = darea.nda_id;
+ area.na_cur = nffs_areas[i].na_cur;
+ if (!nffs_area_magic_is_set(&darea)) {
+ printf("Area header corrupt!\n");
+ }
+ printf("area %d: id %ju %jx-%jx cur %jx len %ju flashid %jx "
+ "gc-seq %jd %s%s\n",
+ i,
+ (uintmax_t)area.na_id,
+ (uintmax_t)area.na_offset,
+ (uintmax_t)area.na_offset + area.na_length,
+ (uintmax_t)area.na_cur,
+ (uintmax_t)area.na_length,
+ (uintmax_t)area.na_flash_id,
+ (uintmax_t)darea.nda_gc_seq,
+ nffs_scratch_area_idx == i ? "(scratch)" : "",
+ !nffs_area_magic_is_set(&darea) ? "corrupt" : "");
+ if (verbose < 2) {
+ off = sizeof (struct nffs_disk_area);
+ while (off < area.na_length) {
+ off += print_nffs_flash_object(&area, off);
+ }
+ }
+ }
+}
+
+static int
+nffs_hash_fn(uint32_t id)
+{
+ return id % NFFS_HASH_SIZE;
+}
+
+void
+print_hashlist(struct nffs_hash_entry *he)
+{
+ struct nffs_hash_list *list;
+ int idx = nffs_hash_fn(he->nhe_id);
+ list = nffs_hash + idx;
+
+ SLIST_FOREACH(he, list, nhe_next) {
+ printf("hash_entry %s %p: id 0x%jx flash_loc 0x%jx next %p\n",
+ nffs_hash_id_is_inode(he->nhe_id) ? "inode" : "block",
+ he,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc,
+ he->nhe_next.sle_next);
+ }
+}
+
+void
+print_hash(void)
+{
+ int i;
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+ struct nffs_inode ni;
+ struct nffs_disk_inode di;
+ struct nffs_block nb;
+ struct nffs_disk_block db;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ NFFS_HASH_FOREACH(he, i, next) {
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ printf("hash_entry inode %d %p: id 0x%jx flash_loc 0x%jx "
+ "next %p\n",
+ i,
+ he,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc,
+ he->nhe_next.sle_next);
+ if (he->nhe_id == NFFS_ID_ROOT_DIR) {
+ continue;
+ }
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_inode_read_disk(area_idx, area_offset, &di);
+ if (rc) {
+ printf("%d: fail inode read id 0x%jx rc %d\n",
+ i, (uintmax_t)he->nhe_id, rc);
+ }
+ printf(" Disk inode: id %jx seq %ju parent %jx last %jx "
+ "flgs %jx\n",
+ (uintmax_t)di.ndi_id,
+ (uintmax_t)di.ndi_seq,
+ (uintmax_t)di.ndi_parent_id,
+ (uintmax_t)di.ndi_lastblock_id,
+ (uintmax_t)di.ndi_flags);
+ ni.ni_inode_entry = (struct nffs_inode_entry *)he;
+ ni.ni_seq = di.ndi_seq;
+ ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id);
+ printf(" RAM inode: entry %p seq %ju parent %p "
+ "filename %s\n",
+ ni.ni_inode_entry,
+ (uintmax_t)ni.ni_seq,
+ ni.ni_parent,
+ ni.ni_filename);
+
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ printf("hash_entry block %d %p: id 0x%jx flash_loc 0x%jx "
+ "next %p\n",
+ i,
+ he,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc,
+ he->nhe_next.sle_next);
+ rc = nffs_block_from_hash_entry(&nb, he);
+ if (rc) {
+ printf("%d: fail block read id 0x%jx rc %d\n",
+ i, (uintmax_t)he->nhe_id, rc);
+ }
+ printf(" block: id %jx seq %ju inode %jx prev %jx\n",
+ (uintmax_t)nb.nb_hash_entry->nhe_id,
+ (uintmax_t)nb.nb_seq,
+ (uintmax_t)nb.nb_inode_entry->nie_hash_entry.nhe_id,
+ (uintmax_t)nb.nb_prev->nhe_id);
+ nffs_flash_loc_expand(nb.nb_hash_entry->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &db);
+ if (rc) {
+ printf("%d: fail disk block read id 0x%jx rc %d\n",
+ i, (uintmax_t)nb.nb_hash_entry->nhe_id, rc);
+ }
+ printf(" disk block: id %jx seq %ju inode %jx prev %jx "
+ "len %ju\n",
+ (uintmax_t)db.ndb_id,
+ (uintmax_t)db.ndb_seq,
+ (uintmax_t)db.ndb_inode_id,
+ (uintmax_t)db.ndb_prev_id,
+ (uintmax_t)db.ndb_data_len);
+ } else {
+ printf("hash_entry UNKNONN %d %p: id 0x%jx flash_loc 0x%jx "
+ "next %p\n",
+ i,
+ he,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc,
+ he->nhe_next.sle_next);
+ }
+ }
+
+}
+
+void
+nffs_print_object(struct nffs_disk_object *dobj)
+{
+ struct nffs_disk_inode *di = &dobj->ndo_disk_inode;
+ struct nffs_disk_block *db = &dobj->ndo_disk_block;
+
+ if (dobj->ndo_type == NFFS_OBJECT_TYPE_INODE) {
+ printf(" %s id %jx seq %ju prnt %jx last %jx\n",
+ nffs_hash_id_is_file(di->ndi_id) ? "File" :
+ nffs_hash_id_is_dir(di->ndi_id) ? "Dir" : "???",
+ (uintmax_t)di->ndi_id,
+ (uintmax_t)di->ndi_seq,
+ (uintmax_t)di->ndi_parent_id,
+ (uintmax_t)di->ndi_lastblock_id);
+ } else if (dobj->ndo_type != NFFS_OBJECT_TYPE_BLOCK) {
+ printf(" %s: id %jx seq %ju ino %jx prev %jx len %ju\n",
+ nffs_hash_id_is_block(db->ndb_id) ? "Block" : "Block?",
+ (uintmax_t)db->ndb_id,
+ (uintmax_t)db->ndb_seq,
+ (uintmax_t)db->ndb_inode_id,
+ (uintmax_t)db->ndb_prev_id,
+ (uintmax_t)db->ndb_data_len);
+ }
+}
+
+void
+print_nffs_hash_block(struct nffs_hash_entry *he, int verbose)
+{
+ struct nffs_block nb = { 0 };
+ struct nffs_disk_block db = { 0 };
+ uint32_t area_offset = 0;
+ uint8_t area_idx = 0;
+ int rc;
+
+ if (he == NULL) {
+ return;
+ }
+ if (!nffs_hash_entry_is_dummy(he)) {
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_block_read_disk(area_idx, area_offset, &db);
+ if (rc) {
+ printf("%p: fail block read id 0x%jx rc %d\n",
+ he, (uintmax_t)he->nhe_id, rc);
+
+ }
+ nb.nb_hash_entry = he;
+ nb.nb_seq = db.ndb_seq;
+ if (db.ndb_inode_id != NFFS_ID_NONE) {
+ nb.nb_inode_entry = nffs_hash_find_inode(db.ndb_inode_id);
+ } else {
+ nb.nb_inode_entry = (void*)db.ndb_inode_id;
+ }
+ if (db.ndb_prev_id != NFFS_ID_NONE) {
+ nb.nb_prev = nffs_hash_find_block(db.ndb_prev_id);
+ } else {
+ nb.nb_prev = (void*)db.ndb_prev_id;
+ }
+ nb.nb_data_len = db.ndb_data_len;
+ }
+ if (!verbose) {
+ printf("%s%s id %jx idx/off %ju/%jx seq %ju ino %jx prev %jx "
+ "len %ju\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_block(he->nhe_id) ? "Block" : "Unknown",
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)area_idx,
+ (uintmax_t)area_offset,
+ (uintmax_t)nb.nb_seq,
+ (uintmax_t)(nb.nb_inode_entry ? nb.nb_inode_entry->nie_hash_entry.nhe_id : 0),
+ (uintmax_t)db.ndb_prev_id,
+ (uintmax_t)db.ndb_data_len);
+ return;
+ }
+ printf("%s%s id %jx loc %jx/%jx %jx ent %p\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_block(he->nhe_id) ? "Block:" : "Unknown:",
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)area_idx,
+ (uintmax_t)area_offset,
+ (uintmax_t)he->nhe_flash_loc,
+ he);
+ if (nb.nb_inode_entry) {
+ printf(" Ram: ent %p seq %ju ino %p prev %p len %ju\n",
+ nb.nb_hash_entry,
+ (uintmax_t)nb.nb_seq,
+ nb.nb_inode_entry,
+ nb.nb_prev,
+ (uintmax_t)nb.nb_data_len);
+ }
+ if (db.ndb_id) {
+ printf(" Disk %s id %jx seq %ju ino %jx prev %jx len %ju\n",
+ nffs_hash_id_is_block(db.ndb_id) ? "Block:" : "???:",
+ (uintmax_t)db.ndb_id,
+ (uintmax_t)db.ndb_seq,
+ (uintmax_t)db.ndb_inode_id,
+ (uintmax_t)db.ndb_prev_id,
+ (uintmax_t)db.ndb_data_len);
+ }
+}
+
+void
+print_nffs_hash_inode(struct nffs_hash_entry *he, int verbose)
+{
+ struct nffs_inode ni = { 0 };
+ struct nffs_disk_inode di = { 0 };
+ struct nffs_inode_entry *nie = (struct nffs_inode_entry*)he;
+ int cached_name_len;
+ uint32_t area_offset = 0;
+ uint8_t area_idx = 0;
+ int rc = 0;
+
+ if (he == NULL) {
+ return;
+ }
+ if (!nffs_hash_entry_is_dummy(he)) {
+ nffs_flash_loc_expand(he->nhe_flash_loc,
+ &area_idx, &area_offset);
+ rc = nffs_inode_read_disk(area_idx, area_offset, &di);
+ if (rc) {
+ printf("Entry %p: fail inode read id 0x%jx rc %d\n",
+ he, (uintmax_t)he->nhe_id, rc);
+ }
+ ni.ni_inode_entry = (struct nffs_inode_entry *)he;
+ ni.ni_seq = di.ndi_seq;
+ if (di.ndi_parent_id != NFFS_ID_NONE) {
+ ni.ni_parent = nffs_hash_find_inode(di.ndi_parent_id);
+ } else {
+ ni.ni_parent = NULL;
+ }
+ if (ni.ni_filename_len > NFFS_SHORT_FILENAME_LEN) {
+ cached_name_len = NFFS_SHORT_FILENAME_LEN;
+ } else {
+ cached_name_len = ni.ni_filename_len;
+ }
+ if (cached_name_len != 0) {
+ rc = nffs_flash_read(area_idx, area_offset + sizeof di,
+ ni.ni_filename, cached_name_len);
+ if (rc != 0) {
+ printf("entry %p: fail filename read id 0x%jx rc %d\n",
+ he, (uintmax_t)he->nhe_id, rc);
+ return;
+ }
+ }
+ }
+ if (!verbose) {
+ printf("%s%s id %jx idx/off %jx/%jx seq %ju prnt %jx last %jx "
+ "flags %jx",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_file(he->nhe_id) ? "File" :
+ he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir" :
+ nffs_hash_id_is_dir(he->nhe_id) ? "Dir" : "Inode",
+
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)area_idx,
+ (uintmax_t)area_offset,
+ (uintmax_t)ni.ni_seq,
+ (uintmax_t)di.ndi_parent_id,
+ (uintmax_t)di.ndi_lastblock_id,
+ (uintmax_t)nie->nie_flags);
+ if (ni.ni_inode_entry) {
+ printf(" ref %ju\n", (uintmax_t)ni.ni_inode_entry->nie_refcnt);
+ } else {
+ printf("\n");
+ }
+ return;
+ }
+ printf("%s%s id %jx loc %jx/%jx %jx entry %p\n",
+ nffs_hash_entry_is_dummy(he) ? "Dummy " : "",
+ nffs_hash_id_is_file(he->nhe_id) ? "File:" :
+ he->nhe_id == NFFS_ID_ROOT_DIR ? "**ROOT Dir:" :
+ nffs_hash_id_is_dir(he->nhe_id) ? "Dir:" : "Inode:",
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)area_idx,
+ (uintmax_t)area_offset,
+ (uintmax_t)he->nhe_flash_loc,
+ he);
+ if (ni.ni_inode_entry) {
+ printf(" ram: ent %p seq %ju prnt %p lst %p ref %ju flgs %jx nm %s\n",
+ ni.ni_inode_entry,
+ (uintmax_t)ni.ni_seq,
+ ni.ni_parent,
+ ni.ni_inode_entry->nie_last_block_entry,
+ (uintmax_t)ni.ni_inode_entry->nie_refcnt,
+ (uintmax_t)ni.ni_inode_entry->nie_flags,
+ ni.ni_filename);
+ }
+ if (rc == 0) {
+ printf(" Disk %s: id %jx seq %ju prnt %jx lst %jx flgs %jx\n",
+ nffs_hash_id_is_file(di.ndi_id) ? "File" :
+ nffs_hash_id_is_dir(di.ndi_id) ? "Dir" : "???",
+ (uintmax_t)di.ndi_id,
+ (uintmax_t)di.ndi_seq,
+ (uintmax_t)di.ndi_parent_id,
+ (uintmax_t)di.ndi_lastblock_id,
+ (uintmax_t)di.ndi_flags);
+ }
+}
+
+void
+print_hash_entries(int verbose)
+{
+ int i;
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+
+ printf("\nnffs_hash_entries:\n");
+ for (i = 0; i < NFFS_HASH_SIZE; i++) {
+ he = SLIST_FIRST(nffs_hash + i);
+ while (he != NULL) {
+ next = SLIST_NEXT(he, nhe_next);
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ print_nffs_hash_inode(he, verbose);
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ print_nffs_hash_block(he, verbose);
+ } else {
+ printf("UNKNOWN type hash entry %d: id 0x%jx loc 0x%jx\n",
+ i,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc);
+ }
+ he = next;
+ }
+ }
+}
+
+void
+print_nffs_hashlist(int verbose)
+{
+ struct nffs_hash_entry *he;
+ struct nffs_hash_entry *next;
+ int i;
+
+ NFFS_HASH_FOREACH(he, i, next) {
+ if (nffs_hash_id_is_inode(he->nhe_id)) {
+ print_nffs_hash_inode(he, verbose);
+ } else if (nffs_hash_id_is_block(he->nhe_id)) {
+ print_nffs_hash_block(he, verbose);
+ } else {
+ printf("UNKNOWN type hash entry %d: id 0x%jx loc 0x%jx\n",
+ i,
+ (uintmax_t)he->nhe_id,
+ (uintmax_t)he->nhe_flash_loc);
+ }
+ }
+}
+
+void
+printfs()
+{
+ if (nffs_misc_ready()) {
+ printf("NFFS directory:\n");
+ process_inode_entry(nffs_root_dir, print_verbose);
+
+ printf("\nNFFS hash list:\n");
+ print_nffs_hashlist(print_verbose);
+ }
+ printf("\nNFFS flash areas:\n");
+ print_nffs_flash_areas(print_verbose);
+}
diff --git a/test/src/nffs_test_priv.h b/test/src/nffs_test_priv.h
new file mode 100644
index 0000000..e685937
--- /dev/null
+++ b/test/src/nffs_test_priv.h
@@ -0,0 +1,49 @@
+/*
+ * 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 H_NFFS_TEST_PRIV_
+#define H_NFFS_TEST_PRIV_
+
+#ifdef __cplusplus
+#extern "C" {
+#endif
+
+struct nffs_test_block_desc {
+ const char *data;
+ int data_len;
+};
+
+struct nffs_test_file_desc {
+ const char *filename;
+ int is_dir;
+ const char *contents;
+ int contents_len;
+ struct nffs_test_file_desc *children;
+};
+
+int nffs_test(void);
+
+extern const struct nffs_test_file_desc *nffs_test_system_01;
+extern const struct nffs_test_file_desc *nffs_test_system_01_rm_1014_mk10;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/test/src/nffs_test_system_01.c b/test/src/nffs_test_system_01.c
new file mode 100644
index 0000000..f25e745
--- /dev/null
+++ b/test/src/nffs_test_system_01.c
@@ -0,0 +1,6537 @@
+/*
+ * 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.
+ */
+
+
+/** Generated by makefs.rb */
+
+#include <stddef.h>
+#include "nffs_test_priv.h"
+
+const struct nffs_test_file_desc *nffs_test_system_01 =
+ (struct nffs_test_file_desc[]) {
+{
+.filename = "",
+.is_dir = 1,
+.children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl1dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+{ .filename = NULL, } }
+},
+};
+
+const struct nffs_test_file_desc *nffs_test_system_01_rm_1014_mk10 =
+ (struct nffs_test_file_desc[]) {
+{
+.filename = "",
+.is_dir = 1,
+.children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl1dir-0000",
+ .is_dir = 1,
+ },
+ {
+ .filename = "lvl1dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl1dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl2dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl2dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl3dir-0000",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0001",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0002",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0003",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ {
+ .filename = "lvl3dir-0004",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ {
+ .filename = "lvl4file-0000",
+ .contents = "0",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0001",
+ .contents = "1",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0002",
+ .contents = "2",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0003",
+ .contents = "3",
+ .contents_len = 1,
+ },
+ {
+ .filename = "lvl4file-0004",
+ .contents = "4",
+ .contents_len = 1,
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+ { .filename = NULL, } }
+ },
+{ .filename = NULL, } }
+},
+};
+
diff --git a/test/src/nffs_test_utils.c b/test/src/nffs_test_utils.c
new file mode 100644
index 0000000..fea07b8
--- /dev/null
+++ b/test/src/nffs_test_utils.c
@@ -0,0 +1,748 @@
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "hal/hal_flash.h"
+#include "testutil/testutil.h"
+#include "fs/fs.h"
+#include "nffs/nffs.h"
+#include "nffs_test.h"
+#include "nffs_test_priv.h"
+#include "nffs_priv.h"
+
+#if 0
+#ifdef ARCH_sim
+const struct nffs_area_desc nffs_sim_area_descs[] = {
+ { 0x00000000, 16 * 1024 },
+ { 0x00004000, 16 * 1024 },
+ { 0x00008000, 16 * 1024 },
+ { 0x0000c000, 16 * 1024 },
+ { 0x00010000, 64 * 1024 },
+ { 0x00020000, 128 * 1024 },
+ { 0x00040000, 128 * 1024 },
+ { 0x00060000, 128 * 1024 },
+ { 0x00080000, 128 * 1024 },
+ { 0x000a0000, 128 * 1024 },
+ { 0x000c0000, 128 * 1024 },
+ { 0x000e0000, 128 * 1024 },
+ { 0, 0 },
+};
+#endif
+#endif
+
+void
+nffs_test_util_assert_ent_name(struct fs_dirent *dirent,
+ const char *expected_name)
+{
+ /* It should not be necessary to initialize this array, but the libgcc
+ * version of strcmp triggers a "Conditional jump or move depends on
+ * uninitialised value(s)" valgrind warning.
+ */
+ char name[NFFS_FILENAME_MAX_LEN + 1] = { 0 };
+ uint8_t name_len;
+ int rc;
+
+ rc = fs_dirent_name(dirent, sizeof name, name, &name_len);
+ TEST_ASSERT(rc == 0);
+ if (rc == 0) {
+ TEST_ASSERT(strcmp(name, expected_name) == 0);
+ }
+}
+
+void
+nffs_test_util_assert_file_len(struct fs_file *file, uint32_t expected)
+{
+ uint32_t len;
+ int rc;
+
+ rc = fs_filelen(file, &len);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(len == expected);
+}
+
+void
+nffs_test_util_assert_cache_is_sane(const char *filename)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_cache_block *cache_block;
+ struct fs_file *fs_file;
+ struct nffs_file *file;
+ uint32_t cache_start;
+ uint32_t cache_end;
+ uint32_t block_end;
+ int rc;
+
+ rc = fs_open(filename, FS_ACCESS_READ, &fs_file);
+ TEST_ASSERT(rc == 0);
+
+ file = (struct nffs_file *)fs_file;
+ rc = nffs_cache_inode_ensure(&cache_inode, file->nf_inode_entry);
+ TEST_ASSERT(rc == 0);
+
+ nffs_cache_inode_range(cache_inode, &cache_start, &cache_end);
+
+ if (TAILQ_EMPTY(&cache_inode->nci_block_list)) {
+ TEST_ASSERT(cache_start == 0 && cache_end == 0);
+ } else {
+ block_end = 0; /* Pacify gcc. */
+ TAILQ_FOREACH(cache_block, &cache_inode->nci_block_list, ncb_link) {
+ if (cache_block == TAILQ_FIRST(&cache_inode->nci_block_list)) {
+ TEST_ASSERT(cache_block->ncb_file_offset == cache_start);
+ } else {
+ /* Ensure no gap between this block and its predecessor. */
+ TEST_ASSERT(cache_block->ncb_file_offset == block_end);
+ }
+
+ block_end = cache_block->ncb_file_offset +
+ cache_block->ncb_block.nb_data_len;
+ if (cache_block == TAILQ_LAST(&cache_inode->nci_block_list,
+ nffs_cache_block_list)) {
+
+ TEST_ASSERT(block_end == cache_end);
+ }
+ }
+ }
+
+ rc = fs_close(fs_file);
+ TEST_ASSERT(rc == 0);
+}
+
+void
+nffs_test_util_assert_contents(const char *filename, const char *contents,
+ int contents_len)
+{
+ struct fs_file *file;
+ uint32_t bytes_read;
+ void *buf;
+ int rc;
+
+ rc = fs_open(filename, FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == 0);
+
+ buf = malloc(contents_len + 1);
+ TEST_ASSERT(buf != NULL);
+
+ rc = fs_read(file, contents_len + 1, buf, &bytes_read);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(bytes_read == contents_len);
+ TEST_ASSERT(memcmp(buf, contents, contents_len) == 0);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ free(buf);
+
+ nffs_test_util_assert_cache_is_sane(filename);
+}
+
+int
+nffs_test_util_block_count(const char *filename)
+{
+ struct nffs_hash_entry *entry;
+ struct nffs_block block;
+ struct nffs_file *file;
+ struct fs_file *fs_file;
+ int count;
+ int rc;
+
+ rc = fs_open(filename, FS_ACCESS_READ, &fs_file);
+ TEST_ASSERT(rc == 0);
+
+ file = (struct nffs_file *)fs_file;
+ count = 0;
+ entry = file->nf_inode_entry->nie_last_block_entry;
+ while (entry != NULL) {
+ count++;
+ rc = nffs_block_from_hash_entry(&block, entry);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(block.nb_prev != entry);
+ entry = block.nb_prev;
+ }
+
+ rc = fs_close(fs_file);
+ TEST_ASSERT(rc == 0);
+
+ return count;
+}
+
+void
+nffs_test_util_assert_block_count(const char *filename, int expected_count)
+{
+ int actual_count;
+
+ actual_count = nffs_test_util_block_count(filename);
+ TEST_ASSERT(actual_count == expected_count);
+}
+
+void
+nffs_test_util_assert_cache_range(const char *filename,
+ uint32_t expected_cache_start,
+ uint32_t expected_cache_end)
+{
+ struct nffs_cache_inode *cache_inode;
+ struct nffs_file *file;
+ struct fs_file *fs_file;
+ uint32_t cache_start;
+ uint32_t cache_end;
+ int rc;
+
+ rc = fs_open(filename, FS_ACCESS_READ, &fs_file);
+ TEST_ASSERT(rc == 0);
+
+ file = (struct nffs_file *)fs_file;
+ rc = nffs_cache_inode_ensure(&cache_inode, file->nf_inode_entry);
+ TEST_ASSERT(rc == 0);
+
+ nffs_cache_inode_range(cache_inode, &cache_start, &cache_end);
+ TEST_ASSERT(cache_start == expected_cache_start);
+ TEST_ASSERT(cache_end == expected_cache_end);
+
+ rc = fs_close(fs_file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_cache_is_sane(filename);
+}
+
+void
+nffs_test_util_create_file_blocks(const char *filename,
+ const struct nffs_test_block_desc *blocks,
+ int num_blocks)
+{
+ struct fs_file *file;
+ uint32_t total_len;
+ uint32_t offset;
+ char *buf;
+ int num_writes;
+ int rc;
+ int i;
+
+ rc = fs_open(filename, FS_ACCESS_WRITE | FS_ACCESS_TRUNCATE, &file);
+ TEST_ASSERT(rc == 0);
+
+ total_len = 0;
+ if (num_blocks <= 0) {
+ num_writes = 1;
+ } else {
+ num_writes = num_blocks;
+ }
+ for (i = 0; i < num_writes; i++) {
+ rc = fs_write(file, blocks[i].data, blocks[i].data_len);
+ TEST_ASSERT(rc == 0);
+
+ total_len += blocks[i].data_len;
+ }
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ buf = malloc(total_len);
+ TEST_ASSERT(buf != NULL);
+
+ offset = 0;
+ for (i = 0; i < num_writes; i++) {
+ memcpy(buf + offset, blocks[i].data, blocks[i].data_len);
+ offset += blocks[i].data_len;
+ }
+ TEST_ASSERT(offset == total_len);
+
+ nffs_test_util_assert_contents(filename, buf, total_len);
+ if (num_blocks > 0) {
+ nffs_test_util_assert_block_count(filename, num_blocks);
+ }
+
+ free(buf);
+}
+
+void
+nffs_test_util_create_file(const char *filename, const char *contents,
+ int contents_len)
+{
+ struct nffs_test_block_desc block;
+
+ block.data = contents;
+ block.data_len = contents_len;
+
+ nffs_test_util_create_file_blocks(filename, &block, 0);
+}
+
+void
+nffs_test_util_append_file(const char *filename, const char *contents,
+ int contents_len)
+{
+ struct fs_file *file;
+ int rc;
+
+ rc = fs_open(filename, FS_ACCESS_WRITE | FS_ACCESS_APPEND, &file);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_write(file, contents, contents_len);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+}
+
+void
+nffs_test_copy_area(const struct nffs_area_desc *from,
+ const struct nffs_area_desc *to)
+{
+ void *buf;
+ int rc;
+
+ TEST_ASSERT(from->nad_length == to->nad_length);
+
+ buf = malloc(from->nad_length);
+ TEST_ASSERT(buf != NULL);
+
+ rc = hal_flash_read(from->nad_flash_id, from->nad_offset, buf,
+ from->nad_length);
+ TEST_ASSERT(rc == 0);
+
+ rc = hal_flash_erase(from->nad_flash_id, to->nad_offset, to->nad_length);
+ TEST_ASSERT(rc == 0);
+
+ rc = hal_flash_write(to->nad_flash_id, to->nad_offset, buf, to->nad_length);
+ TEST_ASSERT(rc == 0);
+
+ free(buf);
+}
+
+void
+nffs_test_util_create_subtree(const char *parent_path,
+ const struct nffs_test_file_desc *elem)
+{
+ char *path;
+ int rc;
+ int i;
+
+ if (parent_path == NULL) {
+ path = malloc(1);
+ TEST_ASSERT(path != NULL);
+ path[0] = '\0';
+ } else {
+ path = malloc(strlen(parent_path) + 1 + strlen(elem->filename) + 1);
+ TEST_ASSERT(path != NULL);
+
+ sprintf(path, "%s/%s", parent_path, elem->filename);
+ }
+
+ if (elem->is_dir) {
+ if (parent_path != NULL) {
+ rc = fs_mkdir(path);
+ TEST_ASSERT(rc == 0);
+ }
+
+ if (elem->children != NULL) {
+ for (i = 0; elem->children[i].filename != NULL; i++) {
+ nffs_test_util_create_subtree(path, elem->children + i);
+ }
+ }
+ } else {
+ nffs_test_util_create_file(path, elem->contents, elem->contents_len);
+ }
+
+ free(path);
+}
+
+void
+nffs_test_util_create_tree(const struct nffs_test_file_desc *root_dir)
+{
+ nffs_test_util_create_subtree(NULL, root_dir);
+}
+
+#define NFFS_TEST_TOUCHED_ARR_SZ (16 * 64)
+/*#define NFFS_TEST_TOUCHED_ARR_SZ (16 * 1024)*/
+struct nffs_hash_entry
+ *nffs_test_touched_entries[NFFS_TEST_TOUCHED_ARR_SZ];
+int nffs_test_num_touched_entries;
+
+/*
+ * Recursively descend directory structure
+ */
+void
+nffs_test_assert_file(const struct nffs_test_file_desc *file,
+ struct nffs_inode_entry *inode_entry,
+ const char *path)
+{
+ const struct nffs_test_file_desc *child_file;
+ struct nffs_inode inode;
+ struct nffs_inode_entry *child_inode_entry;
+ char *child_path;
+ int child_filename_len;
+ int path_len;
+ int rc;
+
+ /*
+ * track of hash entries that have been examined
+ */
+ TEST_ASSERT(nffs_test_num_touched_entries < NFFS_TEST_TOUCHED_ARR_SZ);
+ nffs_test_touched_entries[nffs_test_num_touched_entries] =
+ &inode_entry->nie_hash_entry;
+ nffs_test_num_touched_entries++;
+
+ path_len = strlen(path);
+
+ rc = nffs_inode_from_entry(&inode, inode_entry);
+ TEST_ASSERT(rc == 0);
+
+ /*
+ * recursively examine each child of directory
+ */
+ if (nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) {
+ for (child_file = file->children;
+ child_file != NULL && child_file->filename != NULL;
+ child_file++) {
+
+ /*
+ * Construct full pathname for file
+ * Not null terminated
+ */
+ child_filename_len = strlen(child_file->filename);
+ child_path = malloc(path_len + 1 + child_filename_len + 1);
+ TEST_ASSERT(child_path != NULL);
+ memcpy(child_path, path, path_len);
+ child_path[path_len] = '/';
+ memcpy(child_path + path_len + 1, child_file->filename,
+ child_filename_len);
+ child_path[path_len + 1 + child_filename_len] = '\0';
+
+ /*
+ * Verify child inode can be found using full pathname
+ */
+ rc = nffs_path_find_inode_entry(child_path, &child_inode_entry);
+ if (rc != 0) {
+ TEST_ASSERT(rc == 0);
+ }
+
+ nffs_test_assert_file(child_file, child_inode_entry, child_path);
+
+ free(child_path);
+ }
+ } else {
+ nffs_test_util_assert_contents(path, file->contents,
+ file->contents_len);
+ }
+}
+
+void
+nffs_test_assert_branch_touched(struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_inode_entry *child;
+ int i;
+
+ if (inode_entry == nffs_lost_found_dir) {
+ return;
+ }
+
+ for (i = 0; i < nffs_test_num_touched_entries; i++) {
+ if (nffs_test_touched_entries[i] == &inode_entry->nie_hash_entry) {
+ break;
+ }
+ }
+ TEST_ASSERT(i < nffs_test_num_touched_entries);
+ nffs_test_touched_entries[i] = NULL;
+
+ if (nffs_hash_id_is_dir(inode_entry->nie_hash_entry.nhe_id)) {
+ SLIST_FOREACH(child, &inode_entry->nie_child_list, nie_sibling_next) {
+ nffs_test_assert_branch_touched(child);
+ }
+ }
+}
+
+void
+nffs_test_assert_child_inode_present(struct nffs_inode_entry *child)
+{
+ const struct nffs_inode_entry *inode_entry;
+ const struct nffs_inode_entry *parent;
+ struct nffs_inode inode;
+ int rc;
+
+ /*
+ * Sucessfully read inode data from flash
+ */
+ rc = nffs_inode_from_entry(&inode, child);
+ TEST_ASSERT(rc == 0);
+
+ /*
+ * Validate parent
+ */
+ parent = inode.ni_parent;
+ TEST_ASSERT(parent != NULL);
+ TEST_ASSERT(nffs_hash_id_is_dir(parent->nie_hash_entry.nhe_id));
+
+ /*
+ * Make sure inode is in parents child list
+ */
+ SLIST_FOREACH(inode_entry, &parent->nie_child_list, nie_sibling_next) {
+ if (inode_entry == child) {
+ return;
+ }
+ }
+
+ TEST_ASSERT(0);
+}
+
+void
+nffs_test_assert_block_present(struct nffs_hash_entry *block_entry)
+{
+ const struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *cur;
+ struct nffs_block block;
+ int rc;
+
+ /*
+ * Successfully read block data from flash
+ */
+ rc = nffs_block_from_hash_entry(&block, block_entry);
+ TEST_ASSERT(rc == 0);
+
+ /*
+ * Validate owning inode
+ */
+ inode_entry = block.nb_inode_entry;
+ TEST_ASSERT(inode_entry != NULL);
+ TEST_ASSERT(nffs_hash_id_is_file(inode_entry->nie_hash_entry.nhe_id));
+
+ /*
+ * Validate that block is in owning inode's block chain
+ */
+ cur = inode_entry->nie_last_block_entry;
+ while (cur != NULL) {
+ if (cur == block_entry) {
+ return;
+ }
+
+ rc = nffs_block_from_hash_entry(&block, cur);
+ TEST_ASSERT(rc == 0);
+ cur = block.nb_prev;
+ }
+
+ TEST_ASSERT(0);
+}
+
+/*
+ * Recursively verify that the children of each directory are sorted
+ * on the directory children linked list by filename length
+ */
+void
+nffs_test_assert_children_sorted(struct nffs_inode_entry *inode_entry)
+{
+ struct nffs_inode_entry *child_entry;
+ struct nffs_inode_entry *prev_entry;
+ struct nffs_inode child_inode;
+ struct nffs_inode prev_inode;
+ int cmp;
+ int rc;
+
+ prev_entry = NULL;
+ SLIST_FOREACH(child_entry, &inode_entry->nie_child_list,
+ nie_sibling_next) {
+ rc = nffs_inode_from_entry(&child_inode, child_entry);
+ TEST_ASSERT(rc == 0);
+
+ if (prev_entry != NULL) {
+ rc = nffs_inode_from_entry(&prev_inode, prev_entry);
+ TEST_ASSERT(rc == 0);
+
+ rc = nffs_inode_filename_cmp_flash(&prev_inode, &child_inode,
+ &cmp);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(cmp < 0);
+ }
+
+ if (nffs_hash_id_is_dir(child_entry->nie_hash_entry.nhe_id)) {
+ nffs_test_assert_children_sorted(child_entry);
+ }
+
+ prev_entry = child_entry;
+ }
+}
+
+void
+nffs_test_assert_system_once(const struct nffs_test_file_desc *root_dir)
+{
+ struct nffs_inode_entry *inode_entry;
+ struct nffs_hash_entry *entry;
+ struct nffs_hash_entry *next;
+ int i;
+
+ nffs_test_num_touched_entries = 0;
+ nffs_test_assert_file(root_dir, nffs_root_dir, "");
+ nffs_test_assert_branch_touched(nffs_root_dir);
+
+ /* Ensure no orphaned inodes or blocks. */
+ NFFS_HASH_FOREACH(entry, i, next) {
+ TEST_ASSERT(entry->nhe_flash_loc != NFFS_FLASH_LOC_NONE);
+ if (nffs_hash_id_is_inode(entry->nhe_id)) {
+ inode_entry = (void *)entry;
+ TEST_ASSERT(inode_entry->nie_refcnt == 1);
+ if (entry->nhe_id == NFFS_ID_ROOT_DIR) {
+ TEST_ASSERT(inode_entry == nffs_root_dir);
+ } else {
+ nffs_test_assert_child_inode_present(inode_entry);
+ }
+ } else {
+ nffs_test_assert_block_present(entry);
+ }
+ }
+
+ /* Ensure proper sorting. */
+ nffs_test_assert_children_sorted(nffs_root_dir);
+}
+
+void
+nffs_test_assert_system(const struct nffs_test_file_desc *root_dir,
+ const struct nffs_area_desc *area_descs)
+{
+ int rc;
+
+ /* Ensure files are as specified, and that there are no other files or
+ * orphaned inodes / blocks.
+ */
+ nffs_test_assert_system_once(root_dir);
+
+ /* Force a garbage collection cycle. */
+ rc = nffs_gc(NULL);
+ TEST_ASSERT(rc == 0);
+
+ /* Ensure file system is still as expected. */
+ nffs_test_assert_system_once(root_dir);
+
+ /* Clear cached data and restore from flash (i.e, simulate a reboot). */
+ rc = nffs_misc_reset();
+ TEST_ASSERT(rc == 0);
+ rc = nffs_detect(area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /* Ensure file system is still as expected. */
+ nffs_test_assert_system_once(root_dir);
+}
+
+void
+nffs_test_assert_area_seqs(int seq1, int count1, int seq2, int count2)
+{
+ struct nffs_disk_area disk_area;
+ int cur1;
+ int cur2;
+ int rc;
+ int i;
+
+ cur1 = 0;
+ cur2 = 0;
+
+ for (i = 0; i < nffs_num_areas; i++) {
+ rc = nffs_flash_read(i, 0, &disk_area, sizeof disk_area);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(nffs_area_magic_is_set(&disk_area));
+ TEST_ASSERT(disk_area.nda_gc_seq == nffs_areas[i].na_gc_seq);
+ if (i == nffs_scratch_area_idx) {
+ TEST_ASSERT(disk_area.nda_id == NFFS_AREA_ID_NONE);
+ }
+
+ if (nffs_areas[i].na_gc_seq == seq1) {
+ cur1++;
+ } else if (nffs_areas[i].na_gc_seq == seq2) {
+ cur2++;
+ } else {
+ TEST_ASSERT(0);
+ }
+ }
+
+ TEST_ASSERT(cur1 == count1 && cur2 == count2);
+}
+
+#if 0
+void
+nffs_test_mkdir(void)
+{
+ struct fs_file *file;
+ int rc;
+
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c/d");
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_mkdir("asdf");
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ rc = fs_mkdir("/a");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c/d");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/a/b/c/d/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "a",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "b",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "c",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "d",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = NULL,
+ .contents_len = 0,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
+#endif
diff --git a/test/src/nffs_test_utils.h b/test/src/nffs_test_utils.h
new file mode 100644
index 0000000..c211a2d
--- /dev/null
+++ b/test/src/nffs_test_utils.h
@@ -0,0 +1,92 @@
+/*
+ * 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 H_NFFS_TEST_UTILS_
+#define H_NFFS_TEST_UTILS_
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "hal/hal_flash.h"
+#include "testutil/testutil.h"
+#include "fs/fs.h"
+#include "nffs/nffs.h"
+#include "nffs_test.h"
+#include "nffs_test_priv.h"
+#include "nffs_priv.h"
+
+#ifdef __cplusplus
+#extern "C" {
+#endif
+
+extern struct nffs_hash_entry *nffs_test_touched_entries;
+int nffs_test_num_touched_entries;
+
+extern int flash_native_memset(uint32_t offset, uint8_t c, uint32_t len);
+
+void nffs_test_util_assert_ent_name(struct fs_dirent *dirent,
+ const char *expected_name);
+void nffs_test_util_assert_file_len(struct fs_file *file, uint32_t expected);
+void nffs_test_util_assert_cache_is_sane(const char *filename);
+void nffs_test_util_assert_contents(const char *filename,
+ const char *contents, int contents_len);
+int nffs_test_util_block_count(const char *filename);
+void nffs_test_util_assert_block_count(const char *filename,
+ int expected_count);
+void nffs_test_util_assert_cache_range(const char *filename,
+ uint32_t expected_cache_start,
+ uint32_t expected_cache_end);
+void nffs_test_util_create_file_blocks(const char *filename,
+ const struct nffs_test_block_desc *blocks,
+ int num_blocks);
+void nffs_test_util_create_file(const char *filename, const char *contents,
+ int contents_len);
+void nffs_test_util_append_file(const char *filename, const char *contents,
+ int contents_len);
+void nffs_test_copy_area(const struct nffs_area_desc *from,
+ const struct nffs_area_desc *to);
+void nffs_test_util_create_subtree(const char *parent_path,
+ const struct nffs_test_file_desc *elem);
+void nffs_test_util_create_tree(const struct nffs_test_file_desc *root_dir);
+
+/*
+ * Recursively descend directory structure
+ */
+void nffs_test_assert_file(const struct nffs_test_file_desc *file,
+ struct nffs_inode_entry *inode_entry,
+ const char *path);
+void nffs_test_assert_branch_touched(struct nffs_inode_entry *inode_entry);
+void nffs_test_assert_child_inode_present(struct nffs_inode_entry *child);
+void nffs_test_assert_block_present(struct nffs_hash_entry *block_entry);
+/*
+ * Recursively verify that the children of each directory are sorted
+ * on the directory children linked list by filename length
+ */
+void nffs_test_assert_children_sorted(struct nffs_inode_entry *inode_entry);
+void nffs_test_assert_system_once(const struct nffs_test_file_desc *root_dir);
+void nffs_test_assert_system(const struct nffs_test_file_desc *root_dir,
+ const struct nffs_area_desc *area_descs);
+void nffs_test_assert_area_seqs(int seq1, int count1, int seq2, int count2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H_NFFS_TEST_UTILS_ */
diff --git a/test/src/testcases/append_test.c b/test/src/testcases/append_test.c
new file mode 100644
index 0000000..e82b6b9
--- /dev/null
+++ b/test/src/testcases/append_test.c
@@ -0,0 +1,164 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+void process_inode_entry(struct nffs_inode_entry *inode_entry, int indent);
+
+TEST_CASE(nffs_test_append)
+{
+ struct fs_file *file;
+ uint32_t len;
+ char c;
+ int rc;
+ int i;
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE | FS_ACCESS_APPEND, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 0);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "abcdefgh", 8);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 8);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "abcdefgh", 8);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE | FS_ACCESS_APPEND, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 8);
+
+ /* File position should always be at the end of a file after an append.
+ * Seek to the middle prior to writing to test this.
+ */
+ rc = fs_seek(file, 2);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 2);
+
+ rc = fs_write(file, "ijklmnop", 8);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 16);
+ rc = fs_write(file, "qrstuvwx", 8);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 24);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt",
+ "abcdefghijklmnopqrstuvwx", 24);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT_FATAL(rc == 0);
+ rc = fs_open("/mydir/gaga.txt", FS_ACCESS_WRITE | FS_ACCESS_APPEND, &file);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ /*** Repeated appends to a large file. */
+ for (i = 0; i < 1000; i++) {
+ rc = fs_filelen(file, &len);
+ TEST_ASSERT_FATAL(rc == 0);
+ TEST_ASSERT(len == i);
+
+ c = '0' + i % 10;
+ rc = fs_write(file, &c, 1);
+ TEST_ASSERT_FATAL(rc == 0);
+ }
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/mydir/gaga.txt",
+ "01234567890123456789012345678901234567890123456789" /* 1 */
+ "01234567890123456789012345678901234567890123456789" /* 2 */
+ "01234567890123456789012345678901234567890123456789" /* 3 */
+ "01234567890123456789012345678901234567890123456789" /* 4 */
+ "01234567890123456789012345678901234567890123456789" /* 5 */
+ "01234567890123456789012345678901234567890123456789" /* 6 */
+ "01234567890123456789012345678901234567890123456789" /* 7 */
+ "01234567890123456789012345678901234567890123456789" /* 8 */
+ "01234567890123456789012345678901234567890123456789" /* 9 */
+ "01234567890123456789012345678901234567890123456789" /* 10 */
+ "01234567890123456789012345678901234567890123456789" /* 11 */
+ "01234567890123456789012345678901234567890123456789" /* 12 */
+ "01234567890123456789012345678901234567890123456789" /* 13 */
+ "01234567890123456789012345678901234567890123456789" /* 14 */
+ "01234567890123456789012345678901234567890123456789" /* 15 */
+ "01234567890123456789012345678901234567890123456789" /* 16 */
+ "01234567890123456789012345678901234567890123456789" /* 17 */
+ "01234567890123456789012345678901234567890123456789" /* 18 */
+ "01234567890123456789012345678901234567890123456789" /* 19 */
+ "01234567890123456789012345678901234567890123456789" /* 20 */
+ ,
+ 1000);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "abcdefghijklmnopqrstuvwx",
+ .contents_len = 24,
+ }, {
+ .filename = "mydir",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "gaga.txt",
+ .contents =
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ "01234567890123456789012345678901234567890123456789"
+ ,
+ .contents_len = 1000,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/cache_large_file_test.c b/test/src/testcases/cache_large_file_test.c
new file mode 100644
index 0000000..44e1232
--- /dev/null
+++ b/test/src/testcases/cache_large_file_test.c
@@ -0,0 +1,89 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_cache_large_file)
+{
+ static char data[NFFS_BLOCK_MAX_DATA_SZ_MAX * 5];
+ struct fs_file *file;
+ uint8_t b;
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/myfile.txt", data, sizeof data);
+ nffs_cache_clear();
+
+ /* Opening a file should not cause any blocks to get cached. */
+ rc = fs_open("/myfile.txt", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt", 0, 0);
+
+ /* Cache first block. */
+ rc = fs_seek(file, nffs_block_max_data_sz * 0);
+ TEST_ASSERT(rc == 0);
+ rc = fs_read(file, 1, &b, NULL);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt",
+ nffs_block_max_data_sz * 0,
+ nffs_block_max_data_sz * 1);
+
+ /* Cache second block. */
+ rc = fs_seek(file, nffs_block_max_data_sz * 1);
+ TEST_ASSERT(rc == 0);
+ rc = fs_read(file, 1, &b, NULL);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt",
+ nffs_block_max_data_sz * 0,
+ nffs_block_max_data_sz * 2);
+
+
+ /* Cache fourth block; prior cache should get erased. */
+ rc = fs_seek(file, nffs_block_max_data_sz * 3);
+ TEST_ASSERT(rc == 0);
+ rc = fs_read(file, 1, &b, NULL);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt",
+ nffs_block_max_data_sz * 3,
+ nffs_block_max_data_sz * 4);
+
+ /* Cache second and third blocks. */
+ rc = fs_seek(file, nffs_block_max_data_sz * 1);
+ TEST_ASSERT(rc == 0);
+ rc = fs_read(file, 1, &b, NULL);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt",
+ nffs_block_max_data_sz * 1,
+ nffs_block_max_data_sz * 4);
+
+ /* Cache fifth block. */
+ rc = fs_seek(file, nffs_block_max_data_sz * 4);
+ TEST_ASSERT(rc == 0);
+ rc = fs_read(file, 1, &b, NULL);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_cache_range("/myfile.txt",
+ nffs_block_max_data_sz * 1,
+ nffs_block_max_data_sz * 5);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+}
diff --git a/test/src/testcases/corrupt_block_test.c b/test/src/testcases/corrupt_block_test.c
new file mode 100644
index 0000000..1f4bc3b
--- /dev/null
+++ b/test/src/testcases/corrupt_block_test.c
@@ -0,0 +1,121 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_corrupt_block)
+{
+ struct nffs_block block;
+ struct fs_file *fs_file;
+ struct nffs_file *file;
+ uint32_t flash_offset;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ uint8_t off; /* offset to corrupt */
+ int rc;
+ struct nffs_disk_block ndb;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/mydir/a", "aaaa", 4);
+ nffs_test_util_create_file("/mydir/b", "bbbb", 4);
+ nffs_test_util_create_file("/mydir/c", "cccc", 4);
+
+ /* Add a second block to the 'b' file. */
+ nffs_test_util_append_file("/mydir/b", "1234", 4);
+
+ /* Corrupt the 'b' file; overwrite the second block's magic number. */
+ rc = fs_open("/mydir/b", FS_ACCESS_READ, &fs_file);
+ TEST_ASSERT(rc == 0);
+ file = (struct nffs_file *)fs_file;
+
+ rc = nffs_block_from_hash_entry(&block,
+ file->nf_inode_entry->nie_last_block_entry);
+ TEST_ASSERT(rc == 0);
+
+ nffs_flash_loc_expand(block.nb_hash_entry->nhe_flash_loc, &area_idx,
+ &area_offset);
+ flash_offset = nffs_areas[area_idx].na_offset + area_offset;
+
+ /*
+ * Overwriting the reserved16 field should invalidate the CRC
+ */
+ off = (char*)&ndb.reserved16 - (char*)&ndb;
+ rc = flash_native_memset(flash_offset + off, 0x43, 1);
+
+ TEST_ASSERT(rc == 0);
+
+ /* Write a fourth file. This file should get restored even though the
+ * previous object has an invalid magic number.
+ */
+ nffs_test_util_create_file("/mydir/d", "dddd", 4);
+
+ rc = nffs_misc_reset();
+ TEST_ASSERT(rc == 0);
+ rc = nffs_detect(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /* The entire second block should be removed; the file should only contain
+ * the first block.
+ */
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "mydir",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "a",
+ .contents = "aaaa",
+ .contents_len = 4,
+#if 0
+ /*
+ * In the newer implementation without the find_file_ends
+ * corrupted inodes are deleted rather than retained with
+ * partial contents
+ */
+ }, {
+ .filename = "b",
+ .contents = "bbbb",
+ .contents_len = 4,
+#endif
+ }, {
+ .filename = "c",
+ .contents = "cccc",
+ .contents_len = 4,
+ }, {
+ .filename = "d",
+ .contents = "dddd",
+ .contents_len = 4,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/corrupt_scratch_test.c b/test/src/testcases/corrupt_scratch_test.c
new file mode 100644
index 0000000..9f5d6b5
--- /dev/null
+++ b/test/src/testcases/corrupt_scratch_test.c
@@ -0,0 +1,83 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_corrupt_scratch)
+{
+ int non_scratch_id;
+ int scratch_id;
+ int rc;
+
+ static const struct nffs_area_desc area_descs_two[] = {
+ { 0x00020000, 128 * 1024 },
+ { 0x00040000, 128 * 1024 },
+ { 0, 0 },
+ };
+ nffs_current_area_descs = (struct nffs_area_desc*)area_descs_two;
+
+ /*** Setup. */
+ rc = nffs_format(area_descs_two);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/myfile.txt", "contents", 8);
+
+ /* Copy the current contents of the non-scratch area to the scratch area.
+ * This will make the scratch area look like it only partially
+ * participated in a garbage collection cycle.
+ */
+ scratch_id = nffs_scratch_area_idx;
+ non_scratch_id = scratch_id ^ 1;
+ nffs_test_copy_area(area_descs_two + non_scratch_id,
+ area_descs_two + nffs_scratch_area_idx);
+
+ /* Add some more data to the non-scratch area. */
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+
+ /* Ensure the file system is successfully detected and valid, despite
+ * corruption.
+ */
+
+ rc = nffs_misc_reset();
+ TEST_ASSERT(rc == 0);
+
+ rc = nffs_detect(area_descs_two);
+ TEST_ASSERT(rc == 0);
+
+ TEST_ASSERT(nffs_scratch_area_idx == scratch_id);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "mydir",
+ .is_dir = 1,
+ }, {
+ .filename = "myfile.txt",
+ .contents = "contents",
+ .contents_len = 8,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, area_descs_two);
+}
diff --git a/test/src/testcases/gc_on_oom_test.c b/test/src/testcases/gc_on_oom_test.c
new file mode 100644
index 0000000..4d1b733
--- /dev/null
+++ b/test/src/testcases/gc_on_oom_test.c
@@ -0,0 +1,88 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_gc_on_oom)
+{
+ int rc;
+
+ /*** Setup. */
+ /* Ensure all areas are the same size. */
+ static const struct nffs_area_desc area_descs_two[] = {
+ { 0x00000000, 16 * 1024 },
+ { 0x00004000, 16 * 1024 },
+ { 0x00008000, 16 * 1024 },
+ { 0, 0 },
+ };
+
+ rc = nffs_format(area_descs_two);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ /* Leak block entries until only four are left. */
+ /* XXX: This is ridiculous. Need to fix nffs configuration so that the
+ * caller passes a config object rather than writing to a global variable.
+ */
+ while (nffs_block_entry_pool.mp_num_free != 4) {
+ nffs_block_entry_alloc();
+ }
+
+ /*** Write 4 data blocks. */
+ struct nffs_test_block_desc blocks[4] = { {
+ .data = "1",
+ .data_len = 1,
+ }, {
+ .data = "2",
+ .data_len = 1,
+ }, {
+ .data = "3",
+ .data_len = 1,
+ }, {
+ .data = "4",
+ .data_len = 1,
+ } };
+
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 4);
+
+ TEST_ASSERT_FATAL(nffs_block_entry_pool.mp_num_free == 0);
+
+ /* Attempt another one-byte write. This should trigger a garbage
+ * collection cycle, resulting in the four blocks being collated. The
+ * fifth write consumes an additional block, resulting in 2 out of 4 blocks
+ * in use.
+ */
+ nffs_test_util_append_file("/myfile.txt", "5", 1);
+
+ TEST_ASSERT_FATAL(nffs_block_entry_pool.mp_num_free == 2);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "12345",
+ .contents_len = 5,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, area_descs_two);
+}
diff --git a/test/src/testcases/gc_test.c b/test/src/testcases/gc_test.c
new file mode 100644
index 0000000..49a77a6
--- /dev/null
+++ b/test/src/testcases/gc_test.c
@@ -0,0 +1,67 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_gc)
+{
+ int rc;
+
+ static const struct nffs_area_desc area_descs_two[] = {
+ { 0x00020000, 128 * 1024 },
+ { 0x00040000, 128 * 1024 },
+ { 0, 0 },
+ };
+
+ struct nffs_test_block_desc blocks[8] = { {
+ .data = "1",
+ .data_len = 1,
+ }, {
+ .data = "2",
+ .data_len = 1,
+ }, {
+ .data = "3",
+ .data_len = 1,
+ }, {
+ .data = "4",
+ .data_len = 1,
+ }, {
+ .data = "5",
+ .data_len = 1,
+ }, {
+ .data = "6",
+ .data_len = 1,
+ }, {
+ .data = "7",
+ .data_len = 1,
+ }, {
+ .data = "8",
+ .data_len = 1,
+ } };
+
+
+ rc = nffs_format(area_descs_two);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 8);
+
+ nffs_gc(NULL);
+
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+}
diff --git a/test/src/testcases/incomplete_block_test.c b/test/src/testcases/incomplete_block_test.c
new file mode 100644
index 0000000..33fa9c3
--- /dev/null
+++ b/test/src/testcases/incomplete_block_test.c
@@ -0,0 +1,119 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+/*
+ * This test no longer works with the current implementation. The
+ * expectation is that intermediate blocks can be removed and the old
+ * method of finding the last current block after restore will allow the
+ * file to be salvaged. Instead, the file should be removed and all data
+ * declared invalid.
+ */
+TEST_CASE(nffs_test_incomplete_block)
+{
+ struct nffs_block block;
+ struct fs_file *fs_file;
+ struct nffs_file *file;
+ uint32_t flash_offset;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/mydir/a", "aaaa", 4);
+ nffs_test_util_create_file("/mydir/b", "bbbb", 4);
+ nffs_test_util_create_file("/mydir/c", "cccc", 4);
+
+ /* Add a second block to the 'b' file. */
+ nffs_test_util_append_file("/mydir/b", "1234", 4);
+
+ /* Corrupt the 'b' file; make it look like the second block only got half
+ * written.
+ */
+ rc = fs_open("/mydir/b", FS_ACCESS_READ, &fs_file);
+ TEST_ASSERT(rc == 0);
+ file = (struct nffs_file *)fs_file;
+
+ rc = nffs_block_from_hash_entry(&block,
+ file->nf_inode_entry->nie_last_block_entry);
+ TEST_ASSERT(rc == 0);
+
+ nffs_flash_loc_expand(block.nb_hash_entry->nhe_flash_loc, &area_idx,
+ &area_offset);
+ flash_offset = nffs_areas[area_idx].na_offset + area_offset;
+ /*
+ * Overwrite block data - the CRC check should pick this up
+ */
+ rc = flash_native_memset(
+ flash_offset + sizeof (struct nffs_disk_block) + 2, 0xff, 2);
+ TEST_ASSERT(rc == 0);
+
+ rc = nffs_misc_reset();
+ TEST_ASSERT(rc == 0);
+ rc = nffs_detect(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /* OLD: The entire second block should be removed; the file should only
+ * contain the first block.
+ * Unless we can salvage the block, the entire file should probably be
+ * removed. This is a contrived example which generates bad data on the
+ * what happens to be the last block, but corruption can actually occur
+ * in any block. Sweep should be updated to search look for blocks that
+ * don't have a correct prev_id and then decide whether to delete the
+ * owning inode. XXX
+ */
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "mydir",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "a",
+ .contents = "aaaa",
+ .contents_len = 4,
+#if 0
+/* keep this out until sweep updated to capture bad blocks XXX */
+ }, {
+ .filename = "b",
+ .contents = "bbbb",
+ .contents_len = 4,
+#endif
+ }, {
+ .filename = "c",
+ .contents = "cccc",
+ .contents_len = 4,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/large_system_test.c b/test/src/testcases/large_system_test.c
new file mode 100644
index 0000000..fc0fad1
--- /dev/null
+++ b/test/src/testcases/large_system_test.c
@@ -0,0 +1,43 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_large_system)
+{
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_create_tree(nffs_test_system_01);
+
+ nffs_test_assert_system(nffs_test_system_01, nffs_current_area_descs);
+
+ rc = fs_unlink("/lvl1dir-0000");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_unlink("/lvl1dir-0004");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/lvl1dir-0000");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_assert_system(nffs_test_system_01_rm_1014_mk10, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/large_unlink_test.c b/test/src/testcases/large_unlink_test.c
new file mode 100644
index 0000000..4805ff4
--- /dev/null
+++ b/test/src/testcases/large_unlink_test.c
@@ -0,0 +1,85 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_large_unlink)
+{
+ /* It should not be necessary to initialize this array, but the libgcc
+ * version of strcmp triggers a "Conditional jump or move depends on
+ * uninitialised value(s)" valgrind warning.
+ */
+ char filename[256] = { 0 };
+ int rc;
+ int i;
+ int j;
+ int k;
+
+ static char file_contents[1024 * 4];
+
+ /*** Setup. */
+ nffs_config.nc_num_inodes = 1024;
+ nffs_config.nc_num_blocks = 1024;
+
+ rc = nffs_init();
+ TEST_ASSERT(rc == 0);
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ for (i = 0; i < 5; i++) {
+ snprintf(filename, sizeof filename, "/dir0_%d", i);
+ rc = fs_mkdir(filename);
+ TEST_ASSERT(rc == 0);
+
+ for (j = 0; j < 5; j++) {
+ snprintf(filename, sizeof filename, "/dir0_%d/dir1_%d", i, j);
+ rc = fs_mkdir(filename);
+ TEST_ASSERT(rc == 0);
+
+ for (k = 0; k < 5; k++) {
+ snprintf(filename, sizeof filename,
+ "/dir0_%d/dir1_%d/file2_%d", i, j, k);
+ nffs_test_util_create_file(filename, file_contents,
+ sizeof file_contents);
+ }
+ }
+
+ for (j = 0; j < 15; j++) {
+ snprintf(filename, sizeof filename, "/dir0_%d/file1_%d", i, j);
+ nffs_test_util_create_file(filename, file_contents,
+ sizeof file_contents);
+ }
+ }
+
+ for (i = 0; i < 5; i++) {
+ snprintf(filename, sizeof filename, "/dir0_%d", i);
+ rc = fs_unlink(filename);
+ TEST_ASSERT(rc == 0);
+ }
+
+ /* The entire file system should be empty. */
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/large_write_test.c b/test/src/testcases/large_write_test.c
new file mode 100644
index 0000000..3bf3a02
--- /dev/null
+++ b/test/src/testcases/large_write_test.c
@@ -0,0 +1,71 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_large_write)
+{
+ static char data[NFFS_BLOCK_MAX_DATA_SZ_MAX * 5];
+ int rc;
+ int i;
+
+ static const struct nffs_area_desc area_descs_two[] = {
+ { 0x00020000, 128 * 1024 },
+ { 0x00040000, 128 * 1024 },
+ { 0, 0 },
+ };
+
+ /*** Setup. */
+ rc = nffs_format(area_descs_two);
+ TEST_ASSERT(rc == 0);
+
+ for (i = 0; i < sizeof data; i++) {
+ data[i] = i;
+ }
+
+ nffs_test_util_create_file("/myfile.txt", data, sizeof data);
+
+ /* Ensure large write was split across the appropriate number of data
+ * blocks.
+ */
+ TEST_ASSERT(nffs_test_util_block_count("/myfile.txt") ==
+ sizeof data / NFFS_BLOCK_MAX_DATA_SZ_MAX);
+
+ /* Garbage collect and then ensure the large file is still properly divided
+ * according to max data block size.
+ */
+ nffs_gc(NULL);
+ TEST_ASSERT(nffs_test_util_block_count("/myfile.txt") ==
+ sizeof data / NFFS_BLOCK_MAX_DATA_SZ_MAX);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = data,
+ .contents_len = sizeof data,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, area_descs_two);
+}
diff --git a/test/src/testcases/long_filename_test.c b/test/src/testcases/long_filename_test.c
new file mode 100644
index 0000000..0afc99a
--- /dev/null
+++ b/test/src/testcases/long_filename_test.c
@@ -0,0 +1,59 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_long_filename)
+{
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/12345678901234567890.txt", "contents", 8);
+
+ rc = fs_mkdir("/longdir12345678901234567890");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_rename("/12345678901234567890.txt",
+ "/longdir12345678901234567890/12345678901234567890.txt");
+ TEST_ASSERT(rc == 0);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "longdir12345678901234567890",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "/12345678901234567890.txt",
+ .contents = "contents",
+ .contents_len = 8,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/lost_found_test.c b/test/src/testcases/lost_found_test.c
new file mode 100644
index 0000000..5accb74
--- /dev/null
+++ b/test/src/testcases/lost_found_test.c
@@ -0,0 +1,107 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_lost_found)
+{
+ char buf[32];
+ struct nffs_inode_entry *inode_entry;
+ uint32_t flash_offset;
+ uint32_t area_offset;
+ uint8_t area_idx;
+ int rc;
+ struct nffs_disk_inode ndi;
+ uint8_t off; /* calculated offset for memset */
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+ rc = fs_mkdir("/mydir/dir1");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/mydir/file1", "aaaa", 4);
+ nffs_test_util_create_file("/mydir/dir1/file2", "bbbb", 4);
+
+ /* Corrupt the mydir inode. */
+ rc = nffs_path_find_inode_entry("/mydir", &inode_entry);
+ TEST_ASSERT(rc == 0);
+
+ snprintf(buf, sizeof buf, "%lu",
+ (unsigned long)inode_entry->nie_hash_entry.nhe_id);
+
+ nffs_flash_loc_expand(inode_entry->nie_hash_entry.nhe_flash_loc,
+ &area_idx, &area_offset);
+ flash_offset = nffs_areas[area_idx].na_offset + area_offset;
+ /*
+ * Overwrite the sequence number - should be detected as CRC corruption
+ */
+ off = (char*)&ndi.ndi_seq - (char*)&ndi;
+ rc = flash_native_memset(flash_offset + off, 0xaa, 1);
+ TEST_ASSERT(rc == 0);
+
+ /* Clear cached data and restore from flash (i.e, simulate a reboot). */
+ rc = nffs_misc_reset();
+ TEST_ASSERT(rc == 0);
+ rc = nffs_detect(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /* All contents should now be in the lost+found dir. */
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "lost+found",
+ .is_dir = 1,
+#if 0
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = buf,
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "file1",
+ .contents = "aaaa",
+ .contents_len = 4,
+ }, {
+ .filename = "dir1",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "file2",
+ .contents = "bbbb",
+ .contents_len = 4,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+#endif
+ }, {
+ .filename = NULL,
+ } }
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/many_children_test.c b/test/src/testcases/many_children_test.c
new file mode 100644
index 0000000..7cf2b8c
--- /dev/null
+++ b/test/src/testcases/many_children_test.c
@@ -0,0 +1,74 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_many_children)
+{
+ int rc;
+
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/zasdf", NULL, 0);
+ nffs_test_util_create_file("/FfD", NULL, 0);
+ nffs_test_util_create_file("/4Zvv", NULL, 0);
+ nffs_test_util_create_file("/*(*2fs", NULL, 0);
+ nffs_test_util_create_file("/pzzd", NULL, 0);
+ nffs_test_util_create_file("/zasdf0", NULL, 0);
+ nffs_test_util_create_file("/23132.bin", NULL, 0);
+ nffs_test_util_create_file("/asldkfjaldskfadsfsdf.txt", NULL, 0);
+ nffs_test_util_create_file("/sdgaf", NULL, 0);
+ nffs_test_util_create_file("/939302**", NULL, 0);
+ rc = fs_mkdir("/dir");
+ nffs_test_util_create_file("/dir/itw82", NULL, 0);
+ nffs_test_util_create_file("/dir/124", NULL, 0);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ { "zasdf" },
+ { "FfD" },
+ { "4Zvv" },
+ { "*(*2fs" },
+ { "pzzd" },
+ { "zasdf0" },
+ { "23132.bin" },
+ { "asldkfjaldskfadsfsdf.txt" },
+ { "sdgaf" },
+ { "939302**" },
+ {
+ .filename = "dir",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) {
+ { "itw82" },
+ { "124" },
+ { NULL },
+ },
+ },
+ { NULL },
+ }
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/mkdir_test.c b/test/src/testcases/mkdir_test.c
new file mode 100644
index 0000000..f69a161
--- /dev/null
+++ b/test/src/testcases/mkdir_test.c
@@ -0,0 +1,92 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_mkdir)
+{
+ struct fs_file *file;
+ int rc;
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c/d");
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_mkdir("asdf");
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ rc = fs_mkdir("/a");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/a/b/c/d");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/a/b/c/d/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "a",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "b",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "c",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "d",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = NULL,
+ .contents_len = 0,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/open_test.c b/test/src/testcases/open_test.c
new file mode 100644
index 0000000..7edbe6c
--- /dev/null
+++ b/test/src/testcases/open_test.c
@@ -0,0 +1,74 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_open)
+{
+ struct fs_file *file;
+ struct fs_dir *dir;
+ int rc;
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /*** Fail to open an invalid path (not rooted). */
+ rc = fs_open("file", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ /*** Fail to open a directory (root directory). */
+ rc = fs_open("/", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ /*** Fail to open a nonexistent file for reading. */
+ rc = fs_open("/1234", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ /*** Fail to open a child of a nonexistent directory. */
+ rc = fs_open("/dir/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == FS_ENOENT);
+ rc = fs_opendir("/dir", &dir);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_mkdir("/dir");
+ TEST_ASSERT(rc == 0);
+
+ /*** Fail to open a directory. */
+ rc = fs_open("/dir", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ /*** Successfully open an existing file for reading. */
+ nffs_test_util_create_file("/dir/file.txt", "1234567890", 10);
+ rc = fs_open("/dir/file.txt", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == 0);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ /*** Successfully open an nonexistent file for writing. */
+ rc = fs_open("/dir/file2.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ /*** Ensure the file can be reopened. */
+ rc = fs_open("/dir/file.txt", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == 0);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+}
diff --git a/test/src/testcases/overwrite_many_test.c b/test/src/testcases/overwrite_many_test.c
new file mode 100644
index 0000000..e1e52b3
--- /dev/null
+++ b/test/src/testcases/overwrite_many_test.c
@@ -0,0 +1,105 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_overwrite_many)
+{
+ struct nffs_test_block_desc *blocks = (struct nffs_test_block_desc[]) { {
+ .data = "abcdefgh",
+ .data_len = 8,
+ }, {
+ .data = "ijklmnop",
+ .data_len = 8,
+ }, {
+ .data = "qrstuvwx",
+ .data_len = 8,
+ } };
+
+ struct fs_file *file;
+ int rc;
+
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /*** Overwrite middle of first block. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 3);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 3);
+
+ rc = fs_write(file, "12", 2);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 5);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "abc12fghijklmnopqrstuvwx", 24);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ /*** Overwrite end of first block, start of second. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234", 4);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 10);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "abcdef1234klmnopqrstuvwx", 24);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "abcdef1234klmnopqrstuvwx",
+ .contents_len = 24,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/overwrite_one_test.c b/test/src/testcases/overwrite_one_test.c
new file mode 100644
index 0000000..bf25036
--- /dev/null
+++ b/test/src/testcases/overwrite_one_test.c
@@ -0,0 +1,142 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_overwrite_one)
+{
+ struct fs_file *file;
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_append_file("/myfile.txt", "abcdefgh", 8);
+
+ /*** Overwrite within one block (middle). */
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 3);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 3);
+
+ rc = fs_write(file, "12", 2);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 5);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "abc12fgh", 8);
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+
+ /*** Overwrite within one block (start). */
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "xy", 2);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 2);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "xyc12fgh", 8);
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+
+ /*** Overwrite within one block (end). */
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "<>", 2);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 8);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "xyc12f<>", 8);
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+
+ /*** Overwrite one block middle, extend. */
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 4);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 4);
+
+ rc = fs_write(file, "abcdefgh", 8);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 12);
+ TEST_ASSERT(fs_getpos(file) == 12);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "xyc1abcdefgh", 12);
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+
+ /*** Overwrite one block start, extend. */
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 12);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "abcdefghijklmnop", 16);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 16);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "abcdefghijklmnop", 16);
+ nffs_test_util_assert_block_count("/myfile.txt", 1);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "abcdefghijklmnop",
+ .contents_len = 16,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/overwrite_three_test.c b/test/src/testcases/overwrite_three_test.c
new file mode 100644
index 0000000..3e11824
--- /dev/null
+++ b/test/src/testcases/overwrite_three_test.c
@@ -0,0 +1,167 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_overwrite_three)
+{
+ struct nffs_test_block_desc *blocks = (struct nffs_test_block_desc[]) { {
+ .data = "abcdefgh",
+ .data_len = 8,
+ }, {
+ .data = "ijklmnop",
+ .data_len = 8,
+ }, {
+ .data = "qrstuvwx",
+ .data_len = 8,
+ } };
+
+ struct fs_file *file;
+ int rc;
+
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /*** Overwrite three blocks (middle). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234567890!@", 12);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 18);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "abcdef1234567890!@stuvwx", 24);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ /*** Overwrite three blocks (start). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "1234567890!@#$%^&*()", 20);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 20);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "1234567890!@#$%^&*()uvwx", 24);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ /*** Overwrite three blocks (end). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234567890!@#$%^&*", 18);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 24);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "abcdef1234567890!@#$%^&*", 24);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ /*** Overwrite three blocks middle, extend. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234567890!@#$%^&*()", 20);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 26);
+ TEST_ASSERT(fs_getpos(file) == 26);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "abcdef1234567890!@#$%^&*()", 26);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ /*** Overwrite three blocks start, extend. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 3);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 24);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "1234567890!@#$%^&*()abcdefghij", 30);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 30);
+ TEST_ASSERT(fs_getpos(file) == 30);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt",
+ "1234567890!@#$%^&*()abcdefghij", 30);
+ nffs_test_util_assert_block_count("/myfile.txt", 3);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "1234567890!@#$%^&*()abcdefghij",
+ .contents_len = 30,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/overwrite_two_test.c b/test/src/testcases/overwrite_two_test.c
new file mode 100644
index 0000000..259cc3d
--- /dev/null
+++ b/test/src/testcases/overwrite_two_test.c
@@ -0,0 +1,159 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_overwrite_two)
+{
+ struct nffs_test_block_desc *blocks = (struct nffs_test_block_desc[]) { {
+ .data = "abcdefgh",
+ .data_len = 8,
+ }, {
+ .data = "ijklmnop",
+ .data_len = 8,
+ } };
+
+ struct fs_file *file;
+ int rc;
+
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ /*** Overwrite two blocks (middle). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 2);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 7);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 7);
+
+ rc = fs_write(file, "123", 3);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 10);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt", "abcdefg123klmnop", 16);
+ nffs_test_util_assert_block_count("/myfile.txt", 2);
+
+ /*** Overwrite two blocks (start). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 2);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "ABCDEFGHIJ", 10);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 10);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt", "ABCDEFGHIJklmnop", 16);
+ nffs_test_util_assert_block_count("/myfile.txt", 2);
+
+ /*** Overwrite two blocks (end). */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 2);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234567890", 10);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 16);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt", "abcdef1234567890", 16);
+ nffs_test_util_assert_block_count("/myfile.txt", 2);
+
+ /*** Overwrite two blocks middle, extend. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 2);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_seek(file, 6);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 6);
+
+ rc = fs_write(file, "1234567890!@#$", 14);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 20);
+ TEST_ASSERT(fs_getpos(file) == 20);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt", "abcdef1234567890!@#$", 20);
+ nffs_test_util_assert_block_count("/myfile.txt", 2);
+
+ /*** Overwrite two blocks start, extend. */
+ nffs_test_util_create_file_blocks("/myfile.txt", blocks, 2);
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 16);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "1234567890!@#$%^&*()", 20);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 20);
+ TEST_ASSERT(fs_getpos(file) == 20);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents( "/myfile.txt", "1234567890!@#$%^&*()", 20);
+ nffs_test_util_assert_block_count("/myfile.txt", 2);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "1234567890!@#$%^&*()",
+ .contents_len = 20,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/read_test.c b/test/src/testcases/read_test.c
new file mode 100644
index 0000000..28738e9
--- /dev/null
+++ b/test/src/testcases/read_test.c
@@ -0,0 +1,53 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_read)
+{
+ struct fs_file *file;
+ uint8_t buf[16];
+ uint32_t bytes_read;
+ int rc;
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_create_file("/myfile.txt", "1234567890", 10);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 10);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_read(file, 4, buf, &bytes_read);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(bytes_read == 4);
+ TEST_ASSERT(memcmp(buf, "1234", 4) == 0);
+ TEST_ASSERT(fs_getpos(file) == 4);
+
+ rc = fs_read(file, sizeof buf - 4, buf + 4, &bytes_read);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(bytes_read == 6);
+ TEST_ASSERT(memcmp(buf, "1234567890", 10) == 0);
+ TEST_ASSERT(fs_getpos(file) == 10);
+
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+}
diff --git a/test/src/testcases/readdir_test.c b/test/src/testcases/readdir_test.c
new file mode 100644
index 0000000..2faabe0
--- /dev/null
+++ b/test/src/testcases/readdir_test.c
@@ -0,0 +1,124 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_readdir)
+{
+ struct fs_dirent *dirent;
+ struct fs_dir *dir;
+ int rc;
+
+ /*** Setup. */
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT_FATAL(rc == 0);
+
+ nffs_test_util_create_file("/mydir/b", "bbbb", 4);
+ nffs_test_util_create_file("/mydir/a", "aaaa", 4);
+ rc = fs_mkdir("/mydir/c");
+ TEST_ASSERT_FATAL(rc == 0);
+
+ /* Nonexistent directory. */
+ rc = fs_opendir("/asdf", &dir);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ /* Fail to opendir a file. */
+ rc = fs_opendir("/mydir/a", &dir);
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ /* Real directory (with trailing slash). */
+ rc = fs_opendir("/mydir/", &dir);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_ent_name(dirent, "a");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 0);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_ent_name(dirent, "b");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 0);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_ent_name(dirent, "c");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 1);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_closedir(dir);
+ TEST_ASSERT(rc == 0);
+
+ /* Root directory. */
+ rc = fs_opendir("/", &dir);
+ TEST_ASSERT(rc == 0);
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_ent_name(dirent, "lost+found");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 1);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_ent_name(dirent, "mydir");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 1);
+
+ rc = fs_closedir(dir);
+ TEST_ASSERT(rc == 0);
+
+ /* Delete entries while iterating. */
+ rc = fs_opendir("/mydir", &dir);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_ent_name(dirent, "a");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 0);
+
+ rc = fs_unlink("/mydir/b");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_unlink("/mydir/c");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_unlink("/mydir");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_ent_name(dirent, "c");
+ TEST_ASSERT(fs_dirent_is_dir(dirent) == 1);
+
+ rc = fs_readdir(dir, &dirent);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_closedir(dir);
+ TEST_ASSERT(rc == 0);
+
+ /* Ensure directory is gone. */
+ rc = fs_opendir("/mydir", &dir);
+ TEST_ASSERT(rc == FS_ENOENT);
+}
diff --git a/test/src/testcases/rename_test.c b/test/src/testcases/rename_test.c
new file mode 100644
index 0000000..e925615
--- /dev/null
+++ b/test/src/testcases/rename_test.c
@@ -0,0 +1,98 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_rename)
+{
+ struct fs_file *file;
+ const char contents[] = "contents";
+ int rc;
+
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_rename("/nonexistent.txt", "/newname.txt");
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ /*** Rename file. */
+ nffs_test_util_create_file("/myfile.txt", contents, sizeof contents);
+
+ rc = fs_rename("/myfile.txt", "badname");
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ rc = fs_rename("/myfile.txt", "/myfile2.txt");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_READ, &file);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ nffs_test_util_assert_contents("/myfile2.txt", contents, sizeof contents);
+
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_mkdir("/mydir/leafdir");
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_rename("/myfile2.txt", "/mydir/myfile2.txt");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/mydir/myfile2.txt", contents,
+ sizeof contents);
+
+ /*** Rename directory. */
+ rc = fs_rename("/mydir", "badname");
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ /* Don't allow a directory to be moved into a descendent directory. */
+ rc = fs_rename("/mydir", "/mydir/leafdir/a");
+ TEST_ASSERT(rc == FS_EINVAL);
+
+ rc = fs_rename("/mydir", "/mydir2");
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/mydir2/myfile2.txt", contents,
+ sizeof contents);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "mydir2",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "leafdir",
+ .is_dir = 1,
+ }, {
+ .filename = "myfile2.txt",
+ .contents = "contents",
+ .contents_len = 9,
+ }, {
+ .filename = NULL,
+ } },
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/split_file_test.c b/test/src/testcases/split_file_test.c
new file mode 100644
index 0000000..137d961
--- /dev/null
+++ b/test/src/testcases/split_file_test.c
@@ -0,0 +1,65 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_split_file)
+{
+ static char data[24 * 1024];
+ int rc;
+ int i;
+
+ /*** Setup. */
+ static const struct nffs_area_desc area_descs_two[] = {
+ { 0x00000000, 16 * 1024 },
+ { 0x00004000, 16 * 1024 },
+ { 0x00008000, 16 * 1024 },
+ { 0, 0 },
+ };
+
+ rc = nffs_format(area_descs_two);
+ TEST_ASSERT(rc == 0);
+
+ for (i = 0; i < sizeof data; i++) {
+ data[i] = i;
+ }
+
+ for (i = 0; i < 256; i++) {
+ nffs_test_util_create_file("/myfile.txt", data, sizeof data);
+ rc = fs_unlink("/myfile.txt");
+ TEST_ASSERT(rc == 0);
+ }
+
+ nffs_test_util_create_file("/myfile.txt", data, sizeof data);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = data,
+ .contents_len = sizeof data,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, area_descs_two);
+}
diff --git a/test/src/testcases/truncate_test.c b/test/src/testcases/truncate_test.c
new file mode 100644
index 0000000..d2b6bf2
--- /dev/null
+++ b/test/src/testcases/truncate_test.c
@@ -0,0 +1,73 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_truncate)
+{
+ struct fs_file *file;
+ int rc;
+
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE | FS_ACCESS_TRUNCATE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 0);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "abcdefgh", 8);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 8);
+ TEST_ASSERT(fs_getpos(file) == 8);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "abcdefgh", 8);
+
+ rc = fs_open("/myfile.txt", FS_ACCESS_WRITE | FS_ACCESS_TRUNCATE, &file);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 0);
+ TEST_ASSERT(fs_getpos(file) == 0);
+
+ rc = fs_write(file, "1234", 4);
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_assert_file_len(file, 4);
+ TEST_ASSERT(fs_getpos(file) == 4);
+ rc = fs_close(file);
+ TEST_ASSERT(rc == 0);
+
+ nffs_test_util_assert_contents("/myfile.txt", "1234", 4);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ .children = (struct nffs_test_file_desc[]) { {
+ .filename = "myfile.txt",
+ .contents = "1234",
+ .contents_len = 4,
+ }, {
+ .filename = NULL,
+ } },
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+}
diff --git a/test/src/testcases/unlink_test.c b/test/src/testcases/unlink_test.c
new file mode 100644
index 0000000..61bdf25
--- /dev/null
+++ b/test/src/testcases/unlink_test.c
@@ -0,0 +1,121 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_unlink)
+{
+ struct fs_file *file0;
+ struct fs_file *file2;
+ uint8_t buf[64];
+ struct nffs_file *nfs_file;
+ uint32_t bytes_read;
+ struct fs_file *file1;
+ int initial_num_blocks;
+ int initial_num_inodes;
+ int rc;
+
+ rc = nffs_format(nffs_current_area_descs);
+ TEST_ASSERT_FATAL(rc == 0);
+
+ initial_num_blocks = nffs_block_entry_pool.mp_num_free;
+ initial_num_inodes = nffs_inode_entry_pool.mp_num_free;
+
+ nffs_test_util_create_file("/file0.txt", "0", 1);
+
+ rc = fs_open("/file0.txt", FS_ACCESS_READ | FS_ACCESS_WRITE, &file0);
+ TEST_ASSERT(rc == 0);
+ nfs_file = (struct nffs_file *)file0;
+ TEST_ASSERT(nfs_file->nf_inode_entry->nie_refcnt == 2);
+
+ rc = fs_unlink("/file0.txt");
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(nfs_file->nf_inode_entry->nie_refcnt == 1);
+
+ rc = fs_open("/file0.txt", FS_ACCESS_READ, &file2);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_write(file0, "00", 2);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_seek(file0, 0);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_read(file0, sizeof buf, buf, &bytes_read);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(bytes_read == 2);
+ TEST_ASSERT(memcmp(buf, "00", 2) == 0);
+
+ rc = fs_close(file0);
+ TEST_ASSERT(rc == 0);
+
+
+ rc = fs_open("/file0.txt", FS_ACCESS_READ, &file0);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ /* Ensure the file was fully removed from RAM. */
+ TEST_ASSERT(nffs_inode_entry_pool.mp_num_free == initial_num_inodes);
+ TEST_ASSERT(nffs_block_entry_pool.mp_num_free == initial_num_blocks);
+
+ /*** Nested unlink. */
+ rc = fs_mkdir("/mydir");
+ TEST_ASSERT(rc == 0);
+ nffs_test_util_create_file("/mydir/file1.txt", "1", 2);
+
+ rc = fs_open("/mydir/file1.txt", FS_ACCESS_READ | FS_ACCESS_WRITE, &file1);
+ TEST_ASSERT(rc == 0);
+ nfs_file = (struct nffs_file *)file1;
+ TEST_ASSERT(nfs_file->nf_inode_entry->nie_refcnt == 2);
+
+ rc = fs_unlink("/mydir");
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(nfs_file->nf_inode_entry->nie_refcnt == 1);
+
+ rc = fs_open("/mydir/file1.txt", FS_ACCESS_READ, &file2);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ rc = fs_write(file1, "11", 2);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_seek(file1, 0);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_read(file1, sizeof buf, buf, &bytes_read);
+ TEST_ASSERT(rc == 0);
+ TEST_ASSERT(bytes_read == 2);
+ TEST_ASSERT(memcmp(buf, "11", 2) == 0);
+
+ rc = fs_close(file1);
+ TEST_ASSERT(rc == 0);
+
+ rc = fs_open("/mydir/file1.txt", FS_ACCESS_READ, &file1);
+ TEST_ASSERT(rc == FS_ENOENT);
+
+ struct nffs_test_file_desc *expected_system =
+ (struct nffs_test_file_desc[]) { {
+ .filename = "",
+ .is_dir = 1,
+ } };
+
+ nffs_test_assert_system(expected_system, nffs_current_area_descs);
+
+ /* Ensure the files and directories were fully removed from RAM. */
+ TEST_ASSERT(nffs_inode_entry_pool.mp_num_free == initial_num_inodes);
+ TEST_ASSERT(nffs_block_entry_pool.mp_num_free == initial_num_blocks);
+}
diff --git a/test/src/testcases/wear_level_test.c b/test/src/testcases/wear_level_test.c
new file mode 100644
index 0000000..929f5af
--- /dev/null
+++ b/test/src/testcases/wear_level_test.c
@@ -0,0 +1,58 @@
+/*
+ * 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 "nffs_test_utils.h"
+
+TEST_CASE(nffs_test_wear_level)
+{
+ int rc;
+ int i;
+ int j;
+
+ static const struct nffs_area_desc area_descs_uniform[] = {
+ { 0x00000000, 2 * 1024 },
+ { 0x00020000, 2 * 1024 },
+ { 0x00040000, 2 * 1024 },
+ { 0x00060000, 2 * 1024 },
+ { 0x00080000, 2 * 1024 },
+ { 0, 0 },
+ };
+
+ /*** Setup. */
+ rc = nffs_format(area_descs_uniform);
+ TEST_ASSERT(rc == 0);
+
+ /* Ensure areas rotate properly. */
+ for (i = 0; i < 255; i++) {
+ for (j = 0; j < nffs_num_areas; j++) {
+ nffs_test_assert_area_seqs(i, nffs_num_areas - j, i + 1, j);
+ nffs_gc(NULL);
+ }
+ }
+
+ /* Ensure proper rollover of sequence numbers. */
+ for (j = 0; j < nffs_num_areas; j++) {
+ nffs_test_assert_area_seqs(255, nffs_num_areas - j, 0, j);
+ nffs_gc(NULL);
+ }
+ for (j = 0; j < nffs_num_areas; j++) {
+ nffs_test_assert_area_seqs(0, nffs_num_areas - j, 1, j);
+ nffs_gc(NULL);
+ }
+}
