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

cleanup function signatures and definitions

Browse Source
This commit is contained in:
Antonio SJ Musumeci 2020-08-16 18:22:25 -04:00
parent 6cc6524997
commit ec15872a1f
112 changed files with 743 additions and 820 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/branch.cpp
View File

@ -91,8 +91,8 @@ parse(const string &str_,
else
branch.mode = Branch::RW;
fs::glob(str,globbed);
fs::realpathize(globbed);
fs::glob(str,&globbed);
fs::realpathize(&globbed);
for(size_t i = 0; i < globbed.size(); i++)
{
branch.path = globbed[i];
@ -109,7 +109,7 @@ set(Branches &branches_,
branches_.clear();
str::split(paths,str_,':');
str::split(str_,':',&paths);
for(size_t i = 0; i < paths.size(); i++)
{
@ -130,7 +130,7 @@ add_begin(Branches &branches_,
{
vector<string> paths;
str::split(paths,str_,':');
str::split(str_,':',&paths);
for(size_t i = 0; i < paths.size(); i++)
{
@ -151,7 +151,7 @@ add_end(Branches &branches_,
{
vector<string> paths;
str::split(paths,str_,':');
str::split(str_,':',&paths);
for(size_t i = 0; i < paths.size(); i++)
{
@ -186,7 +186,7 @@ erase_fnmatch(Branches &branches_,
{
vector<string> patterns;
str::split(patterns,str_,':');
str::split(str_,':',&patterns);
for(Branches::iterator i = branches_.begin();
i != branches_.end();)

12
src/buildmap.hpp
View File

@ -23,16 +23,16 @@ template<typename K,typename V>
class buildmap
{
public:
buildmap(const K &key,
const V &val)
buildmap(const K &key_,
const V &val_)
{
_map.insert(std::make_pair(key,val));
_map.insert(std::make_pair(key_,val_));
}
buildmap<K,V> &operator()(const K &key,
const V &val)
buildmap<K,V> &operator()(const K &key_,
const V &val_)
{
_map.insert(std::make_pair(key,val));
_map.insert(std::make_pair(key_,val_));
return *this;
}

8
src/buildvector.hpp
View File

@ -23,14 +23,14 @@ template<typename V, bool SORT = false>
class buildvector
{
public:
buildvector(const V &val)
buildvector(const V &val_)
{
_vector.push_back(val);
_vector.push_back(val_);
}
buildvector<V,SORT> &operator()(const V &val)
buildvector<V,SORT> &operator()(const V &val_)
{
_vector.push_back(val);
_vector.push_back(val_);
return *this;
}

1
src/config_statfsignore.hpp
View File

@ -26,4 +26,5 @@ enum class StatFSIgnoreEnum
RO,
NC
};
typedef Enum<StatFSIgnoreEnum> StatFSIgnore;

54
src/fs.cpp
View File

@ -38,20 +38,20 @@ using std::vector;
namespace fs
{
void
findallfiles(const vector<string> &basepaths,
const char *fusepath,
vector<string> &paths)
findallfiles(const vector<string> &basepaths_,
const char *fusepath_,
vector<string> *paths_)
{
string fullpath;
for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
for(size_t i = 0, ei = basepaths_.size(); i != ei; i++)
{
fullpath = fs::path::make(basepaths[i],fusepath);
fullpath = fs::path::make(basepaths_[i],fusepath_);
if(!fs::exists(fullpath))
continue;
paths.push_back(fullpath);
paths_->push_back(fullpath);
}
}
@ -91,17 +91,17 @@ namespace fs
}
void
realpathize(vector<string> &strs)
realpathize(vector<string> *strs_)
{
char *rv;
for(size_t i = 0; i < strs.size(); i++)
for(size_t i = 0; i < strs_->size(); i++)
{
rv = fs::realpath(strs[i]);
rv = fs::realpath((*strs_)[i]);
if(rv == NULL)
continue;
strs[i] = rv;
(*strs_)[i] = rv;
::free(rv);
}
@ -119,38 +119,4 @@ namespace fs
{
return ::fcntl(fd,F_SETFL,mode);
}
int
mfs(const vector<string> &basepaths,
const uint64_t minfreespace,
string &path)
{
int rv;
uint64_t mfs;
uint64_t spaceavail;
const string *mfsbasepath;
mfs = 0;
mfsbasepath = NULL;
for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
{
rv = fs::statvfs_cache_spaceavail(basepaths[i],&spaceavail);
if(rv == -1)
continue;
if(spaceavail < minfreespace)
continue;
if(spaceavail <= mfs)
continue;
mfs = spaceavail;
mfsbasepath = &basepaths[i];
}
if(mfsbasepath == NULL)
return (errno=ENOENT,-1);
path = *mfsbasepath;
return 0;
}
};

21
src/fs.hpp
View File

@ -24,20 +24,13 @@
namespace fs
{
using std::string;
using std::vector;
void findallfiles(const std::vector<std::string> &basepaths,
const char *fusepath,
std::vector<std::string> *paths);
void findallfiles(const vector<string> &basepaths_,
const char *fusepath_,
vector<string> &paths_);
void realpathize(std::vector<std::string> *strs);
void realpathize(vector<string> &strs_);
int getfl(const int fd_);
int setfl(const int fd_,
const mode_t mode_);
int mfs(const vector<string> &srcs_,
const uint64_t minfreespace_,
string &path_);
int getfl(const int fd);
int setfl(const int fd,
const mode_t mode);
}

2
src/fs_acl.hpp
View File

@ -25,6 +25,6 @@ namespace fs
namespace acl
{
bool
dir_has_defaults(const std::string &fullpath_);
dir_has_defaults(const std::string &fullpath);
}
}

8
src/fs_attr.hpp
View File

@ -22,9 +22,9 @@ namespace fs
{
namespace attr
{
int copy(const int fdin_,
const int fdout_);
int copy(const std::string &from_,
const std::string &to_);
int copy(const int fdin,
const int fdout);
int copy(const std::string &from,
const std::string &to);
}
}

18
src/fs_base_fadvise.hpp
View File

@ -19,17 +19,17 @@
namespace fs
{
int
fadvise_dontneed(const int fd_,
const off_t offset_ = 0,
const off_t len_ = 0);
fadvise_dontneed(const int fd,
const off_t offset = 0,
const off_t len = 0);
int
fadvise_willneed(const int fd_,
const off_t offset_ = 0,
const off_t len_ = 0);
fadvise_willneed(const int fd,
const off_t offset = 0,
const off_t len = 0);
int
fadvise_sequential(const int fd_,
const off_t offset_ = 0,
const off_t len_ = 0);
fadvise_sequential(const int fd,
const off_t offset = 0,
const off_t len = 0);
}

8
src/fs_base_fallocate.hpp
View File

@ -21,8 +21,8 @@
namespace fs
{
int
fallocate(const int fd_,
const int mode_,
const off_t offset_,
const off_t len_);
fallocate(const int fd,
const int mode,
const off_t offset,
const off_t len);
}

28
src/fs_base_fstatat.hpp
View File

@ -28,27 +28,27 @@ namespace fs
static
inline
int
fstatat(const int dirfd,
const char *pathname,
struct stat *statbuf,
const int flags)
fstatat(const int dirfd_,
const char *pathname_,
struct stat *statbuf_,
const int flags_)
{
return ::fstatat(dirfd,
pathname,
statbuf,
flags);
return ::fstatat(dirfd_,
pathname_,
statbuf_,
flags_);
}
static
inline
int
fstatat_nofollow(const int dirfd,
const char *pathname,
struct stat *statbuf)
fstatat_nofollow(const int dirfd_,
const char *pathname_,
struct stat *statbuf_)
{
return fs::fstatat(dirfd,
pathname,
statbuf,
return fs::fstatat(dirfd_,
pathname_,
statbuf_,
AT_SYMLINK_NOFOLLOW);
}
}

6
src/fs_base_futimesat.hpp
View File

@ -23,7 +23,7 @@
namespace fs
{
int
futimesat(const int dirfd_,
const char *pathname_,
const struct timeval times_[2]);
futimesat(const int dirfd,
const char *pathname,
const struct timeval times[2]);
}

6
src/fs_base_getdents.cpp
View File

@ -26,9 +26,9 @@
namespace fs
{
int
getdents(unsigned int fd_,
void *dirp_,
unsigned int count_)
getdents64(unsigned int fd_,
void *dirp_,
unsigned int count_)
{
#if defined SYS_getdents64
return ::syscall(SYS_getdents64,fd_,dirp_,count_);

6
src/fs_base_getdents.hpp
View File

@ -21,7 +21,7 @@
namespace fs
{
int
getdents(unsigned int fd,
void *dirp,
unsigned int count);
getdents64(unsigned int fd,
void *dirp,
unsigned int count);
}

10
src/fs_base_utime_utimensat.hpp
View File

@ -28,12 +28,12 @@ namespace fs
static
inline
int
utime(const int dirfd,
const std::string &path,
const struct timespec times[2],
const int flags)
utime(const int dirfd_,
const std::string &path_,
const struct timespec times_[2],
const int flags_)
{
return ::utimensat(dirfd,path.c_str(),times,flags);
return ::utimensat(dirfd_,path_.c_str(),times_,flags_);
}
static

18
src/fs_base_write.hpp
View File

@ -25,21 +25,21 @@ namespace fs
static
inline
ssize_t
write(const int fd,
const void *buf,
const size_t count)
write(const int fd_,
const void *buf_,
const size_t count_)
{
return ::write(fd,buf,count);
return ::write(fd_,buf_,count_);
}
static
inline
ssize_t
pwrite(const int fd,
const void *buf,
const size_t count,
const off_t offset)
pwrite(const int fd_,
const void *buf_,
const size_t count_,
const off_t offset_)
{
return ::pwrite(fd,buf,count,offset);
return ::pwrite(fd_,buf_,count_,offset_);
}
}

4
src/fs_clonefile.hpp
View File

@ -19,6 +19,6 @@
namespace fs
{
int
clonefile(const int src_fd_,
const int dst_fd_);
clonefile(const int src_fd,
const int dst_fd);
}

2
src/fs_cow.cpp
View File

@ -115,7 +115,7 @@ namespace fs
dst_fullpath = src_fullpath_;
dst_fd = fs::mktemp(dst_fullpath,O_WRONLY);
dst_fd = fs::mktemp(&dst_fullpath,O_WRONLY);
if(dst_fd == -1)
return cleanup_on_error(src_fd);

10
src/fs_cow.hpp
View File

@ -25,12 +25,12 @@ namespace fs
{
namespace cow
{
bool is_eligible(const int flags_);
bool is_eligible(const struct stat &st_);
bool is_eligible(const int flags_, const struct stat &st_);
bool is_eligible(const int flags);
bool is_eligible(const struct stat &st);
bool is_eligible(const int flags, const struct stat &st);
bool is_eligible(const char *fullpath_, const int flags_);
bool is_eligible(const char *fullpath, const int flags);
int break_link(const char *fullpath_);
int break_link(const char *fullpath);
}
}

2
src/fs_exists.hpp
View File

@ -70,7 +70,7 @@ namespace fs
{
std::string fullpath;
fullpath = fs::path::make(&basepath_,relpath_);
fullpath = fs::path::make(basepath_,relpath_);
return fs::exists(fullpath,st_);
}

4
src/fs_ficlone.hpp
View File

@ -21,6 +21,6 @@
namespace fs
{
int
ficlone(const int src_fd_,
const int dst_fd_);
ficlone(const int src_fd,
const int dst_fd);
}

4
src/fs_glob.cpp
View File

@ -28,7 +28,7 @@ namespace fs
{
void
glob(const string &pattern_,
vector<string> &strs_)
vector<string> *strs_)
{
int flags;
glob_t gbuf = {0};
@ -37,7 +37,7 @@ namespace fs
::glob(pattern_.c_str(),flags,NULL,&gbuf);
for(size_t i = 0; i < gbuf.gl_pathc; i++)
strs_.push_back(gbuf.gl_pathv[i]);
strs_->push_back(gbuf.gl_pathv[i]);
::globfree(&gbuf);
}

4
src/fs_glob.hpp
View File

@ -22,6 +22,6 @@
namespace fs
{
void
glob(const std::string &pattern_,
std::vector<std::string> &strs_);
glob(const std::string &pattern,
std::vector<std::string> *strs);
}

4
src/fs_info.cpp
View File

@ -32,13 +32,13 @@ using std::string;
namespace fs
{
int
info(const string *path_,
info(const string &path_,
fs::info_t *info_)
{
int rv;
struct statvfs st;
rv = fs::statvfs_cache(path_->c_str(),&st);
rv = fs::statvfs_cache(path_.c_str(),&st);
if(rv == 0)
{
info_->readonly = StatVFS::readonly(st);

4
src/fs_info.hpp
View File

@ -25,6 +25,6 @@
namespace fs
{
int
info(const std::string *path_,
fs::info_t *info_);
info(const std::string &path,
fs::info_t *info);
}

6
src/fs_mktemp.cpp
View File

@ -48,7 +48,7 @@ generate_tmp_path(const string &base_)
namespace fs
{
int
mktemp(string &base_,
mktemp(string *base_,
const int flags_)
{
int fd;
@ -61,13 +61,13 @@ namespace fs
flags = (flags_ | O_EXCL | O_CREAT);
while(count-- > 0)
{
tmppath = generate_tmp_path(base_);
tmppath = generate_tmp_path(*base_);
fd = fs::open(tmppath,flags,S_IWUSR);
if((fd == -1) && (errno == EEXIST))
continue;
else if(fd != -1)
base_ = tmppath;
*base_ = tmppath;
return fd;
}

4
src/fs_mktemp.hpp
View File

@ -23,6 +23,6 @@
namespace fs
{
int
mktemp(std::string &base_,
const int flags_);
mktemp(std::string *base,
const int flags);
}

2
src/fs_movefile.cpp
View File

@ -97,7 +97,7 @@ namespace l
fs::path::append(fdout_path[0],fusepath_);
fdout_temp = fdout_path[0];
fdout = fs::mktemp(fdout_temp,fdin_flags);
fdout = fs::mktemp(&fdout_temp,fdin_flags);
if(fdout == -1)
return -1;

54
src/fs_path.hpp
View File

@ -23,39 +23,37 @@ namespace fs
{
namespace path
{
using std::string;
std::string dirname(const char *path);
std::string dirname(const std::string &path);
string dirname(const char *path);
string dirname(const string &path);
string basename(const string &path);
std::string basename(const std::string &path);
static
inline
void
append(string &base,
const char *suffix)
append(std::string &base_,
const char *suffix_)
{
base += suffix;
base_ += suffix_;
}
static
inline
void
append(string &base,
const string &suffix)
append(std::string &base_,
const std::string &suffix_)
{
base += suffix;
base_ += suffix_;
}
static
inline
string
std::string
make(const char *base_,
const char *suffix_)
{
char back;
string path(base_);
std::string path(base_);
back = *path.rbegin();
if((back != '/') && (suffix_[0] != '/'))
@ -67,36 +65,18 @@ namespace fs
static
inline
string
make(const string &base_,
const char *suffix_)
std::string
make(const std::string &base_,
const char *suffix_)
{
return (base_ + suffix_);
}
static
inline
string
make(const string *base_,
const char *suffix_)
{
return (*base_ + suffix_);
}
static
inline
string
make(const string *base_,
const string *suffix_)
{
return (*base_ + *suffix_);
}
static
inline
string
make(const string &base_,
const string &suffix_)
std::string
make(const std::string &base_,
const std::string &suffix_)
{
return (base_ + suffix_);
}

18
src/fs_statvfs_cache.hpp
View File

@ -26,21 +26,21 @@ namespace fs
uint64_t
statvfs_cache_timeout(void);
void
statvfs_cache_timeout(const uint64_t timeout_);
statvfs_cache_timeout(const uint64_t timeout);
int
statvfs_cache(const char *path_,
struct statvfs *st_);
statvfs_cache(const char *path,
struct statvfs *st);
int
statvfs_cache_readonly(const std::string &path_,
bool *readonly_);
statvfs_cache_readonly(const std::string &path,
bool *readonly);
int
statvfs_cache_spaceavail(const std::string &path_,
uint64_t *spaceavail_);
statvfs_cache_spaceavail(const std::string &path,
uint64_t *spaceavail);
int
statvfs_cache_spaceused(const std::string &path_,
uint64_t *spaceused_);
statvfs_cache_spaceused(const std::string &path,
uint64_t *spaceused);
}

184
src/fs_xattr.cpp
View File

@ -39,8 +39,8 @@ namespace fs
namespace xattr
{
int
list(const int fd,
vector<char> &attrs)
list(const int fd_,
vector<char> *attrs_)
{
ssize_t rv;
@ -48,21 +48,21 @@ namespace fs
errno = ERANGE;
while((rv == -1) && (errno == ERANGE))
{
rv = fs::flistxattr(fd,NULL,0);
rv = fs::flistxattr(fd_,NULL,0);
if(rv <= 0)
return rv;
attrs.resize(rv);
attrs_->resize(rv);
rv = fs::flistxattr(fd,&attrs[0],rv);
rv = fs::flistxattr(fd_,&(*attrs_)[0],rv);
}
return rv;
}
int
list(const string &path,
vector<char> &attrs)
list(const string &path_,
vector<char> *attrs_)
{
ssize_t rv;
@ -70,84 +70,84 @@ namespace fs
errno = ERANGE;
while((rv == -1) && (errno == ERANGE))
{
rv = fs::llistxattr(path,NULL,0);
rv = fs::llistxattr(path_,NULL,0);
if(rv <= 0)
return rv;
attrs.resize(rv);
attrs_->resize(rv);
rv = fs::llistxattr(path,&attrs[0],rv);
rv = fs::llistxattr(path_,&(*attrs_)[0],rv);
}
return rv;
}
int
list(const int fd,
vector<string> &attrvector)
list(const int fd_,
vector<string> *attrvector_)
{
int rv;
vector<char> attrs;
rv = list(fd,attrs);
rv = fs::xattr::list(fd_,&attrs);
if(rv != -1)
{
string tmp(attrs.begin(),attrs.end());
str::split(attrvector,tmp,'\0');
str::split(tmp,'\0',attrvector_);
}
return rv;
}
int
list(const string &path,
vector<string> &attrvector)
list(const string &path_,
vector<string> *attrvector_)
{
int rv;
vector<char> attrs;
rv = list(path,attrs);
rv = fs::xattr::list(path_,&attrs);
if(rv != -1)
{
string tmp(attrs.begin(),attrs.end());
str::split(attrvector,tmp,'\0');
str::split(tmp,'\0',attrvector_);
}
return rv;
}
int
list(const int fd,
string &attrstr)
list(const int fd_,
string *attrstr_)
{
int rv;
vector<char> attrs;
rv = list(fd,attrs);
rv = fs::xattr::list(fd_,&attrs);
if(rv != -1)
attrstr = string(attrs.begin(),attrs.end());
*attrstr_ = string(attrs.begin(),attrs.end());
return rv;
}
int
list(const string &path,
string &attrstr)
list(const string &path_,
string *attrstr_)
{
int rv;
vector<char> attrs;
rv = list(path,attrs);
rv = fs::xattr::list(path_,&attrs);
if(rv != -1)
attrstr = string(attrs.begin(),attrs.end());
*attrstr_ = string(attrs.begin(),attrs.end());
return rv;
}
int
get(const int fd,
const string &attr,
vector<char> &value)
get(const int fd_,
const string &attr_,
vector<char> *value_)
{
ssize_t rv;
@ -155,22 +155,22 @@ namespace fs
errno = ERANGE;
while((rv == -1) && (errno == ERANGE))
{
rv = fs::fgetxattr(fd,attr,NULL,0);
rv = fs::fgetxattr(fd_,attr_,NULL,0);
if(rv <= 0)
return rv;
value.resize(rv);
value_->resize(rv);
rv = fs::fgetxattr(fd,attr,&value[0],rv);
rv = fs::fgetxattr(fd_,attr_,&(*value_)[0],rv);
}
return rv;
}
int
get(const string &path,
const string &attr,
vector<char> &value)
get(const string &path_,
const string &attr_,
vector<char> *value_)
{
ssize_t rv;
@ -178,56 +178,56 @@ namespace fs
errno = ERANGE;
while((rv == -1) && (errno == ERANGE))
{
rv = fs::lgetxattr(path,attr,NULL,0);
rv = fs::lgetxattr(path_,attr_,NULL,0);
if(rv <= 0)
return rv;
value.resize(rv);
value_->resize(rv);
rv = fs::lgetxattr(path,attr,&value[0],rv);
rv = fs::lgetxattr(path_,attr_,&(*value_)[0],rv);
}
return rv;
}
int
get(const int fd,
const string &attr,
string &value)
get(const int fd_,
const string &attr_,
string *value_)
{
int rv;
vector<char> tmpvalue;
rv = get(fd,attr,tmpvalue);
rv = get(fd_,attr_,&tmpvalue);
if(rv != -1)
value = string(tmpvalue.begin(),tmpvalue.end());
*value_ = string(tmpvalue.begin(),tmpvalue.end());
return rv;
}
int
get(const string &path,
const string &attr,
string &value)
get(const string &path_,
const string &attr_,
string *value_)
{
int rv;
vector<char> tmpvalue;
rv = get(path,attr,tmpvalue);
rv = fs::xattr::get(path_,attr_,&tmpvalue);
if(rv != -1)
value = string(tmpvalue.begin(),tmpvalue.end());
*value_ = string(tmpvalue.begin(),tmpvalue.end());
return rv;
}
int
get(const int fd,
map<string,string> &attrs)
get(const int fd_,
map<string,string> *attrs_)
{
int rv;
string attrstr;
rv = list(fd,attrstr);
rv = fs::xattr::list(fd_,&attrstr);
if(rv == -1)
return -1;
@ -239,9 +239,9 @@ namespace fs
{
string value;
rv = get(fd,key,value);
rv = fs::xattr::get(fd_,key,&value);
if(rv != -1)
attrs[key] = value;
(*attrs_)[key] = value;
}
}
@ -249,13 +249,13 @@ namespace fs
}
int
get(const string &path,
map<string,string> &attrs)
get(const string &path_,
map<string,string> *attrs_)
{
int rv;
string attrstr;
rv = list(path,attrstr);
rv = fs::xattr::list(path_,&attrstr);
if(rv == -1)
return -1;
@ -267,9 +267,9 @@ namespace fs
{
string value;
rv = get(path,key,value);
rv = fs::xattr::get(path_,key,&value);
if(rv != -1)
attrs[key] = value;
(*attrs_)[key] = value;
}
}
@ -277,41 +277,41 @@ namespace fs
}
int
set(const int fd,
const string &key,
const string &value,
const int flags)
set(const int fd_,
const string &key_,
const string &value_,
const int flags_)
{
return fs::fsetxattr(fd,
key.c_str(),
value.data(),
value.size(),
flags);
return fs::fsetxattr(fd_,
key_.c_str(),
value_.data(),
value_.size(),
flags_);
}
int
set(const string &path,
const string &key,
const string &value,
const int flags)
set(const string &path_,
const string &key_,
const string &value_,
const int flags_)
{
return fs::lsetxattr(path,
key,
value.data(),
value.size(),
flags);
return fs::lsetxattr(path_,
key_,
value_.data(),
value_.size(),
flags_);
}
int
set(const int fd,
const map<string,string> &attrs)
set(const int fd_,
const map<string,string> &attrs_)
{
int rv;
for(map<string,string>::const_iterator
i = attrs.begin(), ei = attrs.end(); i != ei; ++i)
i = attrs_.begin(), ei = attrs_.end(); i != ei; ++i)
{
rv = set(fd,i->first,i->second,0);
rv = fs::xattr::set(fd_,i->first,i->second,0);
if(rv == -1)
return -1;
}
@ -320,46 +320,46 @@ namespace fs
}
int
set(const string &path,
const map<string,string> &attrs)
set(const string &path_,
const map<string,string> &attrs_)
{
int fd;
fd = fs::open(path,O_RDONLY|O_NONBLOCK);
fd = fs::open(path_,O_RDONLY|O_NONBLOCK);
if(fd == -1)
return -1;
set(fd,attrs);
fs::xattr::set(fd,attrs_);
return fs::close(fd);
}
int
copy(const int fdin,
const int fdout)
copy(const int fdin_,
const int fdout_)
{
int rv;
map<string,string> attrs;
rv = get(fdin,attrs);
rv = fs::xattr::get(fdin_,&attrs);
if(rv == -1)
return -1;
return set(fdout,attrs);
return fs::xattr::set(fdout_,attrs);
}
int
copy(const string &from,
const string &to)
copy(const string &from_,
const string &to_)
{
int rv;
map<string,string> attrs;
rv = get(from,attrs);
rv = fs::xattr::get(from_,&attrs);
if(rv == -1)
return -1;
return set(to,attrs);
return fs::xattr::set(to_,attrs);
}
}
}

12
src/fs_xattr.hpp
View File

@ -30,21 +30,21 @@ namespace fs
int list(const string &path,
vector<char> &attrs);
vector<char> *attrs);
int list(const string &path,
string &attrs);
string *attrs);
int list(const string &path,
vector<string> &attrs);
vector<string> *attrs);
int get(const string &path,
const string &attr,
vector<char> &value);
vector<char> *value);
int get(const string &path,
const string &attr,
string &value);
string *value);
int get(const string &path,
map<string,string> &attrs);
map<string,string> *attrs);
int set(const string &path,
const string &key,

4
src/fuse_access.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
access(const char *fusepath_,
int mask_);
access(const char *fusepath,
int mask);
}

4
src/fuse_chmod.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
chmod(const char *fusepath_,
mode_t mode_);
chmod(const char *fusepath,
mode_t mode);
}

6
src/fuse_chown.hpp
View File

@ -19,7 +19,7 @@
namespace FUSE
{
int
chown(const char *fusepath_,
uid_t uid_,
gid_t gid_);
chown(const char *fusepath,
uid_t uid,
gid_t gid);
}

6
src/fuse_create.hpp
View File

@ -23,7 +23,7 @@
namespace FUSE
{
int
create(const char *fusepath_,
mode_t mode_,
fuse_file_info *ffi_);
create(const char *fusepath,
mode_t mode,
fuse_file_info *ffi);
}

10
src/fuse_fallocate.hpp
View File

@ -16,11 +16,13 @@
#pragma once
#include "fuse.h"
namespace FUSE
{
int
fallocate(int mode_,
off_t offset_,
off_t len_,
fuse_file_info *ffi_);
fallocate(int mode,
off_t offset,
off_t len,
fuse_file_info *ffi);
}

4
src/fuse_fchmod.hpp
View File

@ -23,6 +23,6 @@
namespace FUSE
{
int
fchmod(const struct fuse_file_info *ffi_,
const mode_t mode_);
fchmod(const fuse_file_info *ffi,
const mode_t mode);
}

6
src/fuse_fchown.hpp
View File

@ -21,7 +21,7 @@
namespace FUSE
{
int
fchown(const struct fuse_file_info *ffi_,
uid_t uid_,
gid_t gid_);
fchown(const fuse_file_info *ffi,
uid_t uid,
gid_t gid);
}

6
src/fuse_flock.hpp
View File

@ -21,7 +21,7 @@
namespace FUSE
{
int
flock(const char *fusepath_,
fuse_file_info *ffi_,
int op_);
flock(const char *fusepath,
fuse_file_info *ffi,
int op);
}

2
src/fuse_flush.hpp
View File

@ -21,5 +21,5 @@
namespace FUSE
{
int
flush(fuse_file_info *ffi_);
flush(fuse_file_info *ffi);
}

2
src/fuse_free_hide.hpp
View File

@ -23,5 +23,5 @@
namespace FUSE
{
int
free_hide(const uint64_t fh_);
free_hide(const uint64_t fh);
}

4
src/fuse_fsync.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
fsync(int isdatasync_,
fuse_file_info *ffi_);
fsync(int isdatasync,
fuse_file_info *ffi);
}

4
src/fuse_fsyncdir.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
fsyncdir(int isdatasync_,
fuse_file_info *ffi_);
fsyncdir(int isdatasync,
fuse_file_info *ffi);
}

4
src/fuse_ftruncate.hpp
View File

@ -24,6 +24,6 @@
namespace FUSE
{
int
ftruncate(off_t size_,
fuse_file_info *ffi_);
ftruncate(off_t size,
fuse_file_info *ffi);
}

4
src/fuse_futimens.hpp
View File

@ -23,6 +23,6 @@
namespace FUSE
{
int
futimens(const struct fuse_file_info *ffi_,
const timespec ts_[2]);
futimens(const fuse_file_info *ffi,
const timespec ts[2]);
}

120
src/fuse_getxattr.cpp
View File

@ -63,10 +63,10 @@ namespace l
static
int
getxattr_controlfile(const Config &config,
const char *attrname,
char *buf,
const size_t count)
getxattr_controlfile(const Config &config_,
const char *attrname_,
char *buf_,
const size_t count_)
{
int rv;
size_t len;
@ -74,42 +74,42 @@ namespace l
string val;
vector<string> attr;
if(!str::startswith(attrname,"user.mergerfs."))
if(!str::startswith(attrname_,"user.mergerfs."))
return -ENOATTR;
key = &attrname[14];
rv = config.get(key,&val);
key = &attrname_[14];
rv = config_.get(key,&val);
if(rv < 0)
return rv;
len = val.size();
if(count == 0)
if(count_ == 0)
return len;
if(count < len)
if(count_ < len)
return -ERANGE;
memcpy(buf,val.c_str(),len);
memcpy(buf_,val.c_str(),len);
return (int)len;
}
static
int
getxattr_from_string(char *destbuf,
const size_t destbufsize,
const string &src)
getxattr_from_string(char *destbuf_,
const size_t destbufsize_,
const string &src_)
{
const size_t srcbufsize = src.size();
const size_t srcbufsize = src_.size();
if(destbufsize == 0)
if(destbufsize_ == 0)
return srcbufsize;
if(srcbufsize > destbufsize)
if(srcbufsize > destbufsize_)
return -ERANGE;
memcpy(destbuf,src.data(),srcbufsize);
memcpy(destbuf_,src_.data(),srcbufsize);
return srcbufsize;
}
@ -117,9 +117,9 @@ namespace l
static
int
getxattr_user_mergerfs_allpaths(const Branches &branches_,
const char *fusepath,
char *buf,
const size_t count)
const char *fusepath_,
char *buf_,
const size_t count_)
{
string concated;
vector<string> paths;
@ -127,90 +127,90 @@ namespace l
branches_.to_paths(branches);
fs::findallfiles(branches,fusepath,paths);
fs::findallfiles(branches,fusepath_,&paths);
concated = str::join(paths,'\0');
return l::getxattr_from_string(buf,count,concated);
return l::getxattr_from_string(buf_,count_,concated);
}
static
int
getxattr_user_mergerfs(const string &basepath,
const char *fusepath,
const string &fullpath,
getxattr_user_mergerfs(const string &basepath_,
const char *fusepath_,
const string &fullpath_,
const Branches &branches_,
const char *attrname,
char *buf,
const size_t count)
const char *attrname_,
char *buf_,
const size_t count_)
{
vector<string> attr;
str::split(attr,attrname,'.');
str::split(attrname_,'.',&attr);
if(attr[2] == "basepath")
return l::getxattr_from_string(buf,count,basepath);
return l::getxattr_from_string(buf_,count_,basepath_);
else if(attr[2] == "relpath")
return l::getxattr_from_string(buf,count,fusepath);
return l::getxattr_from_string(buf_,count_,fusepath_);
else if(attr[2] == "fullpath")
return l::getxattr_from_string(buf,count,fullpath);
return l::getxattr_from_string(buf_,count_,fullpath_);
else if(attr[2] == "allpaths")
return l::getxattr_user_mergerfs_allpaths(branches_,fusepath,buf,count);
return l::getxattr_user_mergerfs_allpaths(branches_,fusepath_,buf_,count_);
return -ENOATTR;
}
static
int
getxattr(Policy::Func::Search searchFunc,
getxattr(Policy::Func::Search searchFunc_,
const Branches &branches_,
const size_t minfreespace,
const char *fusepath,
const char *attrname,
char *buf,
const size_t count)
const size_t minfreespace_,
const char *fusepath_,
const char *attrname_,
char *buf_,
const size_t count_)
{
int rv;
string fullpath;
vector<string> basepaths;
rv = searchFunc(branches_,fusepath,minfreespace,&basepaths);
rv = searchFunc_(branches_,fusepath_,minfreespace_,&basepaths);
if(rv == -1)
return -errno;
fullpath = fs::path::make(basepaths[0],fusepath);
fullpath = fs::path::make(basepaths[0],fusepath_);
if(str::startswith(attrname,"user.mergerfs."))
if(str::startswith(attrname_,"user.mergerfs."))
return l::getxattr_user_mergerfs(basepaths[0],
fusepath,
fusepath_,
fullpath,
branches_,
attrname,
buf,
count);
attrname_,
buf_,
count_);
return l::lgetxattr(fullpath,attrname,buf,count);
return l::lgetxattr(fullpath,attrname_,buf_,count_);
}
}
namespace FUSE
{
int
getxattr(const char *fusepath,
const char *attrname,
char *buf,
size_t count)
getxattr(const char *fusepath_,
const char *attrname_,
char *buf_,
size_t count_)
{
const Config &config = Config::ro();
if(fusepath == config.controlfile)
if(fusepath_ == config.controlfile)
return l::getxattr_controlfile(config,
attrname,
buf,
count);
attrname_,
buf_,
count_);
if((config.security_capability == false) &&
l::is_attrname_security_capability(attrname))
l::is_attrname_security_capability(attrname_))
return -ENOATTR;
if(config.xattr.to_int())
@ -222,9 +222,9 @@ namespace FUSE
return l::getxattr(config.func.getxattr.policy,
config.branches,
config.minfreespace,
fusepath,
attrname,
buf,
count);
fusepath_,
attrname_,
buf_,
count_);
}
}

8
src/fuse_getxattr.hpp
View File

@ -19,8 +19,8 @@
namespace FUSE
{
int
getxattr(const char *fusepath_,
const char *attrname_,
char *buf_,
size_t count_);
getxattr(const char *fusepath,
const char *attrname,
char *buf,
size_t count);
}

2
src/fuse_init.hpp
View File

@ -21,5 +21,5 @@
namespace FUSE
{
void *
init(fuse_conn_info *conn_);
init(fuse_conn_info *conn);
}

2
src/fuse_ioctl.cpp
View File

@ -344,7 +344,7 @@ namespace l
config.branches.to_paths(branches);
fs::findallfiles(branches,fusepath.c_str(),paths);
fs::findallfiles(branches,fusepath.c_str(),&paths);
concated = str::join(paths,'\0');

12
src/fuse_ioctl.hpp
View File

@ -21,10 +21,10 @@
namespace FUSE
{
int
ioctl(unsigned long cmd_,
void *arg_,
fuse_file_info *ffi_,
unsigned int flags_,
void *data_,
uint32_t *out_bufsz_);
ioctl(unsigned long cmd,
void *arg,
fuse_file_info *ffi,
unsigned int flags,
void *data,
uint32_t *out_bufsz);
}

8
src/fuse_link.cpp
View File

@ -44,8 +44,8 @@ namespace l
string oldfullpath;
string newfullpath;
oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_);
newfullpath = fs::path::make(&oldbasepath_,newfusepath_);
oldfullpath = fs::path::make(oldbasepath_,oldfusepath_);
newfullpath = fs::path::make(oldbasepath_,newfusepath_);
rv = fs::link(oldfullpath,newfullpath);
@ -152,8 +152,8 @@ namespace l
string oldfullpath;
string newfullpath;
oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_);
newfullpath = fs::path::make(&oldbasepath_,newfusepath_);
oldfullpath = fs::path::make(oldbasepath_,oldfusepath_);
newfullpath = fs::path::make(oldbasepath_,newfusepath_);
rv = fs::link(oldfullpath,newfullpath);
if((rv == -1) && (errno == ENOENT))

4
src/fuse_link.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
link(const char *from_,
const char *to_);
link(const char *from,
const char *to);
}

