Browse Source

separate policies into individual modules

pull/77/head
Antonio SJ Musumeci 10 years ago
parent
commit
6ca43893ea
  1. 10
      src/access.cpp
  2. 10
      src/chmod.cpp
  3. 12
      src/chown.cpp
  4. 16
      src/create.cpp
  5. 338
      src/fs.cpp
  6. 44
      src/fs.hpp
  7. 10
      src/getattr.cpp
  8. 14
      src/getxattr.cpp
  9. 16
      src/ioctl.cpp
  10. 24
      src/link.cpp
  11. 12
      src/listxattr.cpp
  12. 12
      src/mkdir.cpp
  13. 14
      src/mknod.cpp
  14. 12
      src/open.cpp
  15. 2
      src/policy.cpp
  16. 30
      src/policy.hpp
  17. 65
      src/policy_all.cpp
  18. 104
      src/policy_epmfs.cpp
  19. 70
      src/policy_ff.cpp
  20. 79
      src/policy_ffwp.cpp
  21. 69
      src/policy_fwfs.cpp
  22. 46
      src/policy_invalid.cpp
  23. 83
      src/policy_lfs.cpp
  24. 78
      src/policy_mfs.cpp
  25. 78
      src/policy_newest.cpp
  26. 55
      src/policy_rand.cpp
  27. 12
      src/readlink.cpp
  28. 10
      src/removexattr.cpp
  29. 22
      src/rename.cpp
  30. 8
      src/rmdir.cpp
  31. 16
      src/setxattr.cpp
  32. 10
      src/symlink.cpp
  33. 10
      src/truncate.cpp
  34. 8
      src/unlink.cpp
  35. 10
      src/utimens.cpp

10
src/access.cpp

