github-mirror/mergerfs
github-mirror/mergerfs
2
0
Fork 0
mirror of https://github.com/trapexit/mergerfs.git synced 2025-02-21 07:08:43 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

separate policies into individual modules

Browse Source
This commit is contained in:
Antonio SJ Musumeci 2015-06-23 22:24:55 -04:00
parent 3c8f12281f
commit 6ca43893ea
35 changed files with 886 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/access.cpp
View File

@ -45,11 +45,11 @@ using mergerfs::Policy;
static
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;
Paths paths;

10
src/chmod.cpp
View File

@ -39,11 +39,11 @@ using mergerfs::Policy;
static
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 error;

12
src/chown.cpp
View File

@ -40,12 +40,12 @@ using mergerfs::Policy;
static
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 error;

16
src/create.cpp
View File

@ -43,14 +43,14 @@ using mergerfs::Policy;
static
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 rv;

338
src/fs.cpp
View File

@ -28,7 +28,6 @@
#include <sstream>
#include <cstdlib>
#include <iterator>
#include <algorithm>
#include <dirent.h>
#include <errno.h>
@ -514,341 +513,4 @@ namespace fs
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
View File

@ -97,50 +97,6 @@ namespace fs
void glob(const vector<string> &patterns,
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__

10
src/getattr.cpp
View File

@ -66,11 +66,11 @@ _getattr_controlfile(struct stat &buf)
static
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;
Paths path;

14
src/getxattr.cpp
View File

@ -190,13 +190,13 @@ _getxattr_user_mergerfs(const Path &path,
static
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
int rv;

16
src/ioctl.cpp
View File

@ -82,14 +82,14 @@ _ioctl(const int fd,
#ifdef FUSE_IOCTL_DIR
static
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 rv;

24
src/link.cpp
View File

@ -41,12 +41,12 @@ using mergerfs::Policy;
static
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;
const string fulloldpath = fs::make_path(base,oldpath);
@ -76,12 +76,12 @@ _single_link(const Policy::FuncPtr searchFunc,
static
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 error;

12
src/listxattr.cpp
View File

@ -69,12 +69,12 @@ _listxattr_controlfile(char *list,
static
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
int rv;

12
src/mkdir.cpp
View File

@ -42,12 +42,12 @@ using mergerfs::Policy;
static
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 error;

14
src/mknod.cpp
View File

@ -44,13 +44,13 @@ using mergerfs::Policy;
static
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 error;

12
src/open.cpp
View File

@ -42,12 +42,12 @@ using mergerfs::Policy;
static
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 rv;

2
src/policy.cpp
View File

@ -28,7 +28,7 @@
#include "fs.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
{

30
src/policy.hpp
View File

@ -37,8 +37,6 @@ namespace mergerfs
class Policy
{
public:
typedef int (*FuncPtr)(const std::vector<std::string>&,const std::string&,const std::size_t,Paths&);
struct Enum
{
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:
Enum::Type _enum;
std::string _str;
FuncPtr _func;
Func::Ptr _func;
public:
Policy()
@ -73,7 +91,7 @@ namespace mergerfs
Policy(const Enum::Type enum_,
const std::string &str_,
const FuncPtr func_)
const Func::Ptr func_)
: _enum(enum_),
_str(str_),
_func(func_)
@ -83,14 +101,14 @@ namespace mergerfs
public:
operator const Enum::Type() const { return _enum; }
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; }
bool operator==(const Enum::Type enum_) const
{ return _enum == enum_; }
bool operator==(const std::string &str_) const
{ return _str == str_; }
bool operator==(const FuncPtr func_) const
bool operator==(const Func::Ptr func_) const
{ return _func == func_; }
bool operator!=(const Policy &r) const

65
src/policy_all.cpp Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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 Normal file
View File

@ -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
View File

@ -41,12 +41,12 @@ using mergerfs::Policy;
static
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;
Paths path;

10
src/removexattr.cpp
View File

@ -42,11 +42,11 @@ using mergerfs::Policy;
static
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
int rv;

22
src/rename.cpp
View File

@ -42,11 +42,11 @@ using mergerfs::Policy;
static
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;
const string fullnewpath = fs::make_path(oldpath.base,newpath);
@ -75,12 +75,12 @@ _single_rename(const Policy::FuncPtr searchFunc,
static
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 error;

8
src/rmdir.cpp
View File

@ -40,10 +40,10 @@ using mergerfs::Policy;
static
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 error;

16
src/setxattr.cpp
View File

@ -240,14 +240,14 @@ _setxattr_controlfile(config::Config &config,
static
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
int rv;

10
src/symlink.cpp
View File

@ -40,11 +40,11 @@ using mergerfs::Policy;
static
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 error;

10
src/truncate.cpp
View File

@ -42,11 +42,11 @@ using mergerfs::Policy;
static
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 error;

8
src/unlink.cpp
View File

@ -41,10 +41,10 @@ using mergerfs::Policy;
static
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 error;

10
src/utimens.cpp
View File

@ -42,11 +42,11 @@ using mergerfs::Policy;
static
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 error;