6
src/fuse_listxattr.hpp
View File

@ -19,7 +19,7 @@
namespace FUSE
{
int
listxattr(const char *fusepath_,
char *buf_,
size_t count_);
listxattr(const char *fusepath,
char *buf,
size_t count);
}

4
src/fuse_mkdir.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
mkdir(const char *fusepath_,
mode_t mode_);
mkdir(const char *fusepath,
mode_t mode);
}

2
src/fuse_mknod.cpp
View File

@ -59,7 +59,7 @@ namespace l
int rv;
string fullpath;
fullpath = fs::path::make(&createpath_,fusepath_);
fullpath = fs::path::make(createpath_,fusepath_);
rv = l::mknod_core(fullpath,mode_,umask_,dev_);

6
src/fuse_mknod.hpp
View File

@ -20,7 +20,7 @@
namespace FUSE
{
int
mknod(const char *fusepath_,
mode_t mode_,
dev_t rdev_);
mknod(const char *fusepath,
mode_t mode,
dev_t rdev);
}

4
src/fuse_open.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
open(const char *fusepath_,
fuse_file_info *ffi_);
open(const char *fusepath,
fuse_file_info *ffi);
}

4
src/fuse_opendir.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
opendir(const char *fusepath_,
fuse_file_info *ffi_);
opendir(const char *fusepath,
fuse_file_info *ffi);
}

