Browse Source

Merge pull request #274 from trapexit/lus

add least used space and existing path, least used space policies
pull/275/head
Antonio SJ Musumeci 9 years ago
parent
commit
9f27ad448a
  1. 2
      README.md
  2. 18
      src/fs.cpp
  3. 6
      src/fs.hpp
  4. 4
      src/policy.cpp
  5. 6
      src/policy.hpp
  6. 3
      src/policy_all.cpp
  7. 3
      src/policy_eplfs.cpp
  8. 146
      src/policy_eplus.cpp
  9. 3
      src/policy_epmfs.cpp
  10. 3
      src/policy_ff.cpp
  11. 3
      src/policy_lfs.cpp
  12. 141
      src/policy_lus.cpp
  13. 3
      src/policy_mfs.cpp
  14. 8
      src/statvfs_util.hpp

2
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. |

18
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,

6
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);

4
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);

6
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 &eplus;
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;

3
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;

3
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;

146
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;
}
}

3
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;

3
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;

3
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;

141
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;
}
}

3
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;

8
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));
}
}
Loading…
Cancel
Save