wrap most posix filesystem functions

LICENSE

@@ -1,6 +1,6 @@
 /*
   ISC License
-  
+
   Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
   Permission to use, copy, modify, and/or distribute this software for any

src/access.cpp

@@ -17,11 +17,9 @@
 #include <string>
 #include <vector>
 
-#include <fcntl.h>
-#include <unistd.h>
-
 #include "config.hpp"
 #include "errno.hpp"
+#include "fs_base_access.hpp"
 #include "fs_path.hpp"
 #include "rwlock.hpp"
 #include "ugid.hpp"
@@ -49,7 +47,7 @@ _access(Policy::Func::Search  searchFunc,
 
   fs::path::make(basepaths[0],fusepath,fullpath);
 
-  rv = ::faccessat(AT_FDCWD,fullpath.c_str(),mask,AT_EACCESS);
+  rv = fs::access(fullpath,mask,AT_EACCESS);
 
   return ((rv == -1) ? -errno : 0);
 }

src/chmod.cpp

@@ -21,6 +21,7 @@
 
 #include "config.hpp"
 #include "errno.hpp"
+#include "fs_base_chmod.hpp"
 #include "fs_path.hpp"
 #include "rv.hpp"
 #include "rwlock.hpp"
@@ -42,7 +43,7 @@ _chmod_loop_core(const string *basepath,
 
   fs::path::make(basepath,fusepath,fullpath);
 
-  rv = ::chmod(fullpath.c_str(),mode);
+  rv = fs::chmod(fullpath,mode);
 
   return calc_error(rv,error,errno);
 }

src/chown.cpp

@@ -21,6 +21,7 @@
 
 #include "config.hpp"
 #include "errno.hpp"
+#include "fs_base_chown.hpp"
 #include "fs_path.hpp"
 #include "rv.hpp"
 #include "rwlock.hpp"
@@ -44,7 +45,7 @@ _chown_loop_core(const string *basepath,
 
   fs::path::make(basepath,fusepath,fullpath);
 
-  rv = ::lchown(fullpath.c_str(),uid,gid);
+  rv = fs::lchown(fullpath,uid,gid);
 
   return calc_error(rv,error,errno);
 }

src/create.cpp

@@ -16,16 +16,13 @@
 
 #include <fuse.h>
 
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
 #include <string>
 #include <vector>
 
 #include "config.hpp"
 #include "errno.hpp"
 #include "fileinfo.hpp"
+#include "fs_base_open.hpp"
 #include "fs_clonepath.hpp"
 #include "fs_path.hpp"
 #include "rwlock.hpp"
@@ -57,7 +54,7 @@ _create_core(const string &existingpath,
 
   fs::path::make(&createpath,fusepath,fullpath);
 
-  fd = ::open(fullpath.c_str(),flags,mode);
+  fd = fs::open(fullpath,flags,mode);
   if(fd == -1)
     return -errno;
 

src/fallocate.cpp

@@ -49,7 +49,6 @@ namespace mergerfs
     {
       FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
 
-
       return _fallocate(fi->fd,
                         mode,
                         offset,

src/fgetattr.cpp

@@ -16,12 +16,9 @@
 
 #include <fuse.h>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
 #include "errno.hpp"
 #include "fileinfo.hpp"
+#include "fs_base_stat.hpp"
 
 static
 int
@@ -30,7 +27,7 @@ _fgetattr(const int    fd,
 {
   int rv;
 
-  rv = ::fstat(fd,&st);
+  rv = fs::fstat(fd,st);
 
   return ((rv == -1) ? -errno : 0);
 }

src/fgetattr.hpp

@@ -14,8 +14,8 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
 
 namespace mergerfs

src/flush.cpp

@@ -16,22 +16,22 @@
 
 #include <fuse.h>
 
-#include <unistd.h>
-
 #include "errno.hpp"
 #include "fileinfo.hpp"
+#include "fs_base_close.hpp"
+#include "fs_base_dup.hpp"
 
 static
 int
 _flush(const int fd)
 {
   int rv;
 
-  rv = ::dup(fd);
+  rv = fs::dup(fd);
   if(rv == -1)
     errno = EIO;
   else
-    rv = ::close(rv);
+    rv = fs::close(rv);
 
   return ((rv == -1) ? -errno : 0);
 }

src/fs.cpp

@@ -17,19 +17,16 @@
 #include <string>
 #include <vector>
 
-#include <fcntl.h>
 #include <fcntl.h>
 #include <glob.h>
 #include <limits.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include "errno.hpp"
 #include "fs_attr.hpp"
+#include "fs_base_stat.hpp"
+#include "fs_base_statvfs.hpp"
 #include "fs_path.hpp"
 #include "fs_xattr.hpp"
 #include "statvfs_util.hpp"
@@ -47,7 +44,7 @@ namespace fs
   {
     int rv;
 
-    rv = ::lstat(path.c_str(),&st);
+    rv = fs::lstat(path,st);
 
     return LSTAT_SUCCEEDED(rv);
   }
@@ -60,74 +57,63 @@ namespace fs
     return exists(path,st);
   }
 
-  bool
-  statvfs(const string   &path,
-          struct statvfs &st)
-  {
-    int rv;
-
-    rv = ::statvfs(path.c_str(),&st);
-
-    return STATVFS_SUCCEEDED(rv);
-  }
-
   bool
   info(const string &path,
        bool         &readonly,
        uint64_t     &spaceavail,
        uint64_t     &spaceused)
   {
-    bool rv;
+    int rv;
     struct statvfs st;
 
     rv = fs::statvfs(path,st);
-    if(rv)
+    if(STATVFS_SUCCEEDED(rv))
       {
         readonly   = StatVFS::readonly(st);
         spaceavail = StatVFS::spaceavail(st);
         spaceused  = StatVFS::spaceused(st);
       }
 
-    return rv;
+    return STATVFS_SUCCEEDED(rv);
   }
 
   bool
   readonly(const string &path)
   {
-    bool rv;
+    int rv;
     struct statvfs st;
 
     rv = fs::statvfs(path,st);
 
-    return (rv && StatVFS::readonly(st));
+    return (STATVFS_SUCCEEDED(rv) && StatVFS::readonly(st));
   }
 
   bool
   spaceavail(const string &path,
              uint64_t       &spaceavail)
   {
-    bool rv;
+    int rv;
     struct statvfs st;
 
     rv = fs::statvfs(path,st);
-    if(rv)
+    if(STATVFS_SUCCEEDED(rv))
       spaceavail = StatVFS::spaceavail(st);
 
-    return rv;
+    return STATVFS_SUCCEEDED(rv);
   }
 
   bool
   spaceused(const string &path,
             uint64_t     &spaceused)
   {
-    bool rv;
+    int rv;
     struct statvfs st;
 
     rv = fs::statvfs(path,st);
-    if(rv)
+    if(STATVFS_SUCCEEDED(rv))
       spaceused = StatVFS::spaceused(st);
 
-    return rv;
+    return STATVFS_SUCCEEDED(rv);
   }
 
   void
@@ -159,7 +145,7 @@ namespace fs
     string fullpath;
     struct stat st;
 
-    rv = ::fstat(fd,&st);
+    rv = fs::fstat(fd,st);
     if(FSTAT_FAILED(rv))
       return -1;
 

src/fs.hpp

@@ -31,9 +31,6 @@ namespace fs
               struct stat  &st);
   bool exists(const string &path);
 
-  bool statvfs(const string   &path,
-               struct statvfs &st);
-
   bool info(const string &path,
             bool         &readonly,
             uint64_t     &spaceavail,

src/fs_attr_linux.icpp

@@ -16,14 +16,13 @@
 
 #include <fcntl.h>
 #include <linux/fs.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include <string>
 
 #include "errno.hpp"
+#include "fs_base_close.hpp"
+#include "fs_base_open.hpp"
+#include "fs_base_ioctl.hpp"
 
 using std::string;
 
@@ -36,7 +35,7 @@ namespace fs
     get_fs_ioc_flags(const int  fd,
                      int       &flags)
     {
-      return ::ioctl(fd,FS_IOC_GETFLAGS,&flags);
+      return fs::ioctl(fd,FS_IOC_GETFLAGS,(void*)&flags);
     }
 
     static
@@ -48,28 +47,28 @@ namespace fs
       int rv;
       const int openflags = O_RDONLY|O_NONBLOCK;
 
-      fd = ::open(file.c_str(),openflags);
+      fd = fs::open(file,openflags);
       if(fd == -1)
         return -1;
 
       rv = get_fs_ioc_flags(fd,flags);
       if(rv == -1)
         {
           int error = errno;
-          ::close(fd);
+          fs::close(fd);
           errno = error;
           return -1;
         }
 
-      return ::close(fd);
+      return fs::close(fd);
     }
 
     static
     int
     set_fs_ioc_flags(const int fd,
                      const int flags)
     {
-      return ::ioctl(fd,FS_IOC_SETFLAGS,&flags);
+      return fs::ioctl(fd,FS_IOC_SETFLAGS,(void*)&flags);
     }
 
     static
@@ -81,20 +80,20 @@ namespace fs
       int rv;
       const int openflags = O_RDONLY|O_NONBLOCK;
 
-      fd = ::open(file.c_str(),openflags);
+      fd = fs::open(file,openflags);
       if(fd == -1)
         return -1;
 
       rv = set_fs_ioc_flags(fd,flags);
       if(rv == -1)
         {
           int error = errno;
-          ::close(fd);
+          fs::close(fd);
           errno = error;
           return -1;
         }
 
-      return ::close(fd);
+      return fs::close(fd);
     }
 
     int