Merge pull request #274 from trapexit/lus

add least used space and existing path, least used space policies

README.md

@@ -87,10 +87,12 @@ Due to FUSE limitations **ioctl** behaves differently if its acting on a directo
 |--------------|-------------|
 | all | Search category: acts like **ff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** it will apply to all found. **create** works like **ff**. It will exclude readonly drives and those with free space less than **minfreespace**. |
 | eplfs (existing path, least free space) | If the path exists on multiple drives use the one with the least free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lfs**. |
+| eplus (existing path, least used space) | If the path exists on multiple drives the the one with the least used space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lus**. |
 | epmfs (existing path, most free space) | If the path exists on multiple drives use the one with the most free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
 | erofs | Exclusively return **-1** with **errno** set to **EROFS**. By setting **create** functions to this you can in effect turn the filesystem readonly. |
 | ff (first found) | Given the order of the drives, as defined at mount time or when configured via xattr interface, act on the first one found. For **create** category it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
 | lfs (least free space) | Pick the drive with the least available free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
+| lus (least used space) | Pick the drive with the least used space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
 | mfs (most free space) | Pick the drive with the most available free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **ff**. |
 | newest (newest file) | Pick the file / directory with the largest mtime. For **create** category it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
 | rand (random) | Calls **all** and then randomizes. |

src/fs.cpp

@@ -73,7 +73,8 @@ namespace fs
   bool
   info(const string &path,
        bool         &readonly,
-       size_t       &spaceavail)
+       size_t       &spaceavail,
+       size_t       &spaceused)
   {
     bool rv;
     struct statvfs st;
@@ -83,6 +84,7 @@ namespace fs
       {
         readonly   = StatVFS::readonly(st);
         spaceavail = StatVFS::spaceavail(st);
+        spaceused  = StatVFS::spaceused(st);
       }
 
     return rv;
@@ -113,6 +115,20 @@ namespace fs
     return rv;
   }
 
+  bool
+  spaceused(const string &path,
+            size_t       &spaceused)
+  {
+    bool rv;
+    struct statvfs st;
+
+    rv = fs::statvfs(path,st);
+    if(rv)
+      spaceused = StatVFS::spaceused(st);
+
+    return rv;
+  }
+
   void
   findallfiles(const vector<string> &srcmounts,
                const char           *fusepath,

src/fs.hpp

@@ -35,13 +35,17 @@ namespace fs
 
   bool info(const string &path,
             bool         &readonly,
-            size_t       &spaceavail);
+            size_t       &spaceavail,
+            size_t       &spaceused);
 
   bool readonly(const string &path);
 
   bool spaceavail(const string &path,
                   size_t       &spaceavail);
 
+  bool spaceused(const string &path,
+                 size_t       &spaceavail);
+
   void findallfiles(const vector<string> &srcmounts,
                     const char           *fusepath,
                     vector<string>       &paths);

src/policy.cpp

@@ -31,10 +31,12 @@ namespace mergerfs
     (POLICY(invalid,DOESNT_PRESERVE_PATH))
     (POLICY(all,DOESNT_PRESERVE_PATH))
     (POLICY(eplfs,PRESERVES_PATH))
+    (POLICY(eplus,PRESERVES_PATH))
     (POLICY(epmfs,PRESERVES_PATH))
     (POLICY(erofs,DOESNT_PRESERVE_PATH))
     (POLICY(ff,DOESNT_PRESERVE_PATH))
     (POLICY(lfs,DOESNT_PRESERVE_PATH))
+    (POLICY(lus,DOESNT_PRESERVE_PATH))
     (POLICY(mfs,DOESNT_PRESERVE_PATH))
     (POLICY(newest,DOESNT_PRESERVE_PATH))
     (POLICY(rand,DOESNT_PRESERVE_PATH));
@@ -46,10 +48,12 @@ namespace mergerfs
   CONST_POLICY(invalid);
   CONST_POLICY(all);
   CONST_POLICY(eplfs);
+  CONST_POLICY(eplus);
   CONST_POLICY(epmfs);
   CONST_POLICY(erofs);
   CONST_POLICY(ff);
   CONST_POLICY(lfs);
+  CONST_POLICY(lus);
   CONST_POLICY(mfs);
   CONST_POLICY(newest);
   CONST_POLICY(rand);

src/policy.hpp

@@ -44,10 +44,12 @@ namespace mergerfs
           BEGIN   = 0,
           all     = BEGIN,
           eplfs,
+          eplus,
           epmfs,
           erofs,
           ff,
           lfs,
+          lus,
           mfs,
           newest,
           rand,