@ -45,11 +45,11 @@ using mergerfs::Policy;
static static
int int
_access(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int mask)
_access(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int mask)
{ {
int rv; int rv;
Paths paths; Paths paths;

10
src/chmod.cpp

@ -39,11 +39,11 @@ using mergerfs::Policy;
static static
int int
_chmod(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode)
_chmod(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode)
{ {
int rv; int rv;
int error; int error;

12
src/chown.cpp

@ -40,12 +40,12 @@ using mergerfs::Policy;
static static
int int
_chown(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const uid_t uid,
const gid_t gid)
_chown(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const uid_t uid,
const gid_t gid)
{ {
int rv; int rv;
int error; int error;

16
src/create.cpp

@ -43,14 +43,14 @@ using mergerfs::Policy;
static static
int int
_create(const Policy::FuncPtr searchFunc,
const Policy::FuncPtr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode,
const int flags,
uint64_t &fh)
_create(const Policy::Func::Ptr searchFunc,
const Policy::Func::Ptr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode,
const int flags,
uint64_t &fh)
{ {
int fd; int fd;
int rv; int rv;

338
src/fs.cpp

@ -28,7 +28,6 @@
#include <sstream> #include <sstream>
#include <cstdlib> #include <cstdlib>
#include <iterator> #include <iterator>
#include <algorithm>
#include <dirent.h> #include <dirent.h>
#include <errno.h> #include <errno.h>
@ -514,341 +513,4 @@ namespace fs
globfree(&gbuf); globfree(&gbuf);
} }
namespace find
{
int
invalid(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &rv)
{
return (errno = EINVAL,-1);
}
int
ff(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
paths.push_back(Path(*iter,fullpath));
return 0;
}
}
return -1;
}
int
ffwp(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
Path fallback;
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
paths.push_back(Path(*iter,fullpath));
return 0;
}
else if(errno == EACCES)
{
fallback.base = *iter;
fallback.full = fullpath;
}
}
if(!fallback.base.empty())
return (paths.push_back(fallback),0);
return -1;
}
int
fwfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
for(size_t i = 0, size = basepaths.size(); i != size; i++)
{
int rv;
const char *basepath;
struct statvfs fsstats;
basepath = basepaths[i].c_str();
rv = ::statvfs(basepath,&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > minfreespace)
{
paths.push_back(Path(basepath,
fs::make_path(basepath,fusepath)));
return 0;
}
}
}
return mfs(basepaths,fusepath,minfreespace,paths);
}
int
newest(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
time_t newest;
string npath;
vector<string>::const_iterator niter;
newest = 0;
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0 && st.st_mtime > newest)
{
newest = st.st_mtime;
niter = iter;
npath = fullpath;
}
}
if(newest)
return (paths.push_back(Path(*niter,npath)),0);
return -1;
}
int
lfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t lfs;
const char *lfsstr;
lfs = -1;
lfsstr = NULL;
for(size_t i = 0, size = basepaths.size(); i != size; i++)
{
int rv;
const char *basepath;
struct statvfs fsstats;
basepath = basepaths[i].c_str();
rv = ::statvfs(basepath,&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if((spaceavail > minfreespace) &&
(spaceavail < lfs))
{
lfs = spaceavail;
lfsstr = basepath;
}
}
}
if(lfsstr == NULL)
return mfs(basepaths,fusepath,minfreespace,paths);
paths.push_back(Path(lfsstr,
fs::make_path(lfsstr,fusepath)));
return 0;
}
int
mfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t mfs;
size_t mfsidx;
mfs = 0;
for(size_t i = 0, size = basepaths.size();
i != size;
i++)
{
int rv;
struct statvfs fsstats;
rv = ::statvfs(basepaths[i].c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > mfs)
{
mfs = spaceavail;
mfsidx = i;
}
}
}
if(mfs == 0)
return (errno=ENOENT,-1);
paths.push_back(Path(basepaths[mfsidx],
fs::make_path(basepaths[mfsidx],fusepath)));
return 0;
}
int
epmfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t existingmfs;
fsblkcnt_t generalmfs;
string fullpath;
string generalmfspath;
string existingmfspath;
vector<string>::const_iterator iter = basepaths.begin();
vector<string>::const_iterator eiter = basepaths.end();
if(iter == eiter)
return (errno = ENOENT,-1);
existingmfs = 0;
generalmfs = 0;
do
{
int rv;
struct statvfs fsstats;
const string &mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
struct stat st;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > generalmfs)
{
generalmfs = spaceavail;
generalmfspath = mountpoint;
}
fullpath = fs::make_path(mountpoint,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
if(spaceavail > existingmfs)
{
existingmfs = spaceavail;
existingmfspath = mountpoint;
}
}
}
++iter;
}
while(iter != eiter);
if(existingmfspath.empty())
existingmfspath = generalmfspath;
paths.push_back(Path(existingmfspath,
fullpath));
return 0;
}
int
all(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
int rv;
struct stat st;
string fullpath;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
paths.push_back(Path(*iter,fullpath));
}
return paths.empty() ? (errno=ENOENT,-1) : 0;
}
int
rand(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
int rv;
rv = all(basepaths,fusepath,minfreespace,paths);
if(rv == -1)
return -1;
std::random_shuffle(paths.begin(),paths.end());
return 0;
}
}
}; };

44
src/fs.hpp

