Browse Source

rework policy code

pull/36/head
Antonio SJ Musumeci 10 years ago
parent
commit
aab90b0503
  1. 72
      README.md
  2. 15
      src/access.cpp
  3. 51
      src/buildmap.hpp
  4. 51
      src/buildvector.hpp
  5. 70
      src/category.cpp
  6. 98
      src/category.hpp
  7. 8
      src/chmod.cpp
  8. 8
      src/chown.cpp
  9. 15
      src/config.cpp
  10. 7
      src/config.hpp
  11. 27
      src/create.cpp
  12. 535
      src/fs.cpp
  13. 83
      src/fs.hpp
  14. 12
      src/getattr.cpp
  15. 25
      src/getxattr.cpp
  16. 8
      src/link.cpp
  17. 34
      src/listxattr.cpp
  18. 1
      src/mergerfs.cpp
  19. 24
      src/mkdir.cpp
  20. 24
      src/mknod.cpp
  21. 14
      src/open.cpp
  22. 7
      src/option_parser.cpp
  23. 251
      src/policy.cpp
  24. 164
      src/policy.hpp
  25. 12
      src/readlink.cpp
  26. 8
      src/removexattr.cpp
  27. 14
      src/rename.cpp
  28. 8
      src/rmdir.cpp
  29. 79
      src/setxattr.cpp
  30. 10
      src/symlink.cpp
  31. 2
      src/test.cpp
  32. 8
      src/truncate.cpp
  33. 8
      src/unlink.cpp
  34. 8
      src/utimens.cpp
  35. 39
      src/write.cpp

72
README.md