@@ -96,10 +98,12 @@ namespace mergerfs
       static int invalid(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int all(CType,cstrvec&,const char*,csize_t,cstrptrvec&);
       static int eplfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int eplus(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int epmfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int erofs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int ff(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int lfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int lus(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int mfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int newest(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
       static int rand(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
@@ -167,10 +171,12 @@ namespace mergerfs
     static const Policy &invalid;
     static const Policy &all;
     static const Policy &eplfs;
+    static const Policy ⩱
     static const Policy &epmfs;
     static const Policy &erofs;
     static const Policy &ff;
     static const Policy &lfs;
+    static const Policy &lus;
     static const Policy &mfs;
     static const Policy &newest;
     static const Policy &rand;

src/policy_all.cpp

@@ -37,9 +37,10 @@ _all_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/policy_eplfs.cpp

@@ -46,13 +46,14 @@ _eplfs_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
       fs::path::make(basepath,fusepath,fullpath);
 
       if(!fs::exists(fullpath))
         continue;
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/policy_eplus.cpp

@@ -0,0 +1,146 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_eplus_create(const vector<string>  &basepaths,
+              const char            *fusepath,
+              const size_t           minfreespace,
+              vector<const string*> &paths)
+{
+  string fullpath;
+  size_t eplus;
+  const string *eplusbasepath;
+
+  eplus = std::numeric_limits<size_t>::max();
+  eplusbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      size_t spaceused;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::info(*basepath,readonly,spaceavail,spaceused))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+      if(spaceused >= eplus)
+        continue;
+
+      eplus = spaceused;
+      eplusbasepath = basepath;
+    }
+
+  if(eplusbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(eplusbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_eplus_other(const vector<string>  &basepaths,
+             const char            *fusepath,
+             vector<const string*> &paths)
+{
+  string fullpath;
+  size_t eplus;
+  const string *eplusbasepath;
+
+  eplus = 0;
+  eplusbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceused;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceused(*basepath,spaceused))
+        continue;
+      if(spaceused >= eplus)
+        continue;
+
+      eplus = spaceused;
+      eplusbasepath = basepath;
+    }
+
+  if(eplusbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(eplusbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_eplus(const Category::Enum::Type  type,
+       const vector<string>       &basepaths,
+       const char                 *fusepath,
+       const size_t                minfreespace,
+       vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _eplus_create(basepaths,fusepath,minfreespace,paths);
+
+  return _eplus_other(basepaths,fusepath,paths);
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::eplus(const Category::Enum::Type  type,
+                      const vector<string>       &basepaths,
+                      const char                 *fusepath,
+                      const size_t                minfreespace,
+                      vector<const string*>     &paths)
+  {
+    int rv;
+
+    rv = _eplus(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::lus(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_epmfs.cpp

@@ -46,13 +46,14 @@ _epmfs_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
       fs::path::make(basepath,fusepath,fullpath);
 
       if(!fs::exists(fullpath))
         continue;
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/policy_ff.cpp

@@ -40,9 +40,10 @@ _ff_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/policy_lfs.cpp

@@ -45,9 +45,10 @@ _lfs_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/policy_lus.cpp

@@ -0,0 +1,141 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_lus_create(const vector<string>  &basepaths,
+            const size_t           minfreespace,
+            vector<const string*> &paths)
+{
+  string fullpath;
+  size_t lus;
+  const string *lusbasepath;
+
+  lus = std::numeric_limits<size_t>::max();
+  lusbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceused;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      if(!fs::info(*basepath,readonly,spaceavail,spaceused))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+      if(spaceused >= lus)
+        continue;
+
+      lus = spaceused;
+      lusbasepath = basepath;
+    }
+
+  if(lusbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(lusbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_lus_other(const vector<string>  &basepaths,
+           const char            *fusepath,
+           vector<const string*> &paths)
+{
+  string fullpath;
+  size_t lus;
+  const string *lusbasepath;
+
+  lus = 0;
+  lusbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceused;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceused(*basepath,spaceused))
+        continue;
+      if(spaceused >= lus)
+        continue;
+
+      lus = spaceused;
+      lusbasepath = basepath;
+    }
+
+  if(lusbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(lusbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_lus(const Category::Enum::Type  type,
+     const vector<string>       &basepaths,
+     const char                 *fusepath,
+     const size_t                minfreespace,
+     vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _lus_create(basepaths,minfreespace,paths);
+
+  return _lus_other(basepaths,fusepath,paths);
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::lus(const Category::Enum::Type  type,
+                    const vector<string>       &basepaths,
+                    const char                 *fusepath,
+                    const size_t                minfreespace,
+                    vector<const string*>      &paths)
+  {
+    int rv;
+
+    rv = _lus(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::mfs(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_mfs.cpp

@@ -43,9 +43,10 @@ _mfs_create(const vector<string>  &basepaths,
     {
       bool readonly;
       size_t spaceavail;
+      size_t _spaceused;
       const string *basepath = &basepaths[i];
 
-      if(!fs::info(*basepath,readonly,spaceavail))
+      if(!fs::info(*basepath,readonly,spaceavail,_spaceused))
         continue;
       if(readonly)
         continue;

src/statvfs_util.hpp

@@ -52,4 +52,12 @@ namespace StatVFS
   {
     return (st.f_frsize * st.f_bavail);
   }
+
+  static
+  inline
+  fsblkcnt_t
+  spaceused(const struct statvfs &st)
+  {
+    return (st.f_frsize * (st.f_blocks - st.f_bavail));
+  }
 }