4
src/fuse_prepare_hide.hpp
View File

@ -23,6 +23,6 @@
namespace FUSE
{
int
prepare_hide(const char *name_,
uint64_t *fh_);
prepare_hide(const char *name,
uint64_t *fh);
}

16
src/fuse_read.hpp
View File

@ -21,14 +21,14 @@
namespace FUSE
{
int
read(char *buf_,
size_t count_,
off_t offset_,
fuse_file_info *ffi_);
read(char *buf,
size_t count,
off_t offset,
fuse_file_info *ffi);
int
read_null(char *buf_,
size_t count_,
off_t offset_,
fuse_file_info *ffi_);
read_null(char *buf,
size_t count,
off_t offset,
fuse_file_info *ffi);
}

8
src/fuse_read_buf.hpp
View File

@ -23,8 +23,8 @@
namespace FUSE
{
int
read_buf(struct fuse_bufvec **buf_,
size_t size_,
off_t offset_,
fuse_file_info *ffi_);
read_buf(struct fuse_bufvec **buf,
size_t size,
off_t offset,
fuse_file_info *ffi);
}

4
src/fuse_readdir.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
readdir(fuse_file_info *ffi_,
fuse_dirents_t *buf_);
readdir(fuse_file_info *ffi,
fuse_dirents_t *buf);
}

