Update to the latest SPIFFS git and cleanup

Almost unmodified spiffs from github
lots of NodeMCU leftovers are removed
More proper names given to platform related files
Adjusting the FS class for the changes

Author: ficeto

Diff for: cores/esp8266/FileSystem.cpp

@@ -22,49 +22,71 @@
 #include "Arduino.h"
 
 bool FSClass::mount() {
-  if (_mounted) 
-    return true;
-
-  _mounted = spiffs_mount();
-  return _mounted;
+  if(SPIFFS_mounted(&_filesystemStorageHandle)) return true;
+  int res = spiffs_mount();
+  if(res != 0){
+    int formated = SPIFFS_format(&_filesystemStorageHandle);
+    if(formated != 0) return false;
+    res = spiffs_mount();
+  }
+  return (res == 0);
 }
 
 void FSClass::unmount() {
-  if (!_mounted)
-    return;
-
-  spiffs_unmount();
-  _mounted = false;
+  if(SPIFFS_mounted(&_filesystemStorageHandle))
+    SPIFFS_unmount(&_filesystemStorageHandle);
 }
 
 bool FSClass::format() {
-  return spiffs_format();
+  if(!SPIFFS_mounted(&_filesystemStorageHandle)){
+    spiffs_mount();
+  }
+  SPIFFS_unmount(&_filesystemStorageHandle);
+  int formated = SPIFFS_format(&_filesystemStorageHandle);
+  if(formated != 0) return false;
+  return (spiffs_mount() == 0);
 }
 
 bool FSClass::check() {
   return SPIFFS_check(&_filesystemStorageHandle) == 0;
 }
 