@ -10,36 +10,30 @@ Why create mergerfs when those exist? mhddfs isn't really maintained or flexible
Policies Policies
======== ========
Filesystem calls are broken up into 4 categories of policies: search, action, create, and none.
Below shows each policy class, the FUSE calls they impact, and the policy names.
#### Policy classifications ####
| Class | FUSE calls | Policies |
|-------|------------|----------|
| search | access, getattr, getxattr, listxattr, open, readlink | First Found (ff), First Found w/ Permission (ffwp), Newest (newest) |
| action | chmod, link, removexattr, rmdir, setxattr, truncate, unlink, utimens | First Found (ff), First Found w/ Permission (ffwp), Newest (newest), All Found (all) |
| create | create, mkdir, mknod | Existing Path (ep), Most Free Space (mfs), Existing Path Most Free Space (epmfs), Random (rand) |
| none | fallocate, fsync, ftruncate, ioctl, read, readdir, rename, statfs, symlink, write, release | |
#### Descriptions ####
| Class/Policy | Description |
Filesystem calls are broken up into 4 functional categories: search, action, create, and none. These categories can be assigned a policy which dictates how [mergerfs](http://github.com/trapexit/mergerfs) behaves while when action on the filesystem. Any policy can be assigned to a category though some aren't terribly practical. For instance: rand (Random) may be useful for **create** but could lead to very odd behavior if used for **search** or **action**. Since the input for any policy is the source mounts and fusepath and the output a vector of targets the choice was made to simplify the implementation and allow a policies usage in any category. **NOTE:** In any policy which can return more than one location (currently only **all**) the first value will be used in **search** and **create** policies since they can only ever act on 1 filepath.
#### Functional classifications ####
| Class | FUSE calls |
|-------|------------|
| search | access, getattr, getxattr, listxattr, open, readlink |
| action | chmod, link, removexattr, rmdir, setxattr, truncate, unlink, utimens |
| create | create, mkdir, mknod |
| none | fallocate, fsync, ftruncate, ioctl, read, readdir, rename, statfs, symlink, write, release |
#### Policy descriptions ####
| Policy | Description |
|--------------|-------------| |--------------|-------------|
| search/ff | Given the order the paths were provided at mount time act on the first one found (regardless if stat would return EACCES). |
| search/ffwp | Given the order the paths were provided at mount time act on the first one found which you have access (stat does not error with EACCES). |
| search/newest | If multiple files exist return the one with the most recent mtime. |
| action/ff | (same as search/ff) |
| action/ffwp | (same as search/ffwp) |
| action/newest | (same as search/newest) |
| action/all | Attempt to apply the call to each file found. If any sub call succeeds the entire operation succeeds and other errors ignored. If all fail then the last error is reported. |
| create/ep | Choose the first path which is found. |
| create/mfs | Assuming the path is found to exist (ENOENT would not be returned) use the drive with the most free space available. |
| create/epmfs | If the path exists in multiple locations use the one with the most free space. Otherwise fall back to mfs. |
| create/rand | Pick a destination at random. Again the dirname of the full path must exist somewhere. |
| ff (first found) | Given the order the paths were provided at mount time act on the first one found (regardless if stat would return EACCES). |
| ffwp (first found w/ permissions) | Given the order the paths were provided at mount time act on the first one found which you have access (stat does not error with EACCES). |
| newest (newest file) | If multiple files exist return the one with the most recent mtime. |
| all (all files found) | Attempt to apply the call to each file found. If any sub call succeeds the entire operation succeeds and other errors ignored. If all fail then the last error is reported. |
| mfs (most free space) | Assuming the path is found to exist (ENOENT would not be returned) use the drive with the most free space available. |
| epmfs (existing path, most free space) | If the path exists in multiple locations use the one with the most free space. Otherwise fall back to mfs. |
| rand (random) | Pick a destination at random. Again the dirname of the full path must exist somewhere. |
#### statvfs #### #### statvfs ####
Since we aren't trying to stripe data across drives the free space of the mountpoint is just that of the source mount with the most free space at the moment.
Since we aren't trying to stripe data across drives or move them should ENOSPC be return on a write the free space of the mountpoint is just that of the source mount with the most free space at the moment.
**NOTE:** create is really a search for existence and then create. The 'search' policy applies to the first part. If the [dirname](http://linux.die.net/man/3/dirname) of the full path is not found to exist [ENOENT](http://linux.die.net/man/3/errno) is returned. **NOTE:** create is really a search for existence and then create. The 'search' policy applies to the first part. If the [dirname](http://linux.die.net/man/3/dirname) of the full path is not found to exist [ENOENT](http://linux.die.net/man/3/errno) is returned.
@ -50,17 +44,17 @@ Usage
$ mergerfs -o create=epmfs,search=ff,action=ff <mountpoint> <dir0>:<dir1>:<dir2> $ mergerfs -o create=epmfs,search=ff,action=ff <mountpoint> <dir0>:<dir1>:<dir2>
``` ```
| Option | Values | Default |
|--------|--------|---------|
| search | ff, ffwp, newest | ff |
| action | ff, ffwp, newest, all | ff |
| create | ep, mfs, epmfs, rand | epmfs |
| Option | Default |
|--------|--------|
| search | ff |
| action | ff |
| create | epmfs |
Building Building
======== ========
Need to install FUSE development libraries (libfuse-dev).
Optionally need libattr1 (libattr1-dev).
* Need to install FUSE development libraries (libfuse-dev).
* Optionally need libattr1 (libattr1-dev).
``` ```
@ -77,7 +71,7 @@ Runtime Settings
<mountpoint>/.mergerfs <mountpoint>/.mergerfs
``` ```
There is a pseudo file available at the mountpoint which currently allows for the runtime modification of policies. The file will not show up in readdirs but can be stat'ed, read, and writen. Most other calls will fail with EPERM, EINVAL, or whatever may be appropriate for that call. Anything not understood while writing will result in EINVAL otherwise the number of bytes written will be returned.
There is a pseudo file available at the mountpoint which allows for the runtime modification of policies. The file will not show up in readdirs but can be stat'ed, read, and writen. Most other calls will fail with EPERM, EINVAL, or whatever may be appropriate for that call. Anything not understood while writing will result in EINVAL otherwise the number of bytes written will be returned.
Reading the file will result in a newline delimited list of current settings as followed: Reading the file will result in a newline delimited list of current settings as followed:
@ -106,15 +100,15 @@ If xattrs has been enabled you can also use [{list,get,set}xattrs](http://linux.
``` ```
[trapexit:/tmp/mount] $ attr -l .mergerfs [trapexit:/tmp/mount] $ attr -l .mergerfs
Attribute "mergerfs.action" has a 3 byte value for .mergerfs
Attribute "mergerfs.create" has a 6 byte value for .mergerfs
Attribute "mergerfs.search" has a 3 byte value for .mergerfs
Attribute "mergerfs.action" has a 2 byte value for .mergerfs
Attribute "mergerfs.create" has a 5 byte value for .mergerfs
Attribute "mergerfs.search" has a 2 byte value for .mergerfs
[trapexit:/tmp/mount] $ attr -g mergerfs.action .mergerfs [trapexit:/tmp/mount] $ attr -g mergerfs.action .mergerfs
Attribute "mergerfs.action" had a 3 byte value for .mergerfs:
Attribute "mergerfs.action" had a 2 byte value for .mergerfs:
ff ff
[trapexit:/tmp/mount] 1 $ attr -s mergerfs.action -V ffwp .mergerfs [trapexit:/tmp/mount] 1 $ attr -s mergerfs.action -V ffwp .mergerfs
Attribute "mergerfs.action" set to a 3 byte value for .mergerfs:
Attribute "mergerfs.action" set to a 4 byte value for .mergerfs:
ffwp ffwp
``` ```

15
src/access.cpp

@ -45,19 +45,19 @@ using mergerfs::Policy;
static static
int int
_access(const Policy::Search::Func searchFunc,
_access(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const int mask) const int mask)
{ {
int rv; int rv;
string path;
fs::PathVector path;
path = searchFunc(srcmounts,fusepath).full;
searchFunc(srcmounts,fusepath,path);
if(path.empty()) if(path.empty())
return -ENOENT; return -ENOENT;
rv = ::eaccess(path.c_str(),mask);
rv = ::eaccess(path[0].full.c_str(),mask);
return ((rv == -1) ? -errno : 0); return ((rv == -1) ? -errno : 0);
} }
@ -74,9 +74,12 @@ namespace mergerfs
const config::Config &config = config::get(); const config::Config &config = config::get();
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return 0;
return _access(*config.search,
config.srcmounts,
"/",
mask);
return _access(config.policy.search,
return _access(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
mask); mask);

51
src/buildmap.hpp

@ -0,0 +1,51 @@
/*
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 <algorithm>
template<typename K,typename V>
class buildmap
{
public:
buildmap(const K &key,
const V &val)
{
_map.insert(std::make_pair(key,val));
}
buildmap<K,V> &operator()(const K &key,
const V &val)
{
_map.insert(std::make_pair(key,val));
return *this;
}
operator std::map<K,V>()
{
return _map;
}
private:
std::map<K,V> _map;
};

51
src/buildvector.hpp

@ -0,0 +1,51 @@
/*
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 <algorithm>
template<typename V, bool SORT = false>
class buildvector
{
public:
buildvector(const V &val)
{
_vector.push_back(val);
}
buildvector<V,SORT> &operator()(const V &val)
{
_vector.push_back(val);
return *this;
}
operator std::vector<V>()
{
if(SORT == true)
std::sort(_vector.begin(),_vector.end());
return _vector;
}
private:
std::vector<V> _vector;
};

70
src/category.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 <string>
#include <vector>
#include "category.hpp"
#include "buildvector.hpp"
#define CATEGORY(X) Category(Category::Enum::X,#X)
namespace mergerfs
{
const std::vector<Category> Category::_categories_ =
buildvector<Category,true>
(CATEGORY(invalid))
(CATEGORY(action))
(CATEGORY(create))
(CATEGORY(search));
const Category * const Category::categories = &_categories_[1];
const Category &Category::invalid = Category::categories[Category::Enum::invalid];
const Category &Category::action = Category::categories[Category::Enum::action];
const Category &Category::create = Category::categories[Category::Enum::create];
const Category &Category::search = Category::categories[Category::Enum::search];
const Category&
Category::find(const std::string str)
{
for(int i = Enum::BEGIN; i != Enum::END; ++i)
{
if(categories[i] == str)
return categories[i];
}
return invalid;
}
const Category&
Category::find(const Category::Enum::Type i)
{
if(i >= Category::Enum::BEGIN &&
i < Category::Enum::END)
return categories[i];
return invalid;
}
}

98
src/category.hpp

@ -0,0 +1,98 @@
/*
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.
*/
#ifndef __CATEGORY_HPP__
#define __CATEGORY_HPP__
#include <string>
#include <vector>
namespace mergerfs
{
class Category
{
public:
struct Enum
{
enum Type
{
invalid = -1,
BEGIN = 0,
action = BEGIN,
create,
search,
END
};
};
private:
Enum::Type _enum;
std::string _str;
public:
Category()
: _enum(invalid),
_str(invalid)
{
}
Category(const Enum::Type enum_,
const std::string str_)
: _enum(enum_),
_str(str_)
{
}
public:
operator const Enum::Type() const { return _enum; }
operator const std::string() const { return _str; }
operator const Category*() const { return this; }
bool operator==(const std::string str_) const
{ return _str == str_; }
bool operator==(const Enum::Type enum_) const
{ return _enum == enum_; }
bool operator!=(const Category &r) const
{ return _enum != r._enum; }
bool operator<(const Category &r) const
{ return _enum < r._enum; }
public:
static const Category &find(const std::string);
static const Category &find(const Enum::Type);
public:
static const std::vector<Category> _categories_;
static const Category * const categories;
static const Category &invalid;
static const Category &action;
static const Category &create;
static const Category &search;
};
}
#endif

8
src/chmod.cpp

@ -39,14 +39,14 @@ using mergerfs::Policy;
static static
int int
_chmod(const Policy::Action::Func searchFunc,
_chmod(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const mode_t mode) const mode_t mode)
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -54,7 +54,7 @@ _chmod(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::chmod(i->full.c_str(),mode); rv &= ::chmod(i->full.c_str(),mode);
@ -79,7 +79,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EPERM; return -EPERM;
return _chmod(config.policy.action,
return _chmod(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
mode); mode);

8
src/chown.cpp

@ -40,7 +40,7 @@ using mergerfs::Policy;
static static
int int
_chown(const Policy::Action::Func searchFunc,
_chown(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const uid_t uid, const uid_t uid,
@ -48,7 +48,7 @@ _chown(const Policy::Action::Func searchFunc,
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -56,7 +56,7 @@ _chown(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::lchown(i->full.c_str(),uid,gid); rv &= ::lchown(i->full.c_str(),uid,gid);
@ -82,7 +82,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EPERM; return -EPERM;
return _chown(config.policy.action,
return _chown(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
uid, uid,

15
src/config.cpp

@ -36,9 +36,16 @@ namespace mergerfs
namespace config namespace config
{ {
Config::Config() Config::Config()
: controlfile("/.mergerfs"),
: action(policies[0]),
create(policies[1]),
search(policies[2]),
controlfile("/.mergerfs"),
testmode(false) testmode(false)
{ {
action = &Policy::ff;
create = &Policy::epmfs;
search = &Policy::ff;
time_t now = time(NULL); time_t now = time(NULL);
controlfilestat.st_dev = 0; controlfilestat.st_dev = 0;
@ -61,9 +68,9 @@ namespace mergerfs
{ {
std::stringstream ss; std::stringstream ss;
ss << "action=" << policy.action.str() << std::endl
<< "create=" << policy.create.str() << std::endl
<< "search=" << policy.search.str() << std::endl;
ss << "action=" << (std::string)*action << std::endl
<< "create=" << (std::string)*create << std::endl
<< "search=" << (std::string)*search << std::endl;
return ss.str(); return ss.str();
} }

7
src/config.hpp

@ -31,6 +31,7 @@
#include <vector> #include <vector>
#include "policy.hpp" #include "policy.hpp"
#include "category.hpp"
namespace mergerfs namespace mergerfs
{ {
@ -47,7 +48,11 @@ namespace mergerfs
public: public:
std::string destmount; std::string destmount;
std::vector<std::string> srcmounts; std::vector<std::string> srcmounts;
Policy policy;
const Policy *policies[Category::Enum::END];
const Policy *&action;
const Policy *&create;
const Policy *&search;
const std::string controlfile; const std::string controlfile;
struct stat controlfilestat; struct stat controlfilestat;

27
src/create.cpp

@ -54,8 +54,8 @@ _create_controlfile(uint64_t &fh)
static static
int int
_create(const Policy::Search::Func searchFunc,
const Policy::Create::Func createPathFunc,
_create(const fs::SearchFunc searchFunc,
const fs::SearchFunc createPathFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const mode_t mode, const mode_t mode,
@ -65,19 +65,22 @@ _create(const Policy::Search::Func searchFunc,
int fd; int fd;
string path; string path;
string dirname; string dirname;
fs::Path createpath;
fs::Path existingpath;
fs::PathVector createpath;
fs::PathVector existingpath;
dirname = fs::dirname(fusepath); dirname = fs::dirname(fusepath);
existingpath = searchFunc(srcmounts,dirname);
if(existingpath.base.empty())
searchFunc(srcmounts,dirname,existingpath);
if(existingpath.empty())
return -ENOENT; return -ENOENT;
createpath = createPathFunc(srcmounts,dirname);
if(createpath.base != existingpath.base)
fs::clonepath(existingpath.base,createpath.base,dirname);
createPathFunc(srcmounts,dirname,createpath);
if(createpath.empty())
return -ENOSPC;
path = fs::make_path(createpath.base,fusepath);
if(createpath[0].base != existingpath[0].base)
fs::clonepath(existingpath[0].base,createpath[0].base,dirname);
path = fs::make_path(createpath[0].base,fusepath);
fd = ::open(path.c_str(),flags,mode); fd = ::open(path.c_str(),flags,mode);
if(fd == -1) if(fd == -1)
@ -103,8 +106,8 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return _create_controlfile(fileinfo->fh); return _create_controlfile(fileinfo->fh);
return _create(config.policy.search,
config.policy.create,
return _create(*config.search,
*config.create,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
mode, mode,

535
src/fs.cpp

@ -136,12 +136,12 @@ namespace fs
string string
make_path(const string base, make_path(const string base,
const string suffix)
const string fusepath)
{ {
if(*base.rbegin() == '/' || if(*base.rbegin() == '/' ||
*suffix.rbegin() == '/')
return base + suffix;
return base + '/' + suffix;
*fusepath.rbegin() == '/')
return base + fusepath;
return base + '/' + fusepath;
} }
bool bool
@ -153,11 +153,10 @@ namespace fs
iter = begin; iter != end; ++iter) iter = begin; iter != end; ++iter)
{ {
int rv; int rv;
struct stat st;
string path; string path;
path = make_path(*iter,fusepath);
rv = ::lstat(path.c_str(),&st);
path = fs::make_path(*iter,fusepath);
rv = ::eaccess(path.c_str(),F_OK);
if(rv == 0) if(rv == 0)
return true; return true;
} }
@ -174,282 +173,6 @@ namespace fs
fusepath); fusepath);
} }
Path
find_first(vector<string>::const_iterator beginiter,
vector<string>::const_iterator enditer,
const string suffix)
{
for(vector<string>::const_iterator
iter = beginiter; iter != enditer; ++iter)
{
int rv;
struct stat st;
string path;
path = fs::make_path(*iter,suffix);
rv = ::lstat(path.c_str(),&st);
if(rv == 0 || (rv == -1 && errno == EACCES))
return Path(*iter,path);
}
return Path();
}
Path
find_first(const vector<string> &basepaths,
const string suffix)
{
return find_first(basepaths.begin(),
basepaths.end(),
suffix);
}
void
find_first(const vector<string> &basepaths,
const string suffix,
vector<Path> &paths)
{
paths.push_back(find_first(basepaths,suffix));
}
Path
find_first_with_permission(vector<string>::const_iterator beginiter,
vector<string>::const_iterator enditer,
const string suffix)
{
for(vector<string>::const_iterator
iter = beginiter; iter != enditer; ++iter)
{
int rv;
string path;
path = make_path(*iter,suffix);
rv = ::eaccess(path.c_str(),R_OK);
if(rv == 0)
return Path(*iter,path);
rv = ::eaccess(path.c_str(),W_OK);
if(rv == 0)
return Path(*iter,path);
rv = ::eaccess(path.c_str(),X_OK);
if(rv == 0)
return Path(*iter,path);
}
return Path();
}
Path
find_first_with_permission(const vector<string> &basepaths,
const string suffix)
{
return find_first_with_permission(basepaths.begin(),
basepaths.end(),
suffix);
}
void
find_first_with_permission(const vector<string> &basepaths,
const string suffix,
vector<Path> &paths)
{
paths.push_back(find_first_with_permission(basepaths,suffix));
}
Path
find_newest(vector<string>::const_iterator beginiter,
vector<string>::const_iterator enditer,
const string suffix)
{
time_t newest;
string npath;
vector<string>::const_iterator niter;
newest = 0;
for(vector<string>::const_iterator
iter = beginiter; iter != enditer; ++iter)
{
int rv;
struct stat st;
const string path = make_path(*iter,suffix);
rv = ::lstat(path.c_str(),&st);
if(rv == 0 && st.st_mtime > newest)
{
newest = st.st_mtime;
niter = iter;
npath = path;
}
}
if(newest)
return Path(*niter,npath);
return Path();
}
Path
find_newest(const vector<string> &basepaths,
const string suffix)
{
return find_newest(basepaths.begin(),
basepaths.end(),
suffix);
}
void
find_newest(const vector<string> &basepaths,
const string suffix,
vector<Path> &paths)
{
paths.push_back(find_newest(basepaths,suffix));
}
void
find_all(const vector<string> &basepaths,
const string suffix,
vector<Path> &paths)
{
for(vector<string>::const_iterator
i = basepaths.begin(), ei = basepaths.end(); i != ei; ++i)
{
int rv;
struct stat st;
string path;
path = fs::make_path(*i,suffix);
rv = ::lstat(path.c_str(),&st);
if(rv == 0 || (rv == -1 && errno == EACCES))
paths.push_back(Path(*i,path));
}
}
Path
find_mfs(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
const string fusepath)
{
fsblkcnt_t mfs = 0;
string mfspath;
string fullmfspath;
for(;iter != enditer; ++iter)
{
int rv;
struct statvfs fsstats;
const string mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_bsize * fsstats.f_bavail);
if(spaceavail > mfs)
{
mfs = spaceavail;
mfspath = mountpoint;
}
}
}
fullmfspath = make_path(mfspath,fusepath);
return Path(mfspath,fullmfspath);
}
Path
find_mfs(const vector<string> &paths,
const string fusepath)
{
return find_mfs(paths.begin(),
paths.end(),
fusepath);
}
Path
find_mfs_existing(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
const string fusepath)
{
fsblkcnt_t existingmfs = 0;
fsblkcnt_t generalmfs = 0;
string path;
string generalmfspath;
string existingmfspath;
do
{
int rv;
struct statvfs fsstats;
const string mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
struct stat filestats;
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_bsize * fsstats.f_bavail);
if(spaceavail > generalmfs)
{
generalmfs = spaceavail;
generalmfspath = mountpoint;
}
path = make_path(mountpoint,fusepath);
rv = ::lstat(path.c_str(),&filestats);
if(rv == 0)
{
if(spaceavail > existingmfs)
{
existingmfs = spaceavail;
existingmfspath = mountpoint;
}
}
}
++iter;
}
while(iter != enditer);
if(existingmfspath.empty())
existingmfspath = generalmfspath;
return Path(existingmfspath,path);
}
Path
find_mfs_existing(const vector<string> &paths,
const string fusepath)
{
return find_mfs_existing(paths.begin(),
paths.end(),
fusepath);
}
Path
find_random(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
string fusepath)
{
string randombasepath;
string randomfullpath;
randombasepath = *random_element(iter,enditer);
randomfullpath = make_path(randombasepath,fusepath);
return Path(randombasepath,randomfullpath);
}
Path
find_random(const vector<string> &paths,
const string fusepath)
{
return find_random(paths.begin(),
paths.end(),
fusepath);
}
int int
listxattr(const string path, listxattr(const string path,
vector<char> &attrs) vector<char> &attrs)
@ -701,7 +424,7 @@ namespace fs
return -1; return -1;
} }
frompath = make_path(fromsrc,relative);
frompath = fs::make_path(fromsrc,relative);
rv = ::stat(frompath.c_str(),&st); rv = ::stat(frompath.c_str(),&st);
if(rv == -1) if(rv == -1)
@ -709,7 +432,7 @@ namespace fs
else if(!S_ISDIR(st.st_mode)) else if(!S_ISDIR(st.st_mode))
return (errno = ENOTDIR,-1); return (errno = ENOTDIR,-1);
topath = make_path(tosrc,relative);
topath = fs::make_path(tosrc,relative);
rv = ::mkdir(topath.c_str(),st.st_mode); rv = ::mkdir(topath.c_str(),st.st_mode);
if(rv == -1) if(rv == -1)
return -1; return -1;
@ -729,4 +452,246 @@ namespace fs
return (errno = 0); return (errno = 0);
} }
namespace find
{
void
invalid(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
return;
}
void
ff(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
string path;
path = fs::make_path(*iter,fusepath);
rv = ::eaccess(path.c_str(),F_OK);
if(rv == 0)
{
paths.push_back(Path(*iter,path));
return;
}
}
return;
}
void
ffwp(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
Path fallback;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
string path;
path = fs::make_path(*iter,fusepath);
rv = ((::eaccess(path.c_str(),R_OK) == 0) ||
(::eaccess(path.c_str(),X_OK) == 0) ||
(::eaccess(path.c_str(),W_OK) == 0));
if(rv)
{
paths.push_back(Path(*iter,path));
return;
}
else if(errno == EACCES)
{
fallback.base = *iter;
fallback.full = path;
}
}
if(!fallback.base.empty())
paths.push_back(fallback);
return;
}
void
newest(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
time_t newest;
string npath;
vector<string>::const_iterator niter;
newest = 0;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct stat st;
const string path = fs::make_path(*iter,fusepath);
rv = ::lstat(path.c_str(),&st);
if(rv == 0 && st.st_mtime > newest)
{
newest = st.st_mtime;
niter = iter;
npath = path;
}
}
if(newest)
paths.push_back(Path(*niter,npath));
return;
}
void
all(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
string path;
path = fs::make_path(*iter,fusepath);
rv = ::eaccess(path.c_str(),F_OK);
if(rv == 0)
paths.push_back(Path(*iter,path));
}
return;
}
void
mfs(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
fsblkcnt_t mfs = 0;
string mfspath;
string fullmfspath;
for(vector<string>::const_iterator
iter = basepaths.begin(), eiter = basepaths.end();
iter != eiter;
++iter)
{
int rv;
struct statvfs fsstats;
const string mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_bsize * fsstats.f_bavail);
if(spaceavail > mfs)
{
mfs = spaceavail;
mfspath = mountpoint;
}
}
}
fullmfspath = fs::make_path(mfspath,fusepath);
paths.push_back(Path(mfspath,fullmfspath));
return;
}
void
epmfs(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
fsblkcnt_t existingmfs = 0;
fsblkcnt_t generalmfs = 0;
string path;
string generalmfspath;
string existingmfspath;
vector<string>::const_iterator iter = basepaths.begin();
vector<string>::const_iterator eiter = basepaths.end();
do
{
int rv;
struct statvfs fsstats;
const string mountpoint = *iter;
rv = ::statvfs(mountpoint.c_str(),&fsstats);
if(rv == 0)
{
fsblkcnt_t spaceavail;
spaceavail = (fsstats.f_bsize * fsstats.f_bavail);
if(spaceavail > generalmfs)
{
generalmfs = spaceavail;
generalmfspath = mountpoint;
}
path = fs::make_path(mountpoint,fusepath);
rv = ::eaccess(path.c_str(),F_OK);
if(rv == 0)
{
if(spaceavail > existingmfs)
{
existingmfs = spaceavail;
existingmfspath = mountpoint;
}
}
}
++iter;
}
while(iter != eiter);
if(existingmfspath.empty())
existingmfspath = generalmfspath;
paths.push_back(Path(existingmfspath,path));
return;
}
void
rand(const vector<string> &basepaths,
const string fusepath,
PathVector &paths)
{
string randombasepath;
string randomfullpath;
randombasepath = *random_element(basepaths.begin(),
basepaths.end());
randomfullpath = fs::make_path(randombasepath,
fusepath);
paths.push_back(Path(randombasepath,randomfullpath));
}
}
}; };