4
src/fuse_readdir_linux.cpp
View File

@ -74,7 +74,7 @@ namespace l
int dirfd;
int64_t nread;
basepath = fs::path::make(&branches_[i].path,dirname_);
basepath = fs::path::make(branches_[i].path,dirname_);
dirfd = fs::open_dir_ro(basepath);
if(dirfd == -1)
@ -86,7 +86,7 @@ namespace l
for(;;)
{
nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size());
nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size());
if(nread == -1)
break;
if(nread == 0)

4
src/fuse_readdir_plus.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
readdir_plus(fuse_file_info *ffi_,
fuse_dirents_t *buf_);
readdir_plus(fuse_file_info *ffi,
fuse_dirents_t *buf);
}

4
src/fuse_readdir_plus_linux.cpp
View File

@ -83,7 +83,7 @@ namespace l
int dirfd;
int64_t nread;
basepath = fs::path::make(&branches_[i].path,dirname_);
basepath = fs::path::make(branches_[i].path,dirname_);
dirfd = fs::open_dir_ro(basepath);
if(dirfd == -1)
@ -95,7 +95,7 @@ namespace l
for(;;)
{
nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size());
nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size());
if(nread == -1)
break;
if(nread == 0)

10
src/fuse_readdir_plus_linux.hpp
View File