-bool FSClass::exists(const char *filename) {
+bool FSClass::exists(char *filename) {
   spiffs_stat stat = {0};
   if (SPIFFS_stat(&_filesystemStorageHandle, filename, &stat) < 0) 
     return false;
   return stat.name[0] != '\0';
 }
 
-bool FSClass::create(const char *filepath){
+bool FSClass::create(char *filepath){
   return SPIFFS_creat(&_filesystemStorageHandle, filepath, 0) == 0;
 }
 
-bool FSClass::remove(const char *filepath){
+bool FSClass::remove(char *filepath){
   return SPIFFS_remove(&_filesystemStorageHandle, filepath) == 0;
 }
 
-bool FSClass::rename(const char *filename, const char *newname) {
+bool FSClass::rename(char *filename, char *newname) {
   return SPIFFS_rename(&_filesystemStorageHandle, filename, newname) == 0;
 }
 
-FSFile FSClass::open(const char *filename, uint8_t mode) {
+size_t FSClass::totalBytes(){
+  u32_t totalBytes;
+  u32_t usedBytes;
+  if(SPIFFS_info(&_filesystemStorageHandle, &totalBytes, &usedBytes) == 0)
+    return totalBytes;
+  return 0;
+}
+
+size_t FSClass::usedBytes(){
+  u32_t totalBytes;
+  u32_t usedBytes;
+  if(SPIFFS_info(&_filesystemStorageHandle, &totalBytes, &usedBytes) == 0)
+    return usedBytes;
+  return 0;
+}
+
+FSFile FSClass::open(char *filename, uint8_t mode) {
   if(String(filename) == "" || String(filename) == "/") return FSFile("/");
   int repeats = 0;
   bool notExist;
@@ -76,7 +98,7 @@ FSFile FSClass::open(const char *filename, uint8_t mode) {
     res = SPIFFS_open(&_filesystemStorageHandle, filename, (spiffs_flags)mode, 0);
     int code = SPIFFS_errno(&_filesystemStorageHandle);
     if (res < 0){
-      debugf("open errno %d\n", code);
+      SPIFFS_API_DBG_E("open errno %d\n", code);
       notExist = (code == SPIFFS_ERR_NOT_FOUND || code == SPIFFS_ERR_DELETED || code == SPIFFS_ERR_FILE_DELETED || code == SPIFFS_ERR_IS_FREE);
       if (notExist && canRecreate)
         remove(filename); // fix for deleted files
@@ -112,11 +134,11 @@ FSFile::FSFile(String path) {
     _stats.type = SPIFFS_TYPE_DIR;
     SPIFFS_opendir(&_filesystemStorageHandle, (char*)_stats.name, &_dir);
   } else {
-    _file = SPIFFS_open(&_filesystemStorageHandle, path.c_str(), (spiffs_flags)FSFILE_READ, 0);
+    _file = SPIFFS_open(&_filesystemStorageHandle, (char *)path.c_str(), (spiffs_flags)FSFILE_READ, 0);
     if(SPIFFS_fstat(&_filesystemStorageHandle, _file, &_stats) != 0){
-      debugf("stats errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
+      SPIFFS_API_DBG_E("fstat errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
     }
-    debugf("FSFile name: %s, size: %d, type: %d\n", _stats.name, _stats.size, _stats.type);
+    //debugf("FSFile name: %s, size: %d, type: %d\n", _stats.name, _stats.size, _stats.type);
     if(_stats.type == SPIFFS_TYPE_DIR){
       SPIFFS_opendir(&_filesystemStorageHandle, (char*)_stats.name, &_dir);
     }
@@ -126,9 +148,9 @@ FSFile::FSFile(String path) {
 FSFile::FSFile(file_t f) {
   _file = f;
   if(SPIFFS_fstat(&_filesystemStorageHandle, _file, &_stats) != 0){
-    debugf("stats errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
+    SPIFFS_API_DBG_E("fstat errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
   }
-  debugf("FSFile name: %s, size: %d, type: %d\n", _stats.name, _stats.size, _stats.type);
+  //debugf("FSFile name: %s, size: %d, type: %d\n", _stats.name, _stats.size, _stats.type);
   if(_stats.type == SPIFFS_TYPE_DIR){
     SPIFFS_opendir(&_filesystemStorageHandle, (char*)_stats.name, &_dir);
   }
@@ -237,13 +259,13 @@ void FSFile::flush(){
 bool FSFile::remove(){
   if (! _file) return 0;
   close();
-	return SPIFFS_remove(&_filesystemStorageHandle, (const char *)_stats.name) == 0;
+	return SPIFFS_remove(&_filesystemStorageHandle, (char *)_stats.name) == 0;
 }
 
 int FSFile::lastError(){
   return SPIFFS_errno(&_filesystemStorageHandle);
 }
 
 void FSFile::clearError(){
-  _filesystemStorageHandle.errno = SPIFFS_OK;
+  _filesystemStorageHandle.err_code = SPIFFS_OK;
 }

Diff for: cores/esp8266/FileSystem.h

@@ -85,17 +85,18 @@ class FSFile : public Stream {
 class FSClass {
 
 private:
-  bool _mounted = false;
 
 public:
   bool mount();
   void unmount();
   bool format();
   bool check();
-  bool exists(const char *filename);
-  bool create(const char *filepath);
-  bool remove(const char *filepath);
-  bool rename(const char *filename, const char *newname);
+  bool exists(char *filename);
+  bool create(char *filepath);
+  bool remove(char *filepath);
+  bool rename(char *filename, char *newname);
+  size_t totalBytes();
+  size_t usedBytes();
   size_t size(){ return _filesystemStorageHandle.cfg.phys_size; }
   size_t blockSize(){ return _filesystemStorageHandle.cfg.log_block_size; }
   size_t totalBlocks(){ return _filesystemStorageHandle.block_count; }
@@ -104,7 +105,7 @@ class FSClass {
   size_t allocatedPages(){ return _filesystemStorageHandle.stats_p_allocated; }
   size_t deletedPages(){ return _filesystemStorageHandle.stats_p_deleted; }
 
-  FSFile open(const char *filename, uint8_t mode = FSFILE_READ);
+  FSFile open(char *filename, uint8_t mode = FSFILE_READ);
   FSFile open(spiffs_dirent* entry, uint8_t mode = FSFILE_READ);
 
 private:

Diff for: cores/esp8266/spiffs/docs/INTEGRATION renamed to cores/esp8266/spiffs/INTEGRATION

@@ -303,4 +303,4 @@ Having these figures you can disable SPIFFS_BUFFER_HELP again to save flash.
 
 * HOW TO CONFIG
 
-TODO
+TODO

Diff for: cores/esp8266/spiffs/Makefile

@@ -0,0 +1,86 @@
+SPIFFS (SPI Flash File System)
+V0.3.0
+
+Copyright (c) 2013-2015 Peter Andersson (pelleplutt1976<at>gmail.com)
+
+For legal stuff, see LICENCE in this directory. Basically, you may do whatever
+you want with the source. Use, modify, sell, print it out, roll it and smoke it
+ - as long as I won't be held responsible.
+
+Love to hear feedback though!
+
+
+* INTRODUCTION
+
+Spiffs is a file system intended for SPI NOR flash devices on embedded targets.
+
+Spiffs is designed with following characteristics in mind:
+ - Small (embedded) targets, sparse RAM without heap
+ - Only big areas of data (blocks) can be erased
+ - An erase will reset all bits in block to ones
+ - Writing pulls one to zeroes
+ - Zeroes can only be pulled to ones by erase
+ - Wear leveling
+
+
+* FEATURES
+
+What spiffs does:
+ - Specifically designed for low ram usage
+ - Uses statically sized ram buffers, independent of number of files
+ - Posix-like api: open, close, read, write, seek, stat, etc
+ - It can be run on any NOR flash, not only SPI flash - theoretically also on
+   embedded flash of an microprocessor
+ - Multiple spiffs configurations can be run on same target - and even on same
+   SPI flash device
+ - Implements static wear leveling 
+ - Built in file system consistency checks
+ 
+What spiffs does not:
+ - Presently, spiffs does not support directories. It produces a flat
+   structure. Creating a file with path "tmp/myfile.txt" will create a file 
+   called "tmp/myfile.txt" instead of a "myfile.txt" under directory "tmp". 
+ - It is not a realtime stack. One write operation might take much longer than
+   another.
+ - Poor scalability. Spiffs is intended for small memory devices - the normal
+   sizes for SPI flashes. Going beyond ~128MB is probably a bad idea. This is
+   a side effect of the design goal to use as little ram as possible.
+ - Presently, it does not detect or handle bad blocks.
+
+ 
+* MORE INFO 
+ 
+For integration, see the docs/INTEGRATION file.
+
+For use and design, see the docs/TECH_SPEC file.
+
+For testing and contributions, see the docs/IMPLEMENTING file.
+
+* HISTORY
+
+0.3.0
+  Added existing namecheck when creating files
+  Lots of static analysis bugs #6
+  Added rename func
+  Fix SPIFFS_read length when reading beyond file size
+  Added reading beyond file length testcase
+  Made build a bit more configurable
+  Changed name in spiffs from "errno" to "err_code" due to conflicts compiling
+    in mingw
+  Improved GC checks, fixed an append bug, more robust truncate for very special
+    case
+  GC checks preempts GC, truncate even less picky
+  Struct alignment needed for some targets, define in spiffs config #10
+  Spiffs filesystem magic, definable in config
+
+  New config defines:
+    SPIFFS_USE_MAGIC - enable or disable magic check upon mount
+    SPIFFS_ALIGNED_OBJECT_INDEX_TABLES - alignment for certain targets
+  New API functions:
+    SPIFFS_rename - rename files
+    SPIFFS_clearerr - clears last errno
+    SPIFFS_info - returns info on used and total bytes in fs
+    SPIFFS_format - formats the filesystem
+    SPIFFS_mounted - checks if filesystem is mounted
+
+

Diff for: cores/esp8266/spiffs/README

@@ -0,0 +1,15 @@
+* When mending lost pages, also see if they fit into length specified in object index header
+
+SPIFFS2 thoughts
+
+* Instead of exact object id:s in the object lookup tables, use a hash of span index and object id.
+  Eg. object id xor:ed with bit-reversed span index.
+  This should decrease number of actual pages that needs to be visited when looking thru the obj lut.
+
+* Logical number of each block. When moving stuff in a garbage collected page, the free
+  page is assigned the same number as the garbage collected. Thus, object index pages do not have to
+  be rewritten.
+
+* Steal one page, use as a bit parity page. When starting an fs modification operation, write one bit
+  as zero. When ending, write another bit as zero. On mount, if number of zeroes in page is uneven, a
+  check is automatically run.