83
src/fs.hpp

@ -48,8 +48,8 @@ namespace fs
string full; string full;
}; };
typedef fs::Path (*SearchFunc)(const vector<string>&,const string);
typedef void (*VecSearchFunc)(const vector<string>&,const string,vector<Path>&);
typedef vector<Path> PathVector;
typedef void (*SearchFunc)(const vector<string>&,const string,PathVector&);
string dirname(const string path); string dirname(const string path);
string basename(const string path); string basename(const string path);
@ -65,57 +65,6 @@ namespace fs
bool path_exists(const vector<string> &srcmounts, bool path_exists(const vector<string> &srcmounts,
const string fusepath); const string fusepath);
Path find_first(vector<string>::const_iterator begin,
vector<string>::const_iterator end,
const string fusepath);
Path find_first(const vector<string> &paths,
const string fusepath);
void find_first(const vector<string> &paths,
const string fusepath,
vector<Path> &rv);
Path find_first_with_permission(vector<string>::const_iterator begin,
vector<string>::const_iterator end,
const string fusepath);
Path find_first_with_permission(const vector<string> &paths,
const string fusepath);
void find_first_with_permission(const vector<string> &paths,
const string fusepath,
vector<Path> &rv);
Path find_newest(vector<string>::const_iterator begin,
vector<string>::const_iterator end,
const string fusepath);
Path find_newest(const vector<string> &paths,
const string fusepath);
void find_newest(const vector<string> &paths,
const string fusepath,
vector<Path> &rv);
void find_all(const vector<string> &paths,
const string fusepath,
vector<Path> &rv);
Path find_mfs(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
const string fusepath);
Path find_mfs(const vector<string> &paths,
const string fusepath);
Path find_mfs_existing(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
const string fusepath);
Path find_mfs_existing(const vector<string> &paths,
const string fusepath);
Path find_random(vector<string>::const_iterator iter,
vector<string>::const_iterator enditer,
const string fusepath);
Path find_random(const vector<string> &paths,
const string fusepath);
int clonepath(const string srcfrom, int clonepath(const string srcfrom,
const string srcto, const string srcto,
const string relative); const string relative);
@ -154,6 +103,34 @@ namespace fs
int copyattr(const string from, int copyattr(const string from,
const string to); const string to);
namespace find
{
void invalid(const vector<string> &basepaths,
const string fusepath,
PathVector &paths);
void ff(const vector<string> &basepaths,
const string fusepath,
PathVector &paths);
void ffwp(const vector<string> &paths,
const string fusepath,
PathVector &rv);
void newest(const vector<string> &paths,
const string fusepath,
PathVector &rv);
void all(const vector<string> &paths,
const string fusepath,
PathVector &rv);
void mfs(const vector<string> &paths,
const string fusepath,
PathVector &rv);
void epmfs(const vector<string> &paths,
const string fusepath,
PathVector &rv);
void rand(const vector<string> &paths,
const string fusepath,
PathVector &rv);
}
}; };
#endif // __FS_HPP__ #endif // __FS_HPP__