@ -27,9 +27,9 @@
namespace FUSE
{
int
readdir_plus_linux(const Branches &branches_,
const char *dirname_,
const uint64_t entry_timeout_,
const uint64_t attr_timeout_,
fuse_dirents_t *buf_);
readdir_plus_linux(const Branches &branches,
const char *dirname,
const uint64_t entry_timeout,
const uint64_t attr_timeout,
fuse_dirents_t *buf);
}

2
src/fuse_readdir_plus_posix.cpp
View File

@ -83,7 +83,7 @@ namespace l
int dirfd;
DIR *dh;
basepath = fs::path::make(&branches_[i].path,dirname_);
basepath = fs::path::make(branches_[i].path,dirname_);
dh = fs::opendir(basepath);
if(!dh)

10
src/fuse_readdir_plus_posix.hpp
View File

@ -27,9 +27,9 @@
namespace FUSE
{
int
readdir_plus_posix(const Branches &branches_,
const char *dirname_,
const uint64_t entry_timeout_,
const uint64_t attr_timeout_,
fuse_dirents_t *buf_);
readdir_plus_posix(const Branches &branches,
const char *dirname,
const uint64_t entry_timeout,
const uint64_t attr_timeout,
fuse_dirents_t *buf);
}

2
src/fuse_readdir_posix.cpp
View File

