stop auto calculating and storing fullpath in policies

10 years ago · b2cd79154a
37 changed files with 279 additions and 260 deletions
--- a/src/access.cpp
+++ b/src/access.cpp
@ -53,13 +53,15 @@ _access(Policy::Func::Search  searchFunc,
        const int             mask)
 {
  int rv;
-  Paths paths;
+  vector<string> path;

-  rv = searchFunc(srcmounts,fusepath,minfreespace,paths);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  rv = ::eaccess(paths[0].full.c_str(),mask);
+  fs::path::append(path[0],fusepath);
+
+  rv = ::eaccess(path[0].c_str(),mask);

  return ((rv == -1) ? -errno : 0);
 }
--- a/src/chmod.cpp
+++ b/src/chmod.cpp
@ -47,7 +47,7 @@ _chmod(Policy::Func::Action  actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -56,7 +56,9 @@ _chmod(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::chmod(paths[i].full.c_str(),mode);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::chmod(paths[i].c_str(),mode);
      if(rv == -1)
        error = errno;
    }
--- a/src/chown.cpp
+++ b/src/chown.cpp
@ -49,7 +49,7 @@ _chown(Policy::Func::Action  actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -58,7 +58,9 @@ _chown(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::lchown(paths[i].full.c_str(),uid,gid);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::lchown(paths[i].c_str(),uid,gid);
      if(rv == -1)
        error = errno;
    }
--- a/src/create.cpp
+++ b/src/create.cpp
@ -54,12 +54,11 @@ _create(Policy::Func::Search  searchFunc,
 {
  int fd;
  int rv;
-  string path;
  string dirname;
-  Paths createpath;
-  Paths existingpath;
+  vector<string> createpath;
+  vector<string> existingpath;

-  dirname = fs::dirname(fusepath);
+  dirname = fs::path::dirname(fusepath);
  rv = searchFunc(srcmounts,dirname,minfreespace,existingpath);
  if(rv == -1)
    return -errno;
@ -68,15 +67,15 @@ _create(Policy::Func::Search  searchFunc,
  if(rv == -1)
    return -errno;

-  if(createpath[0].base != existingpath[0].base)
+  if(createpath[0] != existingpath[0])
    {
      const mergerfs::ugid::SetResetGuard ugid(0,0);
-      fs::clonepath(existingpath[0].base,createpath[0].base,dirname);
+      fs::clonepath(existingpath[0],createpath[0],dirname);
    }

-  path = fs::make_path(createpath[0].base,fusepath);
+  fs::path::append(createpath[0],fusepath);

-  fd = ::open(path.c_str(),flags,mode);
+  fd = ::open(createpath[0].c_str(),flags,mode);
  if(fd == -1)
    return -errno;

--- a/src/fs.cpp
+++ b/src/fs.cpp
@ -63,102 +63,85 @@ random_element(Iter begin,

 namespace fs
 {
-  string
-  dirname(const string &path)
+  namespace path
  {
-    string parent = path;
-    string::reverse_iterator i;
-    string::reverse_iterator bi;
-
-    bi = parent.rend();
-    i  = parent.rbegin();
-    while(*i == '/' && i != bi)
-      i++;
+    string
+    dirname(const string &path)
+    {
+      string parent = path;
+      string::reverse_iterator i;
+      string::reverse_iterator bi;

-    while(*i != '/' && i != bi)
-      i++;
+      bi = parent.rend();
+      i  = parent.rbegin();
+      while(*i == '/' && i != bi)
+        i++;

-    while(*i == '/' && i != bi)
-      i++;
+      while(*i != '/' && i != bi)
+        i++;

-    parent.erase(i.base(),parent.end());
+      while(*i == '/' && i != bi)
+        i++;

-    return parent;
-  }
+      parent.erase(i.base(),parent.end());

-  string
-  basename(const string &path)
-  {
-    return path.substr(path.find_last_of('/')+1);
-  }
+      return parent;
+    }

-  bool
-  dir_is_empty(const string &path)
-  {
-    DIR           *dir;
-    struct dirent *de;
+    string
+    basename(const string &path)
+    {
+      return path.substr(path.find_last_of('/')+1);
+    }

-    dir = ::opendir(path.c_str());
-    if(!dir)
-      return false;
+    bool
+    is_empty(const string &path)
+    {
+      DIR           *dir;
+      struct dirent *de;

-    while((de = ::readdir(dir)))
-      {
-        const char *d_name = de->d_name;
+      dir = ::opendir(path.c_str());
+      if(!dir)
+        return false;

-        if(d_name[0] == '.'     &&
-           ((d_name[1] == '\0') ||
-            (d_name[1] == '.' && d_name[2] == '\0')))
-          continue;
+      while((de = ::readdir(dir)))
+        {
+          const char *d_name = de->d_name;

-        ::closedir(dir);
+          if(d_name[0] == '.'     &&
+             ((d_name[1] == '\0') ||
+              (d_name[1] == '.' && d_name[2] == '\0')))
+            continue;

-        return false;
-      }
+          ::closedir(dir);

-    ::closedir(dir);
+          return false;
+        }

-    return true;
-  }
+      ::closedir(dir);

-  string
-  make_path(const string &base,
-            const string &suffix)
-  {
-    if(suffix[0]      == '/' ||
-       *base.rbegin() == '/')
-      return base + suffix;
-    return base + '/' + suffix;
-  }
+      return true;
+    }

-  bool
-  path_exists(vector<string>::const_iterator  begin,
-              vector<string>::const_iterator  end,
-              const string                   &fusepath)
-  {
-    for(vector<string>::const_iterator
-          iter = begin; iter != end; ++iter)
-      {
-        int         rv;
-        string      path;
-        struct stat st;
+    bool
+    exists(const vector<string> &paths,
+           const string         &fusepath)
+    {
+      for(size_t i = 0, ei = paths.size(); i != ei; i++)
+        {
+          int rv;
+          string path;
+          struct stat st;

-        path = fs::make_path(*iter,fusepath);
-        rv   = ::lstat(path.c_str(),&st);
-        if(rv == 0)
-          return true;
-      }
+          path = fs::path::make(paths[i],fusepath);

-    return false;
-  }
+          rv  = ::lstat(path.c_str(),&st);
+          if(rv == 0)
+            return true;
+        }

-  bool
-  path_exists(const vector<string> &srcmounts,
-              const string         &fusepath)
-  {
-    return path_exists(srcmounts.begin(),
-                       srcmounts.end(),
-                       fusepath);
+      return false;
+    }
  }

  void
@ -166,16 +149,14 @@ namespace fs
               const string         &fusepath,
               vector<string>       &paths)
  {
-    for(vector<string>::const_iterator
-          iter = srcmounts.begin(), eiter = srcmounts.end();
-        iter != eiter;
-        ++iter)
+    for(size_t i = 0, ei = srcmounts.size(); i != ei; i++)
      {
        int rv;
        string fullpath;
        struct stat st;

-        fullpath = fs::make_path(*iter,fusepath);
+        fullpath = fs::path::make(srcmounts[i],fusepath);
+
        rv = ::lstat(fullpath.c_str(),&st);
        if(rv == 0)
          paths.push_back(fullpath);
@ -450,7 +431,7 @@ namespace fs
    string      frompath;
    string      dirname;

-    dirname = fs::dirname(relative);
+    dirname = fs::path::dirname(relative);
    if(!dirname.empty())
      {
        rv = clonepath(fromsrc,tosrc,dirname);
@ -458,15 +439,14 @@ namespace fs
          return -1;
      }

-    frompath = fs::make_path(fromsrc,relative);
-
+    frompath = fs::path::make(fromsrc,relative);
    rv = ::stat(frompath.c_str(),&st);
    if(rv == -1)
      return -1;
    else if(!S_ISDIR(st.st_mode))
      return (errno = ENOTDIR,-1);

-    topath = fs::make_path(tosrc,relative);
+    topath = fs::path::make(tosrc,relative);
    rv = ::mkdir(topath.c_str(),st.st_mode);
    if(rv == -1)
      {
--- a/src/fs.hpp
+++ b/src/fs.hpp
@ -38,19 +38,35 @@ namespace fs
  using std::vector;
  using std::map;

-  string dirname(const string &path);
-  string basename(const string &path);
-
-  bool dir_is_empty(const string &path);
-
-  string make_path(const string &base,
-                   const string &suffix);
-
-  bool path_exists(vector<string>::const_iterator  begin,
-                   vector<string>::const_iterator  end,
-                   const string                   &fusepath);
-  bool path_exists(const vector<string>           &srcmounts,
-                   const string                   &fusepath);
+  namespace path
+  {
+    string dirname(const string &path);
+    string basename(const string &path);
+
+    bool is_empty(const string &path);
+
+    bool exists(vector<string>::const_iterator  begin,
+                vector<string>::const_iterator  end,
+                const string                   &fusepath);
+    bool exists(const vector<string>           &srcmounts,
+                const string                   &fusepath);
+
+    inline
+    string
+    make(const string &base,
+         const string &suffix)
+    {
+      return base + suffix;
+    }
+
+    inline
+    void
+    append(string       &base,
+           const string &suffix)
+    {
+      base += suffix;
+    }
+  }

  void findallfiles(const vector<string> &srcmounts,
                    const string         &fusepath,
--- a/src/getattr.cpp
+++ b/src/getattr.cpp
@ -73,13 +73,15 @@ _getattr(Policy::Func::Search  searchFunc,
         struct stat          &buf)
 {
  int rv;
-  Paths path;
+  vector<string> path;

  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  rv = ::lstat(path[0].full.c_str(),&buf);
+  fs::path::append(path[0],fusepath);
+
+  rv = ::lstat(path[0].c_str(),&buf);

  return ((rv == -1) ? -errno : 0);
 }
--- a/src/getxattr.cpp
+++ b/src/getxattr.cpp
@ -167,9 +167,10 @@ _getxattr_user_mergerfs_allpaths(const vector<string> &srcmounts,

 static
 int
-_getxattr_user_mergerfs(const Path           &path,
-                        const vector<string> &srcmounts,
+_getxattr_user_mergerfs(const string         &basepath,
                        const string         &fusepath,
+                        const string         &fullpath,
+                        const vector<string> &srcmounts,
                        const char           *attrname,
                        char                 *buf,
                        const size_t          count)
@ -177,15 +178,15 @@ _getxattr_user_mergerfs(const Path           &path,
  const char *attrbasename = &attrname[sizeof("user.mergerfs")];

  if(!strcmp(attrbasename,"basepath"))
-    return ::_getxattr_from_string(buf,count,path.base);
+    return ::_getxattr_from_string(buf,count,basepath);
  else if(!strcmp(attrbasename,"fullpath"))
-    return ::_getxattr_from_string(buf,count,path.full);
+    return ::_getxattr_from_string(buf,count,fullpath);
  else if(!strcmp(attrbasename,"relpath"))
    return ::_getxattr_from_string(buf,count,fusepath);
  else if(!strcmp(attrbasename,"allpaths"))
    return ::_getxattr_user_mergerfs_allpaths(srcmounts,fusepath,buf,count);

-  return ::lgetxattr(path.full.c_str(),attrname,buf,count);
+  return ::lgetxattr(fullpath.c_str(),attrname,buf,count);
 }

 static
@ -200,16 +201,19 @@ _getxattr(Policy::Func::Search  searchFunc,
 {
 #ifndef WITHOUT_XATTR
  int rv;
-  Paths path;
+  vector<string> basepath;
+  string fullpath;

-  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepath);
  if(rv == -1)
    return -errno;

+  fullpath = fs::path::make(basepath[0],fusepath);
+
  if(!strncmp("user.mergerfs.",attrname,sizeof("user.mergerfs.")-1))
-    rv = _getxattr_user_mergerfs(path[0],srcmounts,fusepath,attrname,buf,count);
+    rv = _getxattr_user_mergerfs(basepath[0],fusepath,fullpath,srcmounts,attrname,buf,count);
  else
-    rv = ::lgetxattr(path[0].full.c_str(),attrname,buf,count);
+    rv = ::lgetxattr(fullpath.c_str(),attrname,buf,count);

  return ((rv == -1) ? -errno : rv);
 #else
--- a/src/ioctl.cpp
+++ b/src/ioctl.cpp
@ -93,19 +93,21 @@ _ioctl_dir_base(Policy::Func::Search  searchFunc,
 {
  int fd;
  int rv;
-  Paths path;
+  vector<string> path;

  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  fd = ::open(path[0].full.c_str(),flags);
+  fs::path::append(path[0],fusepath);
+
+  fd = ::open(path[0].c_str(),flags);
  if(fd == -1)
    return -errno;

  rv = _ioctl(fd,cmd,arg,flags,data);

-  close(fd);
+  ::close(fd);

  return rv;
 }
--- a/src/link.cpp
+++ b/src/link.cpp
@ -49,23 +49,23 @@ _single_link(Policy::Func::Search  searchFunc,
             const string         &newpath)
 {
  int rv;
-  const string fulloldpath = fs::make_path(base,oldpath);
-  const string fullnewpath = fs::make_path(base,newpath);
+  const string fulloldpath = fs::path::make(base,oldpath);
+  const string fullnewpath = fs::path::make(base,newpath);

  rv = ::link(fulloldpath.c_str(),fullnewpath.c_str());
  if(rv == -1 && errno == ENOENT)
    {
      string newpathdir;
-      Paths foundpath;
+      vector<string> foundpath;

-      newpathdir = fs::dirname(newpath);
+      newpathdir = fs::path::dirname(newpath);
      rv = searchFunc(srcmounts,newpathdir,minfreespace,foundpath);
      if(rv == -1)
        return -1;

      {
        const mergerfs::ugid::SetResetGuard ugid(0,0);
-        fs::clonepath(foundpath[0].base,base,newpathdir);
+        fs::clonepath(foundpath[0],base,newpathdir);
      }

      rv = ::link(fulloldpath.c_str(),fullnewpath.c_str());
@ -85,7 +85,7 @@ _link(Policy::Func::Search  searchFunc,
 {
  int rv;
  int error;
-  Paths oldpaths;
+  vector<string> oldpaths;

  rv = actionFunc(srcmounts,oldpath,minfreespace,oldpaths);
  if(rv == -1)
@ -94,7 +94,7 @@ _link(Policy::Func::Search  searchFunc,
  error = 0;
  for(size_t i = 0, ei = oldpaths.size(); i != ei; i++)
    {
-      rv = _single_link(searchFunc,srcmounts,minfreespace,oldpaths[i].base,oldpath,newpath);
+      rv = _single_link(searchFunc,srcmounts,minfreespace,oldpaths[i],oldpath,newpath);
      if(rv == -1)
        error = errno;
    }
--- a/src/listxattr.cpp
+++ b/src/listxattr.cpp
@ -78,13 +78,15 @@ _listxattr(Policy::Func::Search  searchFunc,
 {
 #ifndef WITHOUT_XATTR
  int rv;
-  Paths path;
+  vector<string> path;

  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  rv = ::llistxattr(path[0].full.c_str(),list,size);
+  fs::path::append(path[0],fusepath);
+
+  rv = ::llistxattr(path[0].c_str(),list,size);

  return ((rv == -1) ? -errno : rv);
 #else
--- a/src/mergerfs.cpp
+++ b/src/mergerfs.cpp
@ -80,7 +80,7 @@ namespace local
  getappname(const int     argc,
             char * const *argv)
  {
-    return fs::basename(argv[0]);
+    return fs::path::basename(argv[0]);
  }

  static
--- a/src/mkdir.cpp
+++ b/src/mkdir.cpp
@ -53,10 +53,10 @@ _mkdir(Policy::Func::Search  searchFunc,
  int error;
  string dirname;
  string fullpath;
-  Paths createpaths;
-  Paths existingpath;
+  vector<string> createpaths;
+  vector<string> existingpath;

-  dirname = fs::dirname(fusepath);
+  dirname = fs::path::dirname(fusepath);
  rv = searchFunc(srcmounts,dirname,minfreespace,existingpath);
  if(rv == -1)
    return -errno;
@ -68,17 +68,17 @@ _mkdir(Policy::Func::Search  searchFunc,
  error = 0;
  for(size_t i = 0, ei = createpaths.size(); i != ei; i++)
    {
-      const string &createpath = createpaths[i].base;
+      string &createpath = createpaths[i];

-      if(createpath != existingpath[0].base)
+      if(createpath != existingpath[0])
        {
          const mergerfs::ugid::SetResetGuard ugid(0,0);
-          fs::clonepath(existingpath[0].base,createpath,dirname);
+          fs::clonepath(existingpath[0],createpath,dirname);
        }

-      fullpath = fs::make_path(createpath,fusepath);
+      fs::path::append(createpath,fusepath);

-      rv = ::mkdir(fullpath.c_str(),mode);
+      rv = ::mkdir(createpath.c_str(),mode);
      if(rv == -1)
        error = errno;
    }
--- a/src/mknod.cpp
+++ b/src/mknod.cpp
@ -55,11 +55,10 @@ _mknod(Policy::Func::Search  searchFunc,
  int rv;
  int error;
  string dirname;
-  string fullpath;
-  Paths createpaths;
-  Paths existingpath;
+  vector<string> createpaths;
+  vector<string> existingpath;

-  dirname = fs::dirname(fusepath);
+  dirname = fs::path::dirname(fusepath);
  rv = searchFunc(srcmounts,dirname,minfreespace,existingpath);
  if(rv == -1)
    return -errno;
@ -71,17 +70,17 @@ _mknod(Policy::Func::Search  searchFunc,
  error = 0;
  for(size_t i = 0, ei = createpaths.size(); i != ei; i++)
    {
-      const string &createpath = createpaths[0].base;
+      string &createpath = createpaths[0];

-      if(createpath != existingpath[0].base)
+      if(createpath != existingpath[0])
        {
          const mergerfs::ugid::SetResetGuard ugid(0,0);
-          fs::clonepath(existingpath[0].base,createpath,dirname);
+          fs::clonepath(existingpath[0],createpath,dirname);
        }

-      fullpath = fs::make_path(createpath,fusepath);
+      fs::path::append(createpath,fusepath);

-      rv = ::mknod(fullpath.c_str(),mode,dev);
+      rv = ::mknod(createpath.c_str(),mode,dev);
      if(rv == -1)
        error = errno;
    }
--- a/src/open.cpp
+++ b/src/open.cpp
@ -51,13 +51,13 @@ _open(Policy::Func::Search  searchFunc,
 {
  int fd;
  int rv;
-  Paths path;
+  vector<string> path;

  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  fd = ::open(path[0].full.c_str(),flags);
+  fd = ::open(path[0].c_str(),flags);
  if(fd == -1)
    return -errno;

--- a/src/option_parser.cpp
+++ b/src/option_parser.cpp
@ -121,8 +121,8 @@ parse_and_process_minfreespace(const std::string &value,
      minfreespace *= (1024 * 1024);
      break;

-    case 'b':
-    case 'B':
+    case 'g':
+    case 'G':
      minfreespace *= (1024 * 1024 * 1024);
      break;

--- a/src/policy.hpp
+++ b/src/policy.hpp
@ -67,7 +67,7 @@ namespace mergerfs
      typedef const strvec cstrvec;
      typedef const Category::Enum::Type CType;

-      typedef int (*Ptr)(CType,cstrvec&,cstring&,csize_t,Paths&);
+      typedef int (*Ptr)(CType,cstrvec&,cstring&,csize_t,strvec&);

      class Action
      {
@ -77,7 +77,7 @@ namespace mergerfs
        {}

        int
-        operator()(cstrvec& b,cstring& c,csize_t d,Paths& e)
+        operator()(cstrvec& b,cstring& c,csize_t d,strvec& e)
        {
          return func(Category::Enum::action,b,c,d,e);
        }
@ -94,7 +94,7 @@ namespace mergerfs
        {}

        int
-        operator()(cstrvec& b,cstring& c,csize_t d,Paths& e)
+        operator()(cstrvec& b,cstring& c,csize_t d,strvec& e)
        {
          return func(Category::Enum::create,b,c,d,e);
        }
@ -111,7 +111,7 @@ namespace mergerfs
        {}

        int
-        operator()(cstrvec& b,cstring& c,csize_t d,Paths& e)
+        operator()(cstrvec& b,cstring& c,csize_t d,strvec& e)
        {
          return func(Category::Enum::search,b,c,d,e);
        }
@ -120,16 +120,16 @@ namespace mergerfs
        const Ptr func;
      };

-      static int invalid(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int all(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int epmfs(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int ff(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int ffwp(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int fwfs(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int lfs(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int mfs(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int newest(CType,cstrvec&,cstring&,csize_t,Paths&);
-      static int rand(CType,cstrvec&,cstring&,csize_t,Paths&);
+      static int invalid(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int all(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int epmfs(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int ff(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int ffwp(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int fwfs(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int lfs(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int mfs(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int newest(CType,cstrvec&,cstring&,csize_t,strvec&);
+      static int rand(CType,cstrvec&,cstring&,csize_t,strvec&);
    };

  private:
--- a/src/policy_all.cpp
+++ b/src/policy_all.cpp
@ -39,8 +39,8 @@ using std::size_t;
 static
 int
 _all(const vector<string> &basepaths,
-    const string          &fusepath,
-    Paths                 &paths)
+     const string         &fusepath,
+     vector<string>       &paths)
 {
  int rv;
  struct stat st;
@ -51,11 +51,11 @@ _all(const vector<string> &basepaths,
      const char *basepath;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = ::lstat(fullpath.c_str(),&st);
      if(rv == 0)
-        paths.push_back(Path(basepath,fullpath));
+        paths.push_back(basepath);
    }

  return paths.empty() ? (errno=ENOENT,-1) : 0;
@ -68,7 +68,7 @@ namespace mergerfs
                    const vector<string>       &basepaths,
                    const string               &fusepath,
                    const size_t                minfreespace,
-                    Paths                      &paths)
+                    vector<string>             &paths)
  {
    return _all(basepaths,fusepath,paths);
  }
--- a/src/policy_epmfs.cpp
+++ b/src/policy_epmfs.cpp
@ -122,7 +122,7 @@ static
 int
 _epmfs_create(const vector<string> &basepaths,
              const string         &fusepath,
-              Paths                &paths)
+              vector<string>       &paths)

 {
  fsblkcnt_t  epmfs;
@ -141,7 +141,7 @@ _epmfs_create(const vector<string> &basepaths,
      int rv;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = _try_statvfs(basepath,fusepath,epmfs,epmfsbasepath,mfs,mfsbasepath);
      if(rv == -1)
@ -151,8 +151,7 @@ _epmfs_create(const vector<string> &basepaths,
  if(epmfsbasepath == NULL)
    epmfsbasepath = mfsbasepath;

-  paths.push_back(Path(epmfsbasepath,
-                       fs::make_path(epmfsbasepath,fusepath)));
+  paths.push_back(epmfsbasepath);

  return 0;
 }
@ -161,7 +160,7 @@ static
 int
 _epmfs(const vector<string> &basepaths,
       const string         &fusepath,
-       Paths                &paths)
+       vector<string>       &paths)

 {
  fsblkcnt_t  epmfs;
@ -177,7 +176,7 @@ _epmfs(const vector<string> &basepaths,
      struct statvfs fsstats;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = ::statvfs(fullpath.c_str(),&fsstats);
      if(rv == 0)
@ -187,8 +186,7 @@ _epmfs(const vector<string> &basepaths,
  if(epmfsbasepath == NULL)
    return (errno=ENOENT,-1);

-  paths.push_back(Path(epmfsbasepath,
-                       fs::make_path(epmfsbasepath,fusepath)));
+  paths.push_back(epmfsbasepath);

  return 0;
 }
@ -200,7 +198,7 @@ namespace mergerfs
                      const vector<string>       &basepaths,
                      const string               &fusepath,
                      const size_t                minfreespace,
-                      Paths                      &paths)
+                      vector<string>             &paths)
  {
    if(type == Category::Enum::create)
      return _epmfs_create(basepaths,fusepath,paths);
--- a/src/policy_ff.cpp
+++ b/src/policy_ff.cpp
@ -41,7 +41,7 @@ static
 int
 _ff(const vector<string> &basepaths,
    const string         &fusepath,
-    Paths                &paths)
+    vector<string>       &paths)
 {
  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
    {
@ -51,13 +51,13 @@ _ff(const vector<string> &basepaths,
      string       fullpath;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = ::lstat(fullpath.c_str(),&st);
      if(rv == -1)
        continue;

-      paths.push_back(Path(basepath,fullpath));
+      paths.push_back(basepath);

      return 0;
    }
@ -72,7 +72,7 @@ namespace mergerfs
                   const vector<string>       &basepaths,
                   const string               &fusepath,
                   const size_t                minfreespace,
-                   Paths                      &paths)
+                   vector<string>             &paths)
  {
    return _ff(basepaths,fusepath,paths);
  }
--- a/src/policy_ffwp.cpp
+++ b/src/policy_ffwp.cpp
@ -40,7 +40,7 @@ static
 int
 _ffwp(const vector<string> &basepaths,
      const string         &fusepath,
-      Paths                &paths)
+      vector<string>       &paths)
 {
  const char *fallback;

@ -53,12 +53,12 @@ _ffwp(const vector<string> &basepaths,
      string       fullpath;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = ::lstat(fullpath.c_str(),&st);
      if(rv == 0)
        {
-          paths.push_back(Path(basepath,fullpath));
+          paths.push_back(basepath);
          return 0;
        }
      else if(errno == EACCES)
@ -70,8 +70,7 @@ _ffwp(const vector<string> &basepaths,
  if(fallback == NULL)
    return (errno=ENOENT,-1);

-  paths.push_back(Path(fallback,
-                       fs::make_path(fallback,fusepath)));
+  paths.push_back(fallback);

  return 0;
 }
@ -83,7 +82,7 @@ namespace mergerfs
                     const vector<string>       &basepaths,
                     const string               &fusepath,
                     const size_t                minfreespace,
-                     Paths                      &paths)
+                     vector<string>             &paths)
  {
    return _ffwp(basepaths,fusepath,paths);
  }
--- a/src/policy_fwfs.cpp
+++ b/src/policy_fwfs.cpp
@ -42,7 +42,7 @@ _fwfs_create(const Category::Enum::Type  type,
             const vector<string>       &basepaths,
             const string               &fusepath,
             const size_t                minfreespace,
-             Paths                      &paths)
+             vector<string>             &paths)
 {
  for(size_t i = 0, size = basepaths.size(); i != size; i++)
    {
@ -60,8 +60,7 @@ _fwfs_create(const Category::Enum::Type  type,
          if(spaceavail < minfreespace)
            continue;

-          paths.push_back(Path(basepath,
-                               fs::make_path(basepath,fusepath)));
+          paths.push_back(basepath);

          return 0;
        }
@ -76,7 +75,7 @@ _fwfs(const Category::Enum::Type  type,
      const vector<string>       &basepaths,
      const string               &fusepath,
      const size_t                minfreespace,
-      Paths                      &paths)
+      vector<string>             &paths)
 {
  for(size_t i = 0, size = basepaths.size(); i != size; i++)
    {
@ -86,7 +85,7 @@ _fwfs(const Category::Enum::Type  type,
      struct statvfs fsstats;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);
      rv = ::statvfs(fullpath.c_str(),&fsstats);
      if(rv == 0)
        {
@ -96,7 +95,7 @@ _fwfs(const Category::Enum::Type  type,
          if(spaceavail < minfreespace)
            continue;

-          paths.push_back(Path(basepath,fullpath));
+          paths.push_back(basepath);

          return 0;
        }
@ -112,7 +111,7 @@ namespace mergerfs
                     const vector<string>       &basepaths,
                     const string               &fusepath,
                     const size_t                minfreespace,
-                     Paths                      &paths)
+                     vector<string>             &paths)
  {
    if(type == Category::Enum::create)
      return _fwfs_create(type,basepaths,fusepath,minfreespace,paths);
--- a/src/policy_invalid.cpp
+++ b/src/policy_invalid.cpp
@ -40,7 +40,7 @@ namespace mergerfs
                        const vector<string>       &basepaths,
                        const string               &fusepath,
                        const size_t                minfreespace,
-                        Paths                      &rv)
+                        vector<string>             &rv)
  {
    return (errno = EINVAL,-1);
  }
--- a/src/policy_lfs.cpp
+++ b/src/policy_lfs.cpp
@ -45,7 +45,7 @@ _lfs_create(const Category::Enum::Type  type,
            const vector<string>       &basepaths,
            const string               &fusepath,
            const size_t                minfreespace,
-            Paths                      &paths)
+            vector<string>             &paths)
 {
  fsblkcnt_t  lfs;
  const char *lfsstr;
@ -77,8 +77,7 @@ _lfs_create(const Category::Enum::Type  type,
  if(lfsstr == NULL)
    return Policy::Func::mfs(type,basepaths,fusepath,minfreespace,paths);

-  paths.push_back(Path(lfsstr,
-                       fs::make_path(lfsstr,fusepath)));
+  paths.push_back(lfsstr);

  return 0;
 }
@ -89,7 +88,7 @@ _lfs(const Category::Enum::Type  type,
     const vector<string>       &basepaths,
     const string               &fusepath,
     const size_t                minfreespace,
-     Paths                      &paths)
+     vector<string>             &paths)
 {
  fsblkcnt_t  lfs;
  const char *lfsstr;
@ -104,7 +103,7 @@ _lfs(const Category::Enum::Type  type,
      struct statvfs fsstats;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);
      rv = ::statvfs(fullpath.c_str(),&fsstats);
      if(rv == 0)
        {
@ -123,8 +122,7 @@ _lfs(const Category::Enum::Type  type,
  if(lfsstr == NULL)
    return Policy::Func::mfs(type,basepaths,fusepath,minfreespace,paths);

-  paths.push_back(Path(lfsstr,
-                       fs::make_path(lfsstr,fusepath)));
+  paths.push_back(lfsstr);

  return 0;
 }
@ -136,7 +134,7 @@ namespace mergerfs
                    const vector<string>       &basepaths,
                    const string               &fusepath,
                    const size_t                minfreespace,
-                    Paths                      &paths)
+                    vector<string>             &paths)
  {
    if(type == Category::Enum::create)
      return _lfs_create(type,basepaths,fusepath,minfreespace,paths);
--- a/src/policy_mfs.cpp
+++ b/src/policy_mfs.cpp
@ -38,7 +38,7 @@ static
 int
 _mfs_create(const vector<string> &basepaths,
            const string         &fusepath,
-            Paths                &paths)
+            vector<string>       &paths)
 {
  fsblkcnt_t  mfs;
  const char *mfsstr;
@ -69,8 +69,7 @@ _mfs_create(const vector<string> &basepaths,
  if(mfsstr == NULL)
    return (errno=ENOENT,-1);

-  paths.push_back(Path(mfsstr,
-                       fs::make_path(mfsstr,fusepath)));
+  paths.push_back(mfsstr);

  return 0;
 }
@ -78,8 +77,8 @@ _mfs_create(const vector<string> &basepaths,
 static
 int
 _mfs(const vector<string> &basepaths,
-            const string  &fusepath,
-            Paths         &paths)
+     const string         &fusepath,
+     vector<string>       &paths)
 {
  fsblkcnt_t  mfs;
  const char *mfsstr;
@ -94,7 +93,7 @@ _mfs(const vector<string> &basepaths,
      struct statvfs fsstats;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);
      rv = ::statvfs(fullpath.c_str(),&fsstats);
      if(rv == 0)
        {
@ -112,8 +111,7 @@ _mfs(const vector<string> &basepaths,
  if(mfsstr == NULL)
    return (errno=ENOENT,-1);

-  paths.push_back(Path(mfsstr,
-                       fs::make_path(mfsstr,fusepath)));
+  paths.push_back(mfsstr);

  return 0;
 }
@ -125,7 +123,7 @@ namespace mergerfs
                    const vector<string>       &basepaths,
                    const string               &fusepath,
                    const size_t                minfreespace,
-                    Paths                      &paths)
+                    vector<string>             &paths)
  {
    if(type == Category::Enum::create)
      return _mfs_create(basepaths,fusepath,paths);
--- a/src/policy_newest.cpp
+++ b/src/policy_newest.cpp
@ -40,7 +40,7 @@ static
 int
 _newest(const vector<string> &basepaths,
        const string         &fusepath,
-        Paths                &paths)
+        vector<string>       &paths)
 {
  time_t newest;
  const char *neweststr;
@ -55,7 +55,7 @@ _newest(const vector<string> &basepaths,
      string       fullpath;

      basepath = basepaths[i].c_str();
-      fullpath = fs::make_path(basepath,fusepath);
+      fullpath = fs::path::make(basepath,fusepath);

      rv = ::lstat(fullpath.c_str(),&st);
      if(rv == 0 && st.st_mtime > newest)
@ -68,8 +68,7 @@ _newest(const vector<string> &basepaths,
  if(neweststr == NULL)
    return (errno=ENOENT,-1);

-  paths.push_back(Path(neweststr,
-                       fs::make_path(neweststr,fusepath)));
+  paths.push_back(neweststr);

  return 0;
 }
@ -81,7 +80,7 @@ namespace mergerfs
                       const vector<string>       &basepaths,
                       const string               &fusepath,
                       const size_t                minfreespace,
-                       Paths                      &paths)
+                       vector<string>             &paths)
  {
    return _newest(basepaths,fusepath,paths);
  }
--- a/src/policy_rand.cpp
+++ b/src/policy_rand.cpp
@ -41,7 +41,7 @@ namespace mergerfs
                     const vector<string>       &basepaths,
                     const string               &fusepath,
                     const size_t                minfreespace,
-                     Paths                      &paths)
+                     vector<string>             &paths)
  {
    int rv;

--- a/src/readdir.cpp
+++ b/src/readdir.cpp
@ -62,7 +62,7 @@ _readdir(const vector<string>  &srcmounts,
      DIR *dh;
      string basepath;

-      basepath = fs::make_path(srcmounts[i],dirname);
+      basepath = fs::path::make(srcmounts[i],dirname);
      dh = ::opendir(basepath.c_str());
      if(!dh)
        continue;
--- a/src/readlink.cpp
+++ b/src/readlink.cpp
@ -49,13 +49,15 @@ _readlink(Policy::Func::Search  searchFunc,
          const size_t          size)
 {
  int rv;
-  Paths path;
+  vector<string> path;

  rv = searchFunc(srcmounts,fusepath,minfreespace,path);
  if(rv == -1)
    return -errno;

-  rv = ::readlink(path[0].full.c_str(),buf,size);
+  fs::path::append(path[0],fusepath);
+
+  rv = ::readlink(path[0].c_str(),buf,size);
  if(rv == -1)
    return -errno;

--- a/src/removexattr.cpp
+++ b/src/removexattr.cpp
@ -51,7 +51,7 @@ _removexattr(Policy::Func::Action  actionFunc,
 #ifndef WITHOUT_XATTR
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -60,7 +60,9 @@ _removexattr(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::lremovexattr(paths[i].full.c_str(),attrname);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::lremovexattr(paths[i].c_str(),attrname);
      if(rv == -1)
        error = errno;
    }
--- a/src/rename.cpp
+++ b/src/rename.cpp
@ -45,29 +45,30 @@ int
 _single_rename(Policy::Func::Search  searchFunc,
               const vector<string> &srcmounts,
               const size_t          minfreespace,
-               const Path           &oldpath,
+               const string         &oldbasepath,
+               const string         &oldfullpath,
               const string         &newpath)
 {
  int rv;
-  const string fullnewpath = fs::make_path(oldpath.base,newpath);
+  const string newfullpath = fs::path::make(oldbasepath,newpath);

-  rv = ::rename(oldpath.full.c_str(),fullnewpath.c_str());
+  rv = ::rename(oldfullpath.c_str(),newfullpath.c_str());
  if(rv == -1 && errno == ENOENT)
    {
      string dirname;
-      Paths newpathdir;
+      vector<string> newpathdir;

-      dirname = fs::dirname(newpath);
+      dirname = fs::path::dirname(newpath);
      rv = searchFunc(srcmounts,dirname,minfreespace,newpathdir);
      if(rv == -1)
        return -1;

      {
        const mergerfs::ugid::SetResetGuard ugid(0,0);
-        fs::clonepath(newpathdir[0].base,oldpath.base,dirname);
+        fs::clonepath(newpathdir[0],oldbasepath,dirname);
      }

-      rv = ::rename(oldpath.full.c_str(),fullnewpath.c_str());
+      rv = ::rename(oldfullpath.c_str(),newfullpath.c_str());
    }

  return rv;
@ -79,21 +80,24 @@ _rename(Policy::Func::Search  searchFunc,
        Policy::Func::Action  actionFunc,
        const vector<string> &srcmounts,
        const size_t          minfreespace,
-        const string         &oldpath,
-        const string         &newpath)
+        const string         &oldfusepath,
+        const string         &newfusepath)
 {
  int rv;
  int error;
-  Paths oldpaths;
+  vector<string> oldbasepaths;

-  rv = actionFunc(srcmounts,oldpath,minfreespace,oldpaths);
+  rv = actionFunc(srcmounts,oldfusepath,minfreespace,oldbasepaths);
  if(rv == -1)
    return -errno;

  error = 0;
-  for(size_t i = 0, ei = oldpaths.size(); i != ei; i++)
+  for(size_t i = 0, ei = oldbasepaths.size(); i != ei; i++)
    {
-      rv = _single_rename(searchFunc,srcmounts,minfreespace,oldpaths[i],newpath);
+      const string oldfullpath = fs::path::make(oldbasepaths[i],oldfusepath);
+
+      rv = _single_rename(searchFunc,srcmounts,minfreespace,
+                          oldbasepaths[i],oldfullpath,newfusepath);
      if(rv == -1)
        error = errno;
    }
--- a/src/rmdir.cpp
+++ b/src/rmdir.cpp
@ -47,7 +47,7 @@ _rmdir(Policy::Func::Action  actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -56,7 +56,9 @@ _rmdir(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::rmdir(paths[i].full.c_str());
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::rmdir(paths[i].c_str());
      if(rv == -1)
        error = errno;
    }
--- a/src/setxattr.cpp
+++ b/src/setxattr.cpp
@ -252,7 +252,7 @@ _setxattr(Policy::Func::Action  actionFunc,
 #ifndef WITHOUT_XATTR
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -261,7 +261,9 @@ _setxattr(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::lsetxattr(paths[i].full.c_str(),attrname,attrval,attrvalsize,flags);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::lsetxattr(paths[i].c_str(),attrname,attrval,attrvalsize,flags);
      if(rv == -1)
        error = errno;
    }
--- a/src/symlink.cpp
+++ b/src/symlink.cpp
@ -49,9 +49,9 @@ _symlink(Policy::Func::Create  createFunc,
  int rv;
  int error;
  string newpathdir;
-  Paths newpathdirs;
+  vector<string> newpathdirs;

-  newpathdir = fs::dirname(newpath);
+  newpathdir = fs::path::dirname(newpath);
  rv = createFunc(srcmounts,newpathdir,minfreespace,newpathdirs);
  if(rv == -1)
    return -errno;
@ -59,9 +59,9 @@ _symlink(Policy::Func::Create  createFunc,
  error = 0;
  for(size_t i = 0, ei = newpathdirs.size(); i != ei; i++)
    {
-      newpathdirs[i].full = fs::make_path(newpathdirs[i].base,newpath);
+      fs::path::append(newpathdirs[i],newpath);

-      rv = symlink(oldpath.c_str(),newpathdirs[i].full.c_str());
+      rv = symlink(oldpath.c_str(),newpathdirs[i].c_str());
      if(rv == -1)
        error = errno;
    }
--- a/src/truncate.cpp
+++ b/src/truncate.cpp
@ -50,7 +50,7 @@ _truncate(Policy::Func::Action  actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -59,7 +59,9 @@ _truncate(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::truncate(paths[i].full.c_str(),size);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::truncate(paths[i].c_str(),size);
      if(rv == -1)
        error = errno;
    }
--- a/src/unlink.cpp
+++ b/src/unlink.cpp
@ -48,7 +48,7 @@ _unlink(Policy::Func::Action  actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -57,7 +57,9 @@ _unlink(Policy::Func::Action  actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::unlink(paths[i].full.c_str());
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::unlink(paths[i].c_str());
      if(rv == -1)
        error = errno;
    }
--- a/src/utimens.cpp
+++ b/src/utimens.cpp
@ -50,7 +50,7 @@ _utimens(Policy::Func::Action   actionFunc,
 {
  int rv;
  int error;
-  Paths paths;
+  vector<string> paths;

  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
  if(rv == -1)
@ -59,7 +59,9 @@ _utimens(Policy::Func::Action   actionFunc,
  error = 0;
  for(size_t i = 0, ei = paths.size(); i != ei; i++)
    {
-      rv = ::utimensat(0,paths[i].full.c_str(),ts,AT_SYMLINK_NOFOLLOW);
+      fs::path::append(paths[i],fusepath);
+
+      rv = ::utimensat(0,paths[i].c_str(),ts,AT_SYMLINK_NOFOLLOW);
      if(rv == -1)
        error = errno;
    }