12
src/getattr.cpp

@ -43,19 +43,19 @@ using mergerfs::Policy;
static static
int int
_getattr(const Policy::Search::Func searchFunc,
_getattr(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
struct stat &buf) struct stat &buf)
{ {
int rv; int rv;
string path;
fs::PathVector paths;
path = searchFunc(srcmounts,fusepath).full;
if(path.empty())
searchFunc(srcmounts,fusepath,paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
rv = ::lstat(path.c_str(),&buf);
rv = ::lstat(paths[0].full.c_str(),&buf);
return ((rv == -1) ? -errno : 0); return ((rv == -1) ? -errno : 0);
} }
@ -74,7 +74,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return (*buf = config.controlfilestat,0); return (*buf = config.controlfilestat,0);
return _getattr(config.policy.search,
return _getattr(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
*buf); *buf);

25
src/getxattr.cpp

@ -38,10 +38,11 @@
using std::string; using std::string;
using std::vector; using std::vector;
using mergerfs::Policy; using mergerfs::Policy;
using namespace mergerfs::config;
static static
int int
_getxattr_controlfile(const Policy &policy,
_getxattr_controlfile(const Config &config,
const string attrname, const string attrname,
char *buf, char *buf,
const size_t count) const size_t count)
@ -51,16 +52,16 @@ _getxattr_controlfile(const Policy &policy,
string attrvalue; string attrvalue;
if(attrname == "user.mergerfs.action") if(attrname == "user.mergerfs.action")
attrvalue = policy.action.str();
attrvalue = (std::string)*config.action;
else if(attrname == "user.mergerfs.create") else if(attrname == "user.mergerfs.create")
attrvalue = policy.create.str();
attrvalue = (std::string)*config.create;
else if(attrname == "user.mergerfs.search") else if(attrname == "user.mergerfs.search")
attrvalue = policy.search.str();
attrvalue = (std::string)*config.search;
if(attrvalue.empty()) if(attrvalue.empty())
return -ENOATTR; return -ENOATTR;
len = attrvalue.size() + 1;
len = attrvalue.size();
if(count == 0) if(count == 0)
return len; return len;
@ -78,7 +79,7 @@ _getxattr_controlfile(const Policy &policy,
static static
int int
_getxattr(const Policy::Search::Func searchFunc,
_getxattr(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const char *attrname, const char *attrname,
@ -87,13 +88,13 @@ _getxattr(const Policy::Search::Func searchFunc,
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;
string path;
fs::PathVector paths;
path = searchFunc(srcmounts,fusepath).full;
if(path.empty())
searchFunc(srcmounts,fusepath,paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
rv = ::lgetxattr(path.c_str(),attrname,buf,count);
rv = ::lgetxattr(paths[0].full.c_str(),attrname,buf,count);
return ((rv == -1) ? -errno : rv); return ((rv == -1) ? -errno : rv);
#else #else
@ -115,12 +116,12 @@ namespace mergerfs
const config::Config &config = config::get(); const config::Config &config = config::get();
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return _getxattr_controlfile(config.policy,
return _getxattr_controlfile(config,
attrname, attrname,
buf, buf,
count); count);
return _getxattr(config.policy.search,
return _getxattr(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
attrname, attrname,

8
src/link.cpp

@ -39,14 +39,14 @@ using mergerfs::Policy;
static static
int int
_link(const Policy::Action::Func searchFunc,
_link(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string from, const string from,
const string to) const string to)
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,from,paths); searchFunc(srcmounts,from,paths);
if(paths.empty()) if(paths.empty())
@ -54,7 +54,7 @@ _link(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
const string pathfrom = fs::make_path(i->base,from); const string pathfrom = fs::make_path(i->base,from);
@ -82,7 +82,7 @@ namespace mergerfs
if(from == config.controlfile) if(from == config.controlfile)
return -EPERM; return -EPERM;
return _link(config.policy.action,
return _link(*config.action,
config.srcmounts, config.srcmounts,
from, from,
to); to);

34
src/listxattr.cpp

@ -30,6 +30,7 @@
#include <string.h> #include <string.h>
#include "config.hpp" #include "config.hpp"
#include "category.hpp"
#include "fs.hpp" #include "fs.hpp"
#include "ugid.hpp" #include "ugid.hpp"
#include "assert.hpp" #include "assert.hpp"
@ -37,7 +38,6 @@
using std::string; using std::string;
using std::vector; using std::vector;
using mergerfs::Policy;
using namespace mergerfs; using namespace mergerfs;
static static
@ -46,21 +46,23 @@ _listxattr_controlfile(char *list,
const size_t size) const size_t size)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
const char xattrs[] =
"user.mergerfs.action\0"
"user.mergerfs.create\0"
"user.mergerfs.search\0"
"user.mergerfs.statfs\0";
size_t xattrssize;
string xattrs;
for(int i = Category::Enum::BEGIN; i < Category::Enum::END; ++i)
xattrs += "user.mergerfs." + (string)Category::categories[i] + '\0';
xattrssize = xattrs.size();
if(size == 0) if(size == 0)
return sizeof(xattrs);
return xattrssize;
if(size < sizeof(xattrs))
if(size < xattrssize)
return -ERANGE; return -ERANGE;
memcpy(list,xattrs,sizeof(xattrs));
memcpy(list,xattrs.data(),xattrssize);
return sizeof(xattrs);
return xattrssize;
#else #else
return -ENOTSUP; return -ENOTSUP;
#endif #endif
@ -68,7 +70,7 @@ _listxattr_controlfile(char *list,
static static
int int
_listxattr(const Policy::Search::Func searchFunc,
_listxattr(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
char *list, char *list,
@ -76,13 +78,13 @@ _listxattr(const Policy::Search::Func searchFunc,
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;
string path;
fs::PathVector paths;
path = searchFunc(srcmounts,fusepath).full;
if(path.empty())
searchFunc(srcmounts,fusepath,paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
rv = ::llistxattr(path.c_str(),list,size);
rv = ::llistxattr(paths[0].full.c_str(),list,size);
return ((rv == -1) ? -errno : rv); return ((rv == -1) ? -errno : rv);
#else #else
@ -106,7 +108,7 @@ namespace mergerfs
return _listxattr_controlfile(list, return _listxattr_controlfile(list,
size); size);
return _listxattr(config.policy.search,
return _listxattr(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
list, list,

1
src/mergerfs.cpp

@ -90,7 +90,6 @@ get_fuse_operations()
ops.getdir = NULL; /* deprecated; use readdir */ ops.getdir = NULL; /* deprecated; use readdir */
ops.getxattr = mergerfs::getxattr::getxattr; ops.getxattr = mergerfs::getxattr::getxattr;
ops.init = NULL; ops.init = NULL;
ops.ioctl = NULL;
ops.ioctl = mergerfs::ioctl::ioctl; ops.ioctl = mergerfs::ioctl::ioctl;
ops.link = mergerfs::link::link; ops.link = mergerfs::link::link;
ops.listxattr = mergerfs::listxattr::listxattr; ops.listxattr = mergerfs::listxattr::listxattr;

24
src/mkdir.cpp

@ -43,8 +43,8 @@ using mergerfs::Policy;
static static
int int
_mkdir(const Policy::Search::Func searchFunc,
const Policy::Create::Func createPathFunc,
_mkdir(const fs::SearchFunc searchFunc,
const fs::SearchFunc createPathFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const mode_t mode) const mode_t mode)
@ -52,22 +52,22 @@ _mkdir(const Policy::Search::Func searchFunc,
int rv; int rv;
string path; string path;
string dirname; string dirname;
fs::Path createpath;
fs::Path existingpath;
fs::PathVector createpath;
fs::PathVector existingpath;
if(fs::path_exists(srcmounts,fusepath)) if(fs::path_exists(srcmounts,fusepath))
return -EEXIST; return -EEXIST;
dirname = fs::dirname(fusepath); dirname = fs::dirname(fusepath);
existingpath = searchFunc(srcmounts,dirname);
if(existingpath.base.empty())
searchFunc(srcmounts,dirname,existingpath);
if(existingpath.empty())
return -ENOENT; return -ENOENT;
createpath = createPathFunc(srcmounts,dirname);
if(createpath.base != existingpath.base)
fs::clonepath(existingpath.base,createpath.base,dirname);
createPathFunc(srcmounts,dirname,createpath);
if(createpath[0].base != existingpath[0].base)
fs::clonepath(existingpath[0].base,createpath[0].base,dirname);
path = fs::make_path(createpath.base,fusepath);
path = fs::make_path(createpath[0].base,fusepath);
rv = ::mkdir(path.c_str(),mode); rv = ::mkdir(path.c_str(),mode);
@ -88,8 +88,8 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EEXIST; return -EEXIST;
return _mkdir(config.policy.search,
config.policy.create,
return _mkdir(*config.search,
*config.create,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
mode); mode);

24
src/mknod.cpp

@ -44,8 +44,8 @@ using mergerfs::Policy;
static static
int int
_mknod(const Policy::Search::Func searchFunc,
const Policy::Create::Func createPathFunc,
_mknod(const fs::SearchFunc searchFunc,
const fs::SearchFunc createPathFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const mode_t mode, const mode_t mode,
@ -54,22 +54,22 @@ _mknod(const Policy::Search::Func searchFunc,
int rv; int rv;
string path; string path;
string dirname; string dirname;
fs::Path createpath;
fs::Path existingpath;
fs::PathVector createpath;
fs::PathVector existingpath;
if(fs::path_exists(srcmounts,fusepath)) if(fs::path_exists(srcmounts,fusepath))
return -EEXIST; return -EEXIST;
dirname = fs::dirname(fusepath); dirname = fs::dirname(fusepath);
existingpath = searchFunc(srcmounts,dirname);
if(existingpath.base.empty())
searchFunc(srcmounts,dirname,existingpath);
if(existingpath.empty())
return -ENOENT; return -ENOENT;
createpath = createPathFunc(srcmounts,dirname);
if(existingpath.base != createpath.base)
fs::clonepath(existingpath.base,createpath.base,dirname);
createPathFunc(srcmounts,dirname,createpath);
if(existingpath[0].base != createpath[0].base)
fs::clonepath(existingpath[0].base,createpath[0].base,dirname);
path = fs::make_path(createpath.base,fusepath);
path = fs::make_path(createpath[0].base,fusepath);
rv = ::mknod(path.c_str(),mode,dev); rv = ::mknod(path.c_str(),mode,dev);
@ -91,8 +91,8 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EEXIST; return -EEXIST;
return _mknod(config.policy.search,
config.policy.create,
return _mknod(*config.search,
*config.create,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
mode, mode,

14
src/open.cpp

@ -53,24 +53,24 @@ _open_controlfile(uint64_t &fh)
static static
int int
_open(const Policy::Search::Func searchFunc,
_open(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const int flags, const int flags,
uint64_t &fh) uint64_t &fh)
{ {
int fd; int fd;
fs::Path path;
fs::PathVector paths;
path = searchFunc(srcmounts,fusepath);
if(path.full.empty())
searchFunc(srcmounts,fusepath,paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
fd = ::open(path.full.c_str(),flags);
fd = ::open(paths[0].full.c_str(),flags);
if(fd == -1) if(fd == -1)
return -errno; return -errno;
fh = (uint64_t)new FileInfo(fd,flags,path.full);
fh = (uint64_t)new FileInfo(fd,flags,paths[0].full);
return 0; return 0;
} }
@ -89,7 +89,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return _open_controlfile(fileinfo->fh); return _open_controlfile(fileinfo->fh);
return _open(config.policy.search,
return _open(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
fileinfo->flags, fileinfo->flags,

7
src/option_parser.cpp

@ -62,18 +62,17 @@ process_opt(config::Config &config,
{ {
int rv = 0; int rv = 0;
std::vector<std::string> argvalue; std::vector<std::string> argvalue;
Policy &policy = config.policy;
split(argvalue,arg,'='); split(argvalue,arg,'=');
switch(argvalue.size()) switch(argvalue.size())
{ {
case 2: case 2:
if(argvalue[0] == "create") if(argvalue[0] == "create")
policy.create.fromString(argvalue[1]);
config.create = Policy::find(argvalue[1]);
else if(argvalue[0] == "search") else if(argvalue[0] == "search")
policy.search.fromString(argvalue[1]);
config.search = Policy::find(argvalue[1]);
else if(argvalue[0] == "action") else if(argvalue[0] == "action")
policy.action.fromString(argvalue[1]);
config.action = Policy::find(argvalue[1]);
else else
rv = 1; rv = 1;
break; break;

251
src/policy.cpp

@ -22,236 +22,57 @@
THE SOFTWARE. THE SOFTWARE.
*/ */
#include <vector>
#include "policy.hpp" #include "policy.hpp"
#include "fs.hpp" #include "fs.hpp"
#include "buildvector.hpp"
namespace mergerfs
{
Policy::Create::Create(Type value)
{
*this = value;
}
Policy::Create&
Policy::Create::operator=(const Policy::Create::Type value)
{
_str = toString(value);
_value = fromString(_str);
_func = findFunc(_value);
return *this;
}
Policy::Create&
Policy::Create::operator=(const std::string str)
{
_value = fromString(str);
_str = toString(_value);
_func = findFunc(_value);
return *this;
}
Policy::Create::Type
Policy::Create::fromString(const std::string str)
{
if(str == "ep")
return Policy::Create::ExistingPath;
else if(str == "mfs")
return Policy::Create::MostFreeSpace;
else if(str == "epmfs")
return Policy::Create::ExistingPathMostFreeSpace;
else if(str == "rand")
return Policy::Create::Random;
return Policy::Create::Invalid;
}
std::string
Policy::Create::toString(const Type value)
{
switch(value)
{
case Policy::Create::ExistingPath:
return "ep";
case Policy::Create::ExistingPathMostFreeSpace:
return "epmfs";
case Policy::Create::MostFreeSpace:
return "mfs";
case Policy::Create::Random:
return "rand";
case Policy::Create::Invalid:
default:
return "invalid";
}
}
Policy::Create::Func
Policy::Create::findFunc(Policy::Create::Type value)
{
switch(value)
{
case Policy::Create::ExistingPath:
return fs::find_first;
case Policy::Create::ExistingPathMostFreeSpace:
return fs::find_mfs_existing;
case Policy::Create::MostFreeSpace:
return fs::find_mfs;
case Policy::Create::Random:
return fs::find_random;
case Policy::Create::Invalid:
default:
return NULL;
}
}
Policy::Search::Search(Type value)
{
*this = value;
}
Policy::Search&
Policy::Search::operator=(const Policy::Search::Type value)
{
_str = toString(value);
_value = fromString(_str);
_func = findFunc(_value);
return *this;
}
Policy::Search&
Policy::Search::operator=(const std::string str)
{
_value = fromString(str);
_str = toString(_value);
_func = findFunc(_value);
return *this;
}
Policy::Search::Type
Policy::Search::fromString(const std::string str)
{
if(str == "ff")
return Policy::Search::FirstFound;
else if(str == "ffwp")
return Policy::Search::FirstFoundWithPermissions;
else if(str == "newest")
return Policy::Search::Newest;
return Policy::Search::Invalid;
}
#define POLICY(X) (Policy(Policy::Enum::X,#X,fs::find::X))
std::string
Policy::Search::toString(Policy::Search::Type value)
{
switch(value)
namespace mergerfs
{ {
case Policy::Search::FirstFound:
return "ff";
case Policy::Search::FirstFoundWithPermissions:
return "ffwp";
case Policy::Search::Newest:
return "newest";
case Policy::Search::Invalid:
default:
return "invalid";
}
}
const std::vector<Policy> Policy::_policies_ =
buildvector<Policy,true>
(POLICY(invalid))
(POLICY(all))
(POLICY(epmfs))
(POLICY(ff))
(POLICY(ffwp))
(POLICY(mfs))
(POLICY(newest))
(POLICY(rand));
Policy::Search::Func
Policy::Search::findFunc(Policy::Search::Type value)
{
switch(value)
{
case Policy::Search::FirstFound:
return fs::find_first;
case Policy::Search::FirstFoundWithPermissions:
return fs::find_first_with_permission;
case Policy::Search::Newest:
return fs::find_newest;
case Policy::Search::Invalid:
default:
return NULL;
}
}
const Policy * const Policy::policies = &_policies_[1];
Policy::Action::Action(const Policy::Action::Type value)
{
*this = value;
}
const Policy &Policy::invalid = Policy::policies[Policy::Enum::invalid];
const Policy &Policy::all = Policy::policies[Policy::Enum::all];
const Policy &Policy::epmfs = Policy::policies[Policy::Enum::epmfs];
const Policy &Policy::ff = Policy::policies[Policy::Enum::ff];
const Policy &Policy::ffwp = Policy::policies[Policy::Enum::ffwp];
const Policy &Policy::mfs = Policy::policies[Policy::Enum::mfs];
const Policy &Policy::newest = Policy::policies[Policy::Enum::newest];
const Policy &Policy::rand = Policy::policies[Policy::Enum::rand];
Policy::Action&
Policy::Action::operator=(const Policy::Action::Type value)
const Policy&
Policy::find(const std::string str)
{ {
_str = toString(value);
_value = fromString(_str);
_func = findFunc(_value);
return *this;
}
Policy::Action&
Policy::Action::operator=(const std::string str)
for(int i = Enum::BEGIN; i != Enum::END; ++i)
{ {
_value = fromString(str);
_str = toString(_value);
_func = findFunc(_value);
return *this;
if(policies[i] == str)
return policies[i];
} }
Policy::Action::Type
Policy::Action::fromString(const std::string str)
{
if(str == "ff")
return Policy::Action::FirstFound;
else if(str == "ffwp")
return Policy::Action::FirstFoundWithPermissions;
else if(str == "newest")
return Policy::Action::Newest;
else if(str == "all")
return Policy::Action::All;
return Policy::Action::Invalid;
return invalid;
} }
std::string
Policy::Action::toString(Policy::Action::Type value)
const Policy&
Policy::find(const Policy::Enum::Type i)
{ {
switch(value)
{
case Policy::Action::FirstFound:
return "ff";
case Policy::Action::FirstFoundWithPermissions:
return "ffwp";
case Policy::Action::Newest:
return "newest";
case Policy::Action::All:
return "all";
case Policy::Action::Invalid:
default:
return "invalid";
}
}
if(i >= Policy::Enum::BEGIN &&
i < Policy::Enum::END)
return policies[i];
Policy::Action::Func
Policy::Action::findFunc(const Policy::Action::Type value)
{
switch(value)
{
case Policy::Action::FirstFound:
return fs::find_first;
case Policy::Action::FirstFoundWithPermissions:
return fs::find_first_with_permission;
case Policy::Action::Newest:
return fs::find_newest;
case Policy::Action::All:
return fs::find_all;
case Policy::Action::Invalid:
default:
return NULL;
}
return invalid;
} }
} }

164
src/policy.hpp

@ -26,6 +26,7 @@
#define __POLICY_HPP__ #define __POLICY_HPP__
#include <string> #include <string>
#include <map>
#include "fs.hpp" #include "fs.hpp"
@ -34,138 +35,79 @@ namespace mergerfs
class Policy class Policy
{ {
public: public:
enum Type
{
ACTION,
CREATE,
SEARCH
};
public:
class Create
struct Enum
{ {
public:
typedef fs::SearchFunc Func;
enum Type enum Type
{ {
Invalid = -1,
ExistingPath,
MostFreeSpace,
ExistingPathMostFreeSpace,
Random,
Max
invalid = -1,
BEGIN = 0,
all = BEGIN,
epmfs,
ff,
ffwp,
mfs,
newest,
rand,
END
};
}; };
public:
Create(Type);
operator Type() const { return _value; }
operator Func() const { return _func; }
operator std::string() const { return _str; }
std::string str() const { return _str; }
Create& operator=(const Type);
Create& operator=(const std::string);
static Type fromString(const std::string);
static std::string toString(const Type);
static Func findFunc(const Type);
private:
Create();
private: private:
Type _value;
Enum::Type _enum;
std::string _str; std::string _str;
Func _func;
};
fs::SearchFunc _func;
class Search
{
public: public:
typedef fs::SearchFunc Func;
enum Type
Policy()
: _enum(invalid),
_str(invalid),
_func(invalid)
{ {
Invalid = -1,
FirstFound,
FirstFoundWithPermissions,
Newest,
Max
};
public:
Search(Type);
operator Type() const { return _value; }
operator Func() const { return _func; }
operator std::string() const { return _str; }
std::string str() const { return _str; }
Search& operator=(const Type);
Search& operator=(const std::string);
static Type fromString(const std::string);
static std::string toString(const Type);
static Func findFunc(const Type);
private:
Search();
private:
Type _value;
std::string _str;
Func _func;
};
}
class Action
{
public:
typedef fs::VecSearchFunc Func;
enum Type
Policy(const Enum::Type enum_,
const std::string str_,
const fs::SearchFunc func_)
: _enum(enum_),
_str(str_),
_func(func_)
{ {
Invalid = -1,
FirstFound,
FirstFoundWithPermissions,
Newest,
All,
Max
};
}
public: public:
Action(Type);
operator Type() const { return _value; }
operator Func() const { return _func; }
operator std::string() const { return _str; }
std::string str() const { return _str; }
operator const Enum::Type() const { return _enum; }
operator const std::string() const { return _str; }
operator const fs::SearchFunc() const { return _func; }
operator const Policy*() const { return this; }
Action& operator=(const Type);
Action& operator=(const std::string);
bool operator==(const Enum::Type enum_) const
{ return _enum == enum_; }
bool operator==(const std::string str_) const
{ return _str == str_; }
bool operator==(const fs::SearchFunc func_) const
{ return _func == func_; }
static Type fromString(const std::string);
static std::string toString(const Type);
static Func findFunc(const Type);
bool operator!=(const Policy &r) const
{ return _enum != r._enum; }
private:
Action();
private:
Type _value;
std::string _str;
Func _func;
};
bool operator<(const Policy &r) const
{ return _enum < r._enum; }
public: public:
Policy() :
create(Create::ExistingPathMostFreeSpace),
search(Search::FirstFound),
action(Action::FirstFound)
{}
static const Policy &find(const std::string);
static const Policy &find(const Enum::Type);
public: public:
Create create;
Search search;
Action action;
static const std::vector<Policy> _policies_;
static const Policy * const policies;
static const Policy &invalid;
static const Policy &all;
static const Policy &epmfs;
static const Policy &ff;
static const Policy &ffwp;
static const Policy &mfs;
static const Policy &newest;
static const Policy &rand;
}; };
} }

12
src/readlink.cpp

@ -41,20 +41,20 @@ using mergerfs::Policy;
static static
int int
_readlink(const Policy::Search::Func searchFunc,
_readlink(const fs::SearchFunc searchFunc,
const vector<string>& srcmounts, const vector<string>& srcmounts,
const string fusepath, const string fusepath,
char *buf, char *buf,
const size_t size) const size_t size)
{ {
int rv; int rv;
string path;
fs::PathVector paths;
path = searchFunc(srcmounts,fusepath).full;
if(path.empty())
searchFunc(srcmounts,fusepath,paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
rv = ::readlink(path.c_str(),buf,size);
rv = ::readlink(paths[0].full.c_str(),buf,size);
if(rv == -1) if(rv == -1)
return -errno; return -errno;
@ -78,7 +78,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EINVAL; return -EINVAL;
return _readlink(config.policy.search,
return _readlink(*config.search,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
buf, buf,

8
src/removexattr.cpp

@ -40,7 +40,7 @@ using mergerfs::Policy;
static static
int int
_removexattr(const Policy::Action::Func searchFunc,
_removexattr(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const char *attrname) const char *attrname)
@ -48,7 +48,7 @@ _removexattr(const Policy::Action::Func searchFunc,
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -56,7 +56,7 @@ _removexattr(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::lremovexattr(i->full.c_str(),attrname); rv &= ::lremovexattr(i->full.c_str(),attrname);
@ -84,7 +84,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -ENOTSUP; return -ENOTSUP;
return _removexattr(config.policy.action,
return _removexattr(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
attrname); attrname);

14
src/rename.cpp

@ -39,22 +39,22 @@ using mergerfs::Policy;
static static
int int
_rename(const Policy::Search::Func searchFunc,
_rename(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string from, const string from,
const string to) const string to)
{ {
int rv; int rv;
string pathto; string pathto;
fs::Path pathfrom;
fs::PathVector pathfrom;
pathfrom = searchFunc(srcmounts,from);
if(pathfrom.base.empty())
searchFunc(srcmounts,from,pathfrom);
if(pathfrom.empty())
return -ENOENT; return -ENOENT;
pathto = fs::make_path(pathfrom.base,to);
pathto = fs::make_path(pathfrom[0].base,to);
rv = ::rename(pathfrom.full.c_str(),pathto.c_str());
rv = ::rename(pathfrom[0].full.c_str(),pathto.c_str());
return ((rv == -1) ? -errno : 0); return ((rv == -1) ? -errno : 0);
} }
@ -73,7 +73,7 @@ namespace mergerfs
if(from == config.controlfile) if(from == config.controlfile)
return -ENOENT; return -ENOENT;
return _rename(config.policy.search,
return _rename(*config.search,
config.srcmounts, config.srcmounts,
from, from,
to); to);

8
src/rmdir.cpp

@ -38,13 +38,13 @@ using mergerfs::Policy;
static static
int int
_rmdir(const Policy::Action::Func searchFunc,
_rmdir(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath) const string fusepath)
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -52,7 +52,7 @@ _rmdir(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::rmdir(i->full.c_str()); rv &= ::rmdir(i->full.c_str());
@ -76,7 +76,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -ENOTDIR; return -ENOTDIR;
return _rmdir(config.policy.action,
return _rmdir(*config.action,
config.srcmounts, config.srcmounts,
fusepath); fusepath);
} }

79
src/setxattr.cpp

@ -24,6 +24,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <sstream>
#include <errno.h> #include <errno.h>
#include <sys/types.h> #include <sys/types.h>
@ -37,8 +38,24 @@
using std::string; using std::string;
using std::vector; using std::vector;
using mergerfs::Policy; using mergerfs::Policy;
using mergerfs::Category;
using namespace mergerfs; using namespace mergerfs;
template<typename Container>
Container&
split(Container &result,
const typename Container::value_type &s,
typename Container::value_type::value_type delimiter)
{
std::string str;
std::istringstream ss(s);
while(std::getline(ss,str,delimiter))
result.push_back(str);
return result;
}
static static
int int
_setxattr_controlfile(config::Config &config, _setxattr_controlfile(config::Config &config,
@ -48,37 +65,33 @@ _setxattr_controlfile(config::Config &config,
const int flags) const int flags)
{ {
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
if(attrname == "user.mergerfs.action")
{
if((flags & XATTR_CREATE) == XATTR_CREATE)
return -EEXIST;
if(Policy::Action::fromString(attrval) != -1)
config.policy.action = attrval;
else
return -ENOSPC;
}
else if(attrname == "user.mergerfs.create")
{
if((flags & XATTR_CREATE) == XATTR_CREATE)
return -EEXIST;
if(Policy::Create::fromString(attrval) != -1)
config.policy.create = attrval;
else
return -ENOSPC;
}
else if(attrname == "user.mergerfs.search")
{
const Category *cat;
const Policy *policy;
vector<string> nameparts;
split(nameparts,attrname,'.');
if(nameparts.size() != 3)
return -EINVAL;
if(nameparts[0] != "user")
return -ENOATTR;
if(nameparts[1] != "mergerfs")
return -ENOATTR;
cat = Category::find(nameparts[2]);
if(cat == Category::invalid)
return -ENOATTR;
if((flags & XATTR_CREATE) == XATTR_CREATE) if((flags & XATTR_CREATE) == XATTR_CREATE)
return -EEXIST; return -EEXIST;
if(Policy::Search::fromString(attrval) != -1)
config.policy.search = attrval;
else
return -ENOSPC;
}
else
{
return -ENOATTR;
}
policy = Policy::find(attrval);
if(policy == Policy::invalid)
return -EINVAL;
config.policies[*cat] = policy;
config.updateReadStr(); config.updateReadStr();
@ -90,7 +103,7 @@ _setxattr_controlfile(config::Config &config,
static static
int int
_setxattr(const Policy::Action::Func searchFunc,
_setxattr(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const char *attrname, const char *attrname,
@ -101,7 +114,7 @@ _setxattr(const Policy::Action::Func searchFunc,
#ifndef WITHOUT_XATTR #ifndef WITHOUT_XATTR
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -109,7 +122,7 @@ _setxattr(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::lsetxattr(i->full.c_str(),attrname,attrval,attrvalsize,flags); rv &= ::lsetxattr(i->full.c_str(),attrname,attrval,attrvalsize,flags);
@ -143,7 +156,7 @@ namespace mergerfs
attrvalsize, attrvalsize,
flags); flags);
return _setxattr(config.policy.action,
return _setxattr(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
attrname, attrname,

10
src/symlink.cpp

@ -43,15 +43,15 @@ _symlink(const vector<string> &srcmounts,
const string to) const string to)
{ {
int rv; int rv;
fs::Path path;
fs::PathVector paths;
path = fs::find_first(srcmounts,fs::dirname(to));
if(path.base.empty())
fs::find::ff(srcmounts,fs::dirname(to),paths);
if(paths.empty())
return -ENOENT; return -ENOENT;
path.full = fs::make_path(path.base,to);
paths[0].full = fs::make_path(paths[0].base,to);
rv = symlink(from.c_str(),path.full.c_str());
rv = symlink(from.c_str(),paths[0].full.c_str());
return ((rv == -1) ? -errno : 0); return ((rv == -1) ? -errno : 0);
} }

2
src/test.cpp

@ -48,6 +48,8 @@ namespace mergerfs
test(const struct fuse_args &args, test(const struct fuse_args &args,
const mergerfs::config::Config &config) const mergerfs::config::Config &config)
{ {
return 0; return 0;
} }
} }

8
src/truncate.cpp

@ -42,14 +42,14 @@ using mergerfs::Policy;
static static
int int
_truncate(const Policy::Action::Func searchFunc,
_truncate(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const off_t size) const off_t size)
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -57,7 +57,7 @@ _truncate(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::truncate(i->full.c_str(),size); rv &= ::truncate(i->full.c_str(),size);
@ -82,7 +82,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EPERM; return -EPERM;
return _truncate(config.policy.action,
return _truncate(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
size); size);

8
src/unlink.cpp

@ -39,13 +39,13 @@ using mergerfs::Policy;
static static
int int
_unlink(const Policy::Action::Func searchFunc,
_unlink(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath) const string fusepath)
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -53,7 +53,7 @@ _unlink(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::unlink(i->full.c_str()); rv &= ::unlink(i->full.c_str());
@ -77,7 +77,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EPERM; return -EPERM;
return _unlink(config.policy.action,
return _unlink(*config.action,
config.srcmounts, config.srcmounts,
fusepath); fusepath);
} }

8
src/utimens.cpp

@ -39,14 +39,14 @@ using mergerfs::Policy;
static static
int int
_utimens(const Policy::Action::Func searchFunc,
_utimens(const fs::SearchFunc searchFunc,
const vector<string> &srcmounts, const vector<string> &srcmounts,
const string fusepath, const string fusepath,
const struct timespec ts[2]) const struct timespec ts[2])
{ {
int rv; int rv;
int error; int error;
vector<fs::Path> paths;
fs::PathVector paths;
searchFunc(srcmounts,fusepath,paths); searchFunc(srcmounts,fusepath,paths);
if(paths.empty()) if(paths.empty())
@ -54,7 +54,7 @@ _utimens(const Policy::Action::Func searchFunc,
rv = -1; rv = -1;
error = 0; error = 0;
for(vector<fs::Path>::const_iterator
for(fs::PathVector::const_iterator
i = paths.begin(), ei = paths.end(); i != ei; ++i) i = paths.begin(), ei = paths.end(); i != ei; ++i)
{ {
rv &= ::utimensat(0,i->full.c_str(),ts,AT_SYMLINK_NOFOLLOW); rv &= ::utimensat(0,i->full.c_str(),ts,AT_SYMLINK_NOFOLLOW);
@ -79,7 +79,7 @@ namespace mergerfs
if(fusepath == config.controlfile) if(fusepath == config.controlfile)
return -EPERM; return -EPERM;
return _utimens(config.policy.action,
return _utimens(*config.action,
config.srcmounts, config.srcmounts,
fusepath, fusepath,
ts); ts);

39
src/write.cpp

@ -33,11 +33,13 @@
#include "config.hpp" #include "config.hpp"
#include "policy.hpp" #include "policy.hpp"
#include "category.hpp"
#include "ugid.hpp" #include "ugid.hpp"
#include "fileinfo.hpp" #include "fileinfo.hpp"
using mergerfs::config::Config; using mergerfs::config::Config;
using mergerfs::Policy; using mergerfs::Policy;
using mergerfs::Category;
using std::string; using std::string;
using std::vector; using std::vector;
using std::stringstream; using std::stringstream;
@ -48,35 +50,22 @@ _process_kv(Config &config,
const string key, const string key,
const string value) const string value)
{ {
int rv = 0;
const Category *cat;
const Policy *policy;
if(key == "search")
{
rv = (Policy::Search::fromString(value) != -1) ? 0 : -EINVAL;
if(rv == 0)
config.policy.search = value;
}
else if(key == "action")
{
rv = (Policy::Action::fromString(value) != -1) ? 0 : -EINVAL;
if(rv == 0)
config.policy.action = value;
}
else if(key == "create")
{
rv = (Policy::Create::fromString(value) != -1) ? 0 : -EINVAL;
if(rv == 0)
config.policy.create = value;
}
else
{
rv = -EINVAL;
}
cat = Category::find(key);
if(cat == Category::invalid)
return -EINVAL;
policy = Policy::find(value);
if(policy == Policy::invalid)
return -EINVAL;
config.policies[*cat] = policy;
if(rv == 0)
config.updateReadStr(); config.updateReadStr();
return rv;
return 0;
} }
static static

Loading…
Cancel
Save