@ -72,7 +72,7 @@ namespace l
int dirfd;
DIR *dh;
basepath = fs::path::make(&branches_[i].path,dirname_);
basepath = fs::path::make(branches_[i].path,dirname_);
dh = fs::opendir(basepath);
if(!dh)

6
src/fuse_readlink.hpp
View File

@ -19,7 +19,7 @@
namespace FUSE
{
int
readlink(const char *fusepath_,
char *buf_,
size_t size_);
readlink(const char *fusepath,
char *buf,
size_t size);
}

2
src/fuse_release.hpp
View File

@ -21,5 +21,5 @@
namespace FUSE
{
int
release(fuse_file_info *ffi_);
release(fuse_file_info *ffi);
}

2
src/fuse_releasedir.hpp
View File

@ -21,5 +21,5 @@
namespace FUSE
{
int
releasedir(fuse_file_info *ffi_);
releasedir(fuse_file_info *ffi);
}

4
src/fuse_removexattr.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
removexattr(const char *fusepath_,
const char *attrname_);
removexattr(const char *fusepath,
const char *attrname);
}

4
src/fuse_rename.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
rename(const char *from_,
const char *to_);
rename(const char *from,
const char *to);
}

2
src/fuse_rmdir.hpp
View File

@ -19,5 +19,5 @@
namespace FUSE
{
int
rmdir(const char *fusepath_);
rmdir(const char *fusepath);
}

10
src/fuse_setxattr.hpp
View File

@ -19,9 +19,9 @@
namespace FUSE
{
int
setxattr(const char *fusepath_,
const char *attrname_,
const char *attrval_,
size_t attrvalsize_,
int flags_);
setxattr(const char *fusepath,
const char *attrname,
const char *attrval,
size_t attrvalize,
int flags);
}

2
src/fuse_statfs.cpp
View File

@ -99,7 +99,7 @@ namespace l
for(size_t i = 0, ei = branches_.size(); i < ei; i++)
{
fullpath = ((mode_ == StatFS::ENUM::FULL) ?
fs::path::make(&branches_[i].path,fusepath_) :
fs::path::make(branches_[i].path,fusepath_) :
branches_[i].path);
rv = fs::lstat(fullpath,&st);

4
src/fuse_statfs.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
statfs(const char *fusepath_,
struct statvfs *fsstat_);
statfs(const char *fusepath,
struct statvfs *fsstat);
}

2
src/fuse_symlink.cpp
View File

@ -44,7 +44,7 @@ namespace l
int rv;
string fullnewpath;
fullnewpath = fs::path::make(&newbasepath_,newpath_);
fullnewpath = fs::path::make(newbasepath_,newpath_);
rv = fs::symlink(oldpath_,fullnewpath);

4
src/fuse_symlink.hpp
View File

@ -19,6 +19,6 @@
namespace FUSE
{
int
symlink(const char *oldpath_,
const char *newpath_);
symlink(const char *oldpath,
const char *newpath);
}

4
src/fuse_truncate.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
truncate(const char *fusepath_,
off_t size_);
truncate(const char *fusepath,
off_t size);
}

2
src/fuse_unlink.hpp
View File

@ -19,5 +19,5 @@
namespace FUSE
{
int
unlink(const char *fusepath_);
unlink(const char *fusepath);
}

4
src/fuse_utimens.hpp
View File

@ -21,6 +21,6 @@
namespace FUSE
{
int
utimens(const char *fusepath_,
const timespec ts_[2]);
utimens(const char *fusepath,
const timespec ts[2]);
}

16
src/fuse_write.hpp
View File

@ -21,14 +21,14 @@
namespace FUSE
{
int
write(const char *buf_,
size_t count_,
off_t offset_,
fuse_file_info *ffi_);
write(const char *buf,
size_t count,
off_t offset,
fuse_file_info *ffi);
int
write_null(const char *buf_,
size_t count_,
off_t offset_,
fuse_file_info *ffi_);
write_null(const char *buf,
size_t count,
off_t offset,
fuse_file_info *ffi);
}

12
src/fuse_write_buf.hpp
View File

@ -23,12 +23,12 @@
namespace FUSE
{
int
write_buf(struct fuse_bufvec *buf_,
off_t offset_,
fuse_file_info *ffi_);
write_buf(struct fuse_bufvec *buf,
off_t offset,
fuse_file_info *ffi);
int
write_buf_null(struct fuse_bufvec *buf_,
off_t offset_,
fuse_file_info *ffi_);
write_buf_null(struct fuse_bufvec *buf,
off_t offset,
fuse_file_info *ffi);
}

110
src/mergerfs.cpp
View File