@ -97,50 +97,6 @@ namespace fs
void glob(const vector<string> &patterns, void glob(const vector<string> &patterns,
vector<string> &strs); vector<string> &strs);
namespace find
{
int invalid(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int all(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int ff(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int ffwp(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int fwfs(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int newest(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int lfs(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int mfs(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int epmfs(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
int rand(const vector<string> &paths,
const string &fusepath,
const size_t minfreespace,
Paths &path);
}
}; };
#endif // __FS_HPP__ #endif // __FS_HPP__

10
src/getattr.cpp

@ -66,11 +66,11 @@ _getattr_controlfile(struct stat &buf)
static static
int int
_getattr(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
struct stat &buf)
_getattr(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
struct stat &buf)
{ {
int rv; int rv;
Paths path; Paths path;

14
src/getxattr.cpp

@ -190,13 +190,13 @@ _getxattr_user_mergerfs(const Path &path,
static static
int int
_getxattr(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname,
char *buf,
const size_t count)
_getxattr(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname,
char *buf,
const size_t count)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;

16
src/ioctl.cpp

@ -82,14 +82,14 @@ _ioctl(const int fd,
#ifdef FUSE_IOCTL_DIR #ifdef FUSE_IOCTL_DIR
static static
int int
_ioctl_dir_base(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int cmd,
void *arg,
const unsigned int flags,
void *data)
_ioctl_dir_base(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int cmd,
void *arg,
const unsigned int flags,
void *data)
{ {
int fd; int fd;
int rv; int rv;

24
src/link.cpp

@ -41,12 +41,12 @@ using mergerfs::Policy;
static static
int int
_single_link(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &base,
const string &oldpath,
const string &newpath)
_single_link(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &base,
const string &oldpath,
const string &newpath)
{ {
int rv; int rv;
const string fulloldpath = fs::make_path(base,oldpath); const string fulloldpath = fs::make_path(base,oldpath);
@ -76,12 +76,12 @@ _single_link(const Policy::FuncPtr searchFunc,
static static
int int
_link(const Policy::FuncPtr searchFunc,
const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
_link(const Policy::Func::Ptr searchFunc,
const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
{ {
int rv; int rv;
int error; int error;

12
src/listxattr.cpp

@ -69,12 +69,12 @@ _listxattr_controlfile(char *list,
static static
int int
_listxattr(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
char *list,
const size_t size)
_listxattr(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
char *list,
const size_t size)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;

12
src/mkdir.cpp

@ -42,12 +42,12 @@ using mergerfs::Policy;
static static
int int
_mkdir(const Policy::FuncPtr searchFunc,
const Policy::FuncPtr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode)
_mkdir(const Policy::Func::Ptr searchFunc,
const Policy::Func::Ptr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode)
{ {
int rv; int rv;
int error; int error;

14
src/mknod.cpp

@ -44,13 +44,13 @@ using mergerfs::Policy;
static static
int int
_mknod(const Policy::FuncPtr searchFunc,
const Policy::FuncPtr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode,
const dev_t dev)
_mknod(const Policy::Func::Ptr searchFunc,
const Policy::Func::Ptr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const mode_t mode,
const dev_t dev)
{ {
int rv; int rv;
int error; int error;

12
src/open.cpp

@ -42,12 +42,12 @@ using mergerfs::Policy;
static static
int int
_open(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int flags,
uint64_t &fh)
_open(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const int flags,
uint64_t &fh)
{ {
int fd; int fd;
int rv; int rv;

2
src/policy.cpp

@ -28,7 +28,7 @@
#include "fs.hpp" #include "fs.hpp"
#include "buildvector.hpp" #include "buildvector.hpp"
#define POLICY(X) (Policy(Policy::Enum::X,#X,fs::find::X))
#define POLICY(X) (Policy(Policy::Enum::X,#X,Policy::Func::X))
namespace mergerfs namespace mergerfs
{ {

30
src/policy.hpp

@ -37,8 +37,6 @@ namespace mergerfs
class Policy class Policy
{ {
public: public:
typedef int (*FuncPtr)(const std::vector<std::string>&,const std::string&,const std::size_t,Paths&);
struct Enum struct Enum
{ {
enum Type enum Type
@ -58,10 +56,30 @@ namespace mergerfs
}; };
}; };
struct Func
{
typedef std::string string;
typedef std::size_t size_t;
typedef std::vector<string> strvec;
typedef int (*Ptr)(const strvec&,const string&,const size_t,Paths&);
static int invalid(const strvec&,const string&,const size_t,Paths&);
static int all(const strvec&,const string&,const size_t,Paths&);
static int epmfs(const strvec&,const string&,const size_t,Paths&);
static int ff(const strvec&,const string&,const size_t,Paths&);
static int ffwp(const strvec&,const string&,const size_t,Paths&);
static int fwfs(const strvec&,const string&,const size_t,Paths&);
static int lfs(const strvec&,const string&,const size_t,Paths&);
static int mfs(const strvec&,const string&,const size_t,Paths&);
static int newest(const strvec&,const string&,const size_t,Paths&);
static int rand(const strvec&,const string&,const size_t,Paths&);
};
private: private:
Enum::Type _enum; Enum::Type _enum;
std::string _str; std::string _str;
FuncPtr _func;
Func::Ptr _func;
public: public:
Policy() Policy()
@ -73,7 +91,7 @@ namespace mergerfs
Policy(const Enum::Type enum_, Policy(const Enum::Type enum_,
const std::string &str_, const std::string &str_,
const FuncPtr func_)
const Func::Ptr func_)
: _enum(enum_), : _enum(enum_),
_str(str_), _str(str_),
_func(func_) _func(func_)
@ -83,14 +101,14 @@ namespace mergerfs
public: public:
operator const Enum::Type() const { return _enum; } operator const Enum::Type() const { return _enum; }
operator const std::string&() const { return _str; } operator const std::string&() const { return _str; }
operator const FuncPtr() const { return _func; }
operator const Func::Ptr() const { return _func; }
operator const Policy*() const { return this; } operator const Policy*() const { return this; }
bool operator==(const Enum::Type enum_) const bool operator==(const Enum::Type enum_) const
{ return _enum == enum_; } { return _enum == enum_; }
bool operator==(const std::string &str_) const bool operator==(const std::string &str_) const
{ return _str == str_; } { return _str == str_; }
bool operator==(const FuncPtr func_) const
bool operator==(const Func::Ptr func_) const
{ return _func == func_; } { return _func == func_; }
bool operator!=(const Policy &r) const bool operator!=(const Policy &r) const

65
src/policy_all.cpp

@ -0,0 +1,65 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::all(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
int rv;
struct stat st;
string fullpath;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
paths.push_back(Path(*iter,fullpath));
}
return paths.empty() ? (errno=ENOENT,-1) : 0;
}
}

104
src/policy_epmfs.cpp

@ -0,0 +1,104 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/statvfs.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::epmfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t existingmfs;
fsblkcnt_t generalmfs;
string fullpath;
string generalmfspath;
string existingmfspath;
vector<string>::const_iterator iter = basepaths.begin();
vector<string>::const_iterator eiter = basepaths.end();
if(iter == eiter)
return (errno = ENOENT,-1);
existingmfs = 0;
generalmfs = 0;
do
{
int rv;
struct statvfs fsstats;
const string &mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
struct stat st;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > generalmfs)
{
generalmfs = spaceavail;
generalmfspath = mountpoint;
}
fullpath = fs::make_path(mountpoint,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
if(spaceavail > existingmfs)
{
existingmfs = spaceavail;
existingmfspath = mountpoint;
}
}
}
++iter;
}
while(iter != eiter);
if(existingmfspath.empty())
existingmfspath = generalmfspath;
paths.push_back(Path(existingmfspath,
fullpath));
return 0;
}
}

70
src/policy_ff.cpp

@ -0,0 +1,70 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string>
#include <vector>
#include "path.hpp"
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::ff(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
paths.push_back(Path(*iter,fullpath));
return 0;
}
}
return -1;
}
}

79
src/policy_ffwp.cpp

@ -0,0 +1,79 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::ffwp(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
Path fallback;
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0)
{
paths.push_back(Path(*iter,fullpath));
return 0;
}
else if(errno == EACCES)
{
fallback.base = *iter;
fallback.full = fullpath;
}
}
if(!fallback.base.empty())
return (paths.push_back(fallback),0);
return -1;
}
}

69
src/policy_fwfs.cpp

@ -0,0 +1,69 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/statvfs.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::fwfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
for(size_t i = 0, size = basepaths.size(); i != size; i++)
{
int rv;
const char *basepath;
struct statvfs fsstats;
basepath = basepaths[i].c_str();
rv = ::statvfs(basepath,&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > minfreespace)
{
paths.push_back(Path(basepath,
fs::make_path(basepath,fusepath)));
return 0;
}
}
}
return mfs(basepaths,fusepath,minfreespace,paths);
}
}

46
src/policy_invalid.cpp

@ -0,0 +1,46 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::invalid(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &rv)
{
return (errno = EINVAL,-1);
}
}

83
src/policy_lfs.cpp

@ -0,0 +1,83 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <unistd.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::lfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t lfs;
const char *lfsstr;
lfs = -1;
lfsstr = NULL;
for(size_t i = 0, size = basepaths.size(); i != size; i++)
{
int rv;
const char *basepath;
struct statvfs fsstats;
basepath = basepaths[i].c_str();
rv = ::statvfs(basepath,&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if((spaceavail > minfreespace) &&
(spaceavail < lfs))
{
lfs = spaceavail;
lfsstr = basepath;
}
}
}
if(lfsstr == NULL)
return Policy::Func::mfs(basepaths,fusepath,minfreespace,paths);
paths.push_back(Path(lfsstr,
fs::make_path(lfsstr,fusepath)));
return 0;
}
}

78
src/policy_mfs.cpp

@ -0,0 +1,78 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/statvfs.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::mfs(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
fsblkcnt_t mfs;
size_t mfsidx;
mfs = 0;
for(size_t i = 0, size = basepaths.size();
i != size;
i++)
{
int rv;
struct statvfs fsstats;
rv = ::statvfs(basepaths[i].c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
if(spaceavail > mfs)
{
mfs = spaceavail;
mfsidx = i;
}
}
}
if(mfs == 0)
return (errno=ENOENT,-1);
paths.push_back(Path(basepaths[mfsidx],
fs::make_path(basepaths[mfsidx],fusepath)));
return 0;
}
}

78
src/policy_newest.cpp

@ -0,0 +1,78 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string>
#include <vector>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::newest(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
time_t newest;
string npath;
vector<string>::const_iterator niter;
newest = 0;
errno = ENOENT;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
string fullpath;
fullpath = fs::make_path(*iter,fusepath);
rv = ::lstat(fullpath.c_str(),&st);
if(rv == 0 && st.st_mtime > newest)
{
newest = st.st_mtime;
niter = iter;
npath = fullpath;
}
}
if(newest)
return (paths.push_back(Path(*niter,npath)),0);
return -1;
}
}

55
src/policy_rand.cpp

@ -0,0 +1,55 @@
/*
The MIT License (MIT)
Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <errno.h>
#include <string>
#include <vector>
#include <algorithm>
#include "policy.hpp"
using std::string;
using std::vector;
using std::size_t;
namespace mergerfs
{
int
Policy::Func::rand(const vector<string> &basepaths,
const string &fusepath,
const size_t minfreespace,
Paths &paths)
{
int rv;
rv = Policy::Func::all(basepaths,fusepath,minfreespace,paths);
if(rv == -1)
return -1;
std::random_shuffle(paths.begin(),paths.end());
return 0;
}
}

12
src/readlink.cpp

@ -41,12 +41,12 @@ using mergerfs::Policy;
static static
int int
_readlink(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
char *buf,
const size_t size)
_readlink(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
char *buf,
const size_t size)
{ {
int rv; int rv;
Paths path; Paths path;

10
src/removexattr.cpp

@ -42,11 +42,11 @@ using mergerfs::Policy;
static static
int int
_removexattr(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname)
_removexattr(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;

22
src/rename.cpp

@ -42,11 +42,11 @@ using mergerfs::Policy;
static static
int int
_single_rename(const Policy::FuncPtr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const Path &oldpath,
const string &newpath)
_single_rename(const Policy::Func::Ptr searchFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const Path &oldpath,
const string &newpath)
{ {
int rv; int rv;
const string fullnewpath = fs::make_path(oldpath.base,newpath); const string fullnewpath = fs::make_path(oldpath.base,newpath);
@ -75,12 +75,12 @@ _single_rename(const Policy::FuncPtr searchFunc,
static static
int int
_rename(const Policy::FuncPtr searchFunc,
const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
_rename(const Policy::Func::Ptr searchFunc,
const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
{ {
int rv; int rv;
int error; int error;

8
src/rmdir.cpp

@ -40,10 +40,10 @@ using mergerfs::Policy;
static static
int int
_rmdir(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath)
_rmdir(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath)
{ {
int rv; int rv;
int error; int error;

16
src/setxattr.cpp

@ -240,14 +240,14 @@ _setxattr_controlfile(config::Config &config,
static static
int int
_setxattr(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname,
const char *attrval,
const size_t attrvalsize,
const int flags)
_setxattr(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const char *attrname,
const char *attrval,
const size_t attrvalsize,
const int flags)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;

10
src/symlink.cpp

@ -40,11 +40,11 @@ using mergerfs::Policy;
static static
int int
_symlink(const Policy::FuncPtr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
_symlink(const Policy::Func::Ptr createFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &oldpath,
const string &newpath)
{ {
int rv; int rv;
int error; int error;

10
src/truncate.cpp

@ -42,11 +42,11 @@ using mergerfs::Policy;
static static
int int
_truncate(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const off_t size)
_truncate(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const off_t size)
{ {
int rv; int rv;
int error; int error;

8
src/unlink.cpp

@ -41,10 +41,10 @@ using mergerfs::Policy;
static static
int int
_unlink(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath)
_unlink(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath)
{ {
int rv; int rv;
int error; int error;

10
src/utimens.cpp

@ -42,11 +42,11 @@ using mergerfs::Policy;
static static
int int
_utimens(const Policy::FuncPtr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const struct timespec ts[2])
_utimens(const Policy::Func::Ptr actionFunc,
const vector<string> &srcmounts,
const size_t minfreespace,
const string &fusepath,
const struct timespec ts[2])
{ {
int rv; int rv;
int error; int error;

Loading…
Cancel
Save