@ -77,59 +77,59 @@ namespace l
{
static
void
get_fuse_operations(struct fuse_operations &ops,
const bool nullrw)
get_fuse_operations(struct fuse_operations &ops_,
const bool nullrw_)
{
ops.access = FUSE::access;
ops.bmap = NULL;
ops.chmod = FUSE::chmod;
ops.chown = FUSE::chown;
ops.copy_file_range = FUSE::copy_file_range;
ops.create = FUSE::create;
ops.destroy = FUSE::destroy;
ops.fallocate = FUSE::fallocate;
ops.fchmod = FUSE::fchmod;
ops.fchown = FUSE::fchown;
ops.fgetattr = FUSE::fgetattr;
ops.flock = NULL; // FUSE::flock;
ops.flush = FUSE::flush;
ops.free_hide = FUSE::free_hide;
ops.fsync = FUSE::fsync;
ops.fsyncdir = FUSE::fsyncdir;
ops.ftruncate = FUSE::ftruncate;
ops.futimens = FUSE::futimens;
ops.getattr = FUSE::getattr;
ops.getxattr = FUSE::getxattr;
ops.init = FUSE::init;
ops.ioctl = FUSE::ioctl;
ops.link = FUSE::link;
ops.listxattr = FUSE::listxattr;
ops.lock = NULL;
ops.mkdir = FUSE::mkdir;
ops.mknod = FUSE::mknod;
ops.open = FUSE::open;
ops.opendir = FUSE::opendir;
ops.poll = NULL;
ops.prepare_hide = FUSE::prepare_hide;
ops.read = (nullrw ? FUSE::read_null : FUSE::read);
ops.read_buf = (nullrw ? NULL : FUSE::read_buf);
ops.readdir = FUSE::readdir;
ops.readdir_plus = FUSE::readdir_plus;
ops.readlink = FUSE::readlink;
ops.release = FUSE::release;
ops.releasedir = FUSE::releasedir;
ops.removexattr = FUSE::removexattr;
ops.rename = FUSE::rename;
ops.rmdir = FUSE::rmdir;
ops.setxattr = FUSE::setxattr;
ops.statfs = FUSE::statfs;
ops.symlink = FUSE::symlink;
ops.truncate = FUSE::truncate;
ops.unlink = FUSE::unlink;
ops.utime = NULL; /* deprecated; use utimens() */
ops.utimens = FUSE::utimens;
ops.write = (nullrw ? FUSE::write_null : FUSE::write);
ops.write_buf = (nullrw ? FUSE::write_buf_null : FUSE::write_buf);
ops_.access = FUSE::access;
ops_.bmap = NULL;
ops_.chmod = FUSE::chmod;
ops_.chown = FUSE::chown;
ops_.copy_file_range = FUSE::copy_file_range;
ops_.create = FUSE::create;
ops_.destroy = FUSE::destroy;
ops_.fallocate = FUSE::fallocate;
ops_.fchmod = FUSE::fchmod;
ops_.fchown = FUSE::fchown;
ops_.fgetattr = FUSE::fgetattr;
ops_.flock = NULL; // FUSE::flock;
ops_.flush = FUSE::flush;
ops_.free_hide = FUSE::free_hide;
ops_.fsync = FUSE::fsync;
ops_.fsyncdir = FUSE::fsyncdir;
ops_.ftruncate = FUSE::ftruncate;
ops_.futimens = FUSE::futimens;
ops_.getattr = FUSE::getattr;
ops_.getxattr = FUSE::getxattr;
ops_.init = FUSE::init;
ops_.ioctl = FUSE::ioctl;
ops_.link = FUSE::link;
ops_.listxattr = FUSE::listxattr;
ops_.lock = NULL;
ops_.mkdir = FUSE::mkdir;
ops_.mknod = FUSE::mknod;
ops_.open = FUSE::open;
ops_.opendir = FUSE::opendir;
ops_.poll = NULL;
ops_.prepare_hide = FUSE::prepare_hide;
ops_.read = (nullrw_ ? FUSE::read_null : FUSE::read);
ops_.read_buf = (nullrw_ ? NULL : FUSE::read_buf);
ops_.readdir = FUSE::readdir;
ops_.readdir_plus = FUSE::readdir_plus;
ops_.readlink = FUSE::readlink;
ops_.release = FUSE::release;
ops_.releasedir = FUSE::releasedir;
ops_.removexattr = FUSE::removexattr;
ops_.rename = FUSE::rename;
ops_.rmdir = FUSE::rmdir;
ops_.setxattr = FUSE::setxattr;
ops_.statfs = FUSE::statfs;
ops_.symlink = FUSE::symlink;
ops_.truncate = FUSE::truncate;
ops_.unlink = FUSE::unlink;
ops_.utime = NULL; /* deprecated; use utimens() */
ops_.utimens = FUSE::utimens;
ops_.write = (nullrw_ ? FUSE::write_null : FUSE::write);
ops_.write_buf = (nullrw_ ? FUSE::write_buf_null : FUSE::write_buf);
return;
}
@ -182,8 +182,8 @@ namespace l
}
int
main(int argc,
char **argv)
main(int argc_,
char **argv_)
{
return l::main(argc,argv);
return l::main(argc_,argv_);
}

6
src/num.hpp
View File

@ -22,7 +22,7 @@
namespace num
{
int to_uint64_t(const std::string &str_, uint64_t &value_);
int to_double(const std::string &str_, double *value_);
int to_time_t(const std::string &str_, time_t &value_);
int to_uint64_t(const std::string &str, uint64_t *value);
int to_double(const std::string &str, double *value);
int to_time_t(const std::string &str, time_t *value);
}

2
src/policy_all.cpp
View File

@ -50,7 +50,7 @@ namespace all
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)

14
src/policy_cache.hpp
View File

@ -41,16 +41,16 @@ public:
PolicyCache(void);
public:
void erase(const char *fusepath_);
void cleanup(const int prob_ = 1);
void erase(const char *fusepath);
void cleanup(const int prob = 1);
void clear(void);
public:
int operator()(Policy::Func::Search &func_,
const Branches &branches_,
const char *fusepath_,
const uint64_t minfreespace_,
std::string *branch_);
int operator()(Policy::Func::Search &func,
const Branches &branches,
const char *fusepath,
const uint64_t minfreespace,
std::string *branch);
public:
uint64_t timeout;

52
src/policy_epall.cpp
View File

@ -35,9 +35,9 @@ namespace epall
static
int
create(const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -51,22 +51,22 @@ namespace epall
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
error_and_continue(error,EROFS);
if(info.spaceavail < minfreespace)
if(info.spaceavail < minfreespace_)
error_and_continue(error,ENOSPC);
paths->push_back(branch->path);
paths_->push_back(branch->path);
}
if(paths->empty())
if(paths_->empty())
return (errno=error,-1);
return 0;
@ -75,8 +75,8 @@ namespace epall
static
int
action(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -90,7 +90,7 @@ namespace epall
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro())
error_and_continue(error,EROFS);
@ -100,10 +100,10 @@ namespace epall
if(readonly)
error_and_continue(error,EROFS);
paths->push_back(branch->path);
paths_->push_back(branch->path);
}
if(paths->empty())
if(paths_->empty())
return (errno=error,-1);
return 0;
@ -112,8 +112,8 @@ namespace epall
static
int
search(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -123,13 +123,13 @@ namespace epall
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
continue;
paths->push_back(branch->path);
paths_->push_back(branch->path);
}
if(paths->empty())
if(paths_->empty())
return (errno=ENOENT,-1);
return 0;
@ -137,20 +137,20 @@ namespace epall
}
int
Policy::Func::epall(const Category type,
Policy::Func::epall(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
switch(type)
switch(type_)
{
case Category::CREATE:
return epall::create(branches_,fusepath,minfreespace,paths);
return epall::create(branches_,fusepath_,minfreespace_,paths_);
case Category::ACTION:
return epall::action(branches_,fusepath,paths);
return epall::action(branches_,fusepath_,paths_);
case Category::SEARCH:
default:
return epall::search(branches_,fusepath,paths);
return epall::search(branches_,fusepath_,paths_);
}
}

2
src/policy_epff.cpp
View File

@ -55,7 +55,7 @@ namespace epff
error_and_continue(error,ENOENT);
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)

48
src/policy_eplfs.cpp
View File

@ -36,9 +36,9 @@ namespace eplfs
static
int
create(const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -56,16 +56,16 @@ namespace eplfs
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
error_and_continue(error,EROFS);
if(info.spaceavail < minfreespace)
if(info.spaceavail < minfreespace_)
error_and_continue(error,ENOSPC);
if(info.spaceavail > eplfs)
continue;
@ -77,7 +77,7 @@ namespace eplfs
if(eplfsbasepath == NULL)
return (errno=error,-1);
paths->push_back(*eplfsbasepath);
paths_->push_back(*eplfsbasepath);
return 0;
}
@ -85,8 +85,8 @@ namespace eplfs
static
int
action(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -104,11 +104,11 @@ namespace eplfs
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
@ -123,7 +123,7 @@ namespace eplfs
if(eplfsbasepath == NULL)
return (errno=error,-1);
paths->push_back(*eplfsbasepath);
paths_->push_back(*eplfsbasepath);
return 0;
}
@ -131,8 +131,8 @@ namespace eplfs
static
int
search(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -148,7 +148,7 @@ namespace eplfs
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
continue;
rv = fs::statvfs_cache_spaceavail(branch->path,&spaceavail);
if(rv == -1)
@ -163,27 +163,27 @@ namespace eplfs
if(eplfsbasepath == NULL)
return (errno=ENOENT,-1);
paths->push_back(*eplfsbasepath);
paths_->push_back(*eplfsbasepath);
return 0;
}
}
int
Policy::Func::eplfs(const Category type,
Policy::Func::eplfs(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
switch(type)
switch(type_)
{
case Category::CREATE:
return eplfs::create(branches_,fusepath,minfreespace,paths);
return eplfs::create(branches_,fusepath_,minfreespace_,paths_);
case Category::ACTION:
return eplfs::action(branches_,fusepath,paths);
return eplfs::action(branches_,fusepath_,paths_);
case Category::SEARCH:
default:
return eplfs::search(branches_,fusepath,paths);
return eplfs::search(branches_,fusepath_,paths_);
}
}

48
src/policy_eplus.cpp
View File

@ -36,9 +36,9 @@ namespace eplus
static
int
create(const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -56,16 +56,16 @@ namespace eplus
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
error_and_continue(error,EROFS);
if(info.spaceavail < minfreespace)
if(info.spaceavail < minfreespace_)
error_and_continue(error,ENOSPC);
if(info.spaceused >= eplus)
continue;
@ -77,7 +77,7 @@ namespace eplus
if(eplusbasepath == NULL)
return (errno=error,-1);
paths->push_back(*eplusbasepath);
paths_->push_back(*eplusbasepath);
return 0;
}
@ -85,8 +85,8 @@ namespace eplus
static
int
action(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -104,11 +104,11 @@ namespace eplus
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
error_and_continue(error,ENOENT);
if(branch->ro())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
@ -123,7 +123,7 @@ namespace eplus
if(eplusbasepath == NULL)
return (errno=error,-1);
paths->push_back(*eplusbasepath);
paths_->push_back(*eplusbasepath);
return 0;
}
@ -131,8 +131,8 @@ namespace eplus
static
int
search(const Branches &branches_,
const char *fusepath,
vector<string> *paths)
const char *fusepath_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -148,7 +148,7 @@ namespace eplus
{
branch = &branches_[i];
if(!fs::exists(branch->path,fusepath))
if(!fs::exists(branch->path,fusepath_))
continue;
rv = fs::statvfs_cache_spaceused(branch->path,&spaceused);
if(rv == -1)
@ -163,27 +163,27 @@ namespace eplus
if(eplusbasepath == NULL)
return (errno=ENOENT,-1);
paths->push_back(*eplusbasepath);
paths_->push_back(*eplusbasepath);
return 0;
}
}
int
Policy::Func::eplus(const Category type,
Policy::Func::eplus(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
switch(type)
switch(type_)
{
case Category::CREATE:
return eplus::create(branches_,fusepath,minfreespace,paths);
return eplus::create(branches_,fusepath_,minfreespace_,paths_);
case Category::ACTION:
return eplus::action(branches_,fusepath,paths);
return eplus::action(branches_,fusepath_,paths_);
case Category::SEARCH:
default:
return eplus::search(branches_,fusepath,paths);
return eplus::search(branches_,fusepath_,paths_);
}
}

4
src/policy_epmfs.cpp
View File

@ -60,7 +60,7 @@ namespace epmfs
error_and_continue(error,ENOENT);
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
@ -108,7 +108,7 @@ namespace epmfs
error_and_continue(error,ENOENT);
if(branch->ro())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)

24
src/policy_ff.cpp
View File

@ -34,8 +34,8 @@ namespace ff
static
int
create(const Branches &branches_,
const uint64_t minfreespace,
vector<string> *paths)
const uint64_t minfreespace_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -51,15 +51,15 @@ namespace ff
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
error_and_continue(error,EROFS);
if(info.spaceavail < minfreespace)
if(info.spaceavail < minfreespace_)
error_and_continue(error,ENOSPC);
paths->push_back(branch->path);
paths_->push_back(branch->path);
return 0;
}
@ -69,14 +69,14 @@ namespace ff
}
int
Policy::Func::ff(const Category type,
Policy::Func::ff(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
if(type == Category::CREATE)
return ff::create(branches_,minfreespace,paths);
if(type_ == Category::CREATE)
return ff::create(branches_,minfreespace_,paths_);
return Policy::Func::epff(type,branches_,fusepath,minfreespace,paths);
return Policy::Func::epff(type_,branches_,fusepath_,minfreespace_,paths_);
}

16
src/policy_lfs.cpp
View File

@ -56,7 +56,7 @@ namespace lfs
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
@ -80,14 +80,14 @@ namespace lfs
}
int
Policy::Func::lfs(const Category type,
Policy::Func::lfs(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
if(type == Category::CREATE)
return lfs::create(branches_,minfreespace,paths);
if(type_ == Category::CREATE)
return lfs::create(branches_,minfreespace_,paths_);
return Policy::Func::eplfs(type,branches_,fusepath,minfreespace,paths);
return Policy::Func::eplfs(type_,branches_,fusepath_,minfreespace_,paths_);
}

24
src/policy_lus.cpp
View File

@ -35,8 +35,8 @@ namespace lus
static
int
create(const Branches &branches_,
const uint64_t minfreespace,
vector<string> *paths)
const uint64_t minfreespace_,
vector<string> *paths_)
{
rwlock::ReadGuard guard(&branches_.lock);
@ -56,12 +56,12 @@ namespace lus
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
error_and_continue(error,EROFS);
if(info.spaceavail < minfreespace)
if(info.spaceavail < minfreespace_)
error_and_continue(error,ENOSPC);
if(info.spaceused >= lus)
continue;
@ -73,21 +73,21 @@ namespace lus
if(lusbasepath == NULL)
return (errno=error,-1);
paths->push_back(*lusbasepath);
paths_->push_back(*lusbasepath);
return 0;
}
}
int
Policy::Func::lus(const Category type,
Policy::Func::lus(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
if(type == Category::CREATE)
return lus::create(branches_,minfreespace,paths);
if(type_ == Category::CREATE)
return lus::create(branches_,minfreespace_,paths_);
return Policy::Func::eplus(type,branches_,fusepath,minfreespace,paths);
return Policy::Func::eplus(type_,branches_,fusepath_,minfreespace_,paths_);
}

16
src/policy_mfs.cpp
View File

@ -55,7 +55,7 @@ namespace mfs
if(branch->ro_or_nc())
error_and_continue(error,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(error,ENOENT);
if(info.readonly)
@ -79,14 +79,14 @@ namespace mfs
}
int
Policy::Func::mfs(const Category type,
Policy::Func::mfs(const Category type_,
const Branches &branches_,
const char *fusepath,
const uint64_t minfreespace,
vector<string> *paths)
const char *fusepath_,
const uint64_t minfreespace_,
vector<string> *paths_)
{
if(type == Category::CREATE)
return mfs::create(branches_,minfreespace,paths);
if(type_ == Category::CREATE)
return mfs::create(branches_,minfreespace_,paths_);
return Policy::Func::epmfs(type,branches_,fusepath,minfreespace,paths);
return Policy::Func::epmfs(type_,branches_,fusepath_,minfreespace_,paths_);
}

2
src/policy_msplfs.cpp
View File

@ -59,7 +59,7 @@ namespace msplfs
error_and_continue(*err_,ENOENT);
if(branch->ro_or_nc())
error_and_continue(*err_,EROFS);
rv = fs::info(&branch->path,&info);
rv = fs::info(branch->path,&info);
if(rv == -1)
error_and_continue(*err_,ENOENT);
if(info.readonly)

Some files were not shown because too many files have changed in this diff Show More