config.cpp

libfuse/lib/debug.cpp

@@ -861,11 +861,25 @@ fuse_syslog_fuse_init_out(const struct fuse_init_out *arg_)
   output = fmt::format("fuse_init_out:"
                        " major={};"
                        " minor={};"
+                       " max_readahead={};"
+                       " max_background={};"
+                       " congestion_threshold={};"
+                       " max_write={};"
+                       " time_gran={};"
                        " max_pages={};"
+                       " map_alignment={};"
+                       " max_stack_depth={};"
                        " flags=(",
                        arg_->major,
                        arg_->minor,
-                       arg_->max_pages);
+                       arg_->max_readahead,
+                       arg_->max_background,
+                       arg_->congestion_threshold,
+                       arg_->max_write,
+                       arg_->time_gran,
+                       arg_->max_pages,
+                       arg_->map_alignment,
+                       arg_->max_stack_depth);
 
   for(uint64_t i = 0; i < (sizeof(flags)*8); i++)
     {

libfuse/lib/fuse.cpp

@@ -4165,14 +4165,14 @@ fuse_new_common(struct fuse_chan             *ch,
   return NULL;
 }
 
-struct fuse*
-fuse_new(struct fuse_chan             *ch,
-         struct fuse_args             *args,
-         const struct fuse_operations *op,
-         size_t                        op_size)
-{
-  return fuse_new_common(ch,args,op,op_size);
-}
+// struct fuse*
+// fuse_new(struct fuse_chan             *ch,
+//          struct fuse_args             *args,
+//          const struct fuse_operations *op,
+//          size_t                        op_size)
+// {
+//   return fuse_new_common(ch,args,op,op_size);
+// }
 
 void
 fuse_destroy(struct fuse *f)

libfuse/lib/fuse_i.h

@@ -69,6 +69,7 @@ struct fuse_ll
   int broken_splice_nonblock;
   uint64_t notify_ctr;
   struct fuse_notify_req notify_list;
+  int passthrough_max_stack_depth;
 };
 
 struct fuse_cmd

libfuse/lib/fuse_lowlevel.cpp

@@ -1117,7 +1117,7 @@ do_init(fuse_req_t             req,
         struct fuse_in_header *hdr_)
 {
   struct fuse_init_out outarg = {0};
-  struct fuse_init_in *arg = (struct fuse_init_in *) &hdr_[1];
+  struct fuse_init_in *arg = (struct fuse_init_in*)&hdr_[1];
   struct fuse_ll *f = req->f;
   size_t bufsize = fuse_chan_bufsize(req->ch);
   uint64_t inargflags;
@@ -1288,7 +1288,7 @@ do_init(fuse_req_t             req,
   if(f->conn.want & FUSE_CAP_PASSTHROUGH)
     {
       outargflags |= FUSE_PASSTHROUGH;
-      outarg.max_stack_depth = 2;
+      outarg.max_stack_depth = (f->passthrough_max_stack_depth + 1);
     }
 
   if(inargflags & FUSE_INIT_EXT)
@@ -1800,6 +1800,7 @@ enum {
 
 static const struct fuse_opt fuse_ll_opts[] =
   {
+    { "passthrough-max-stack-depth=%u", offsetof(struct fuse_ll, passthrough_max_stack_depth), 0 },
     { "debug", offsetof(struct fuse_ll, debug), 1 },
     { "-d", offsetof(struct fuse_ll, debug), 1 },
     { "max_readahead=%u", offsetof(struct fuse_ll, conn.max_readahead), 0 },

src/config.cpp

@@ -65,6 +65,7 @@ namespace l
     IFERT("kernel-permissions-check");
     IFERT("mount");
     IFERT("nullrw");
+    IFERT("passthrough-max-stack-depth");
     IFERT("pid");
     IFERT("pin-threads");
     IFERT("process-thread-count");
@@ -204,6 +205,7 @@ Config::Config()
   _map["nfsopenhack"]            = &nfsopenhack;
   _map["nullrw"]                 = &nullrw;
   _map["passthrough"]            = &passthrough;
+  _map["passthrough-max-stack-depth"] = &passthrough_max_stack_depth;
   _map["pid"]                    = &pid;
   _map["parallel-direct-writes"] = &parallel_direct_writes;
   _map["pin-threads"]            = &fuse_pin_threads;

src/config.hpp

@@ -56,6 +56,7 @@
 #include <sys/stat.h>
 
 typedef ToFromWrapper<bool>                  ConfigBOOL;
+typedef ToFromWrapper<uint32_t>              ConfigUINT32;
 typedef ToFromWrapper<uint64_t>              ConfigUINT64;
 typedef ToFromWrapper<int64_t>               ConfigS64;
 typedef ToFromWrapper<int>                   ConfigINT;
@@ -124,6 +125,7 @@ public:
   NFSOpenHack    nfsopenhack;
   ConfigBOOL     nullrw;
   Passthrough    passthrough = Passthrough::ENUM::OFF;
+  ConfigUINT32   passthrough_max_stack_depth = 1;
   ConfigBOOL     parallel_direct_writes;
   ConfigGetPid   pid;
   ConfigBOOL     posix_acl;

src/from_string.cpp

@@ -65,6 +65,53 @@ str::from(const std::string_view  val_,
   return 0;
 }
 
+int
+str::from(const std::string_view  val_,
+          uint32_t               *rv_)
+{
+  uint64_t tmp;
+  const int base = 10;
+
+  auto [ptr,ec] = std::from_chars(val_.begin(),
+                                  val_.end(),
+                                  tmp,
+                                  base);
+
+  if(ec != std::errc{})
+    return -EINVAL;
+  *rv_ = tmp;
+  if(ptr == val_.end())
+    return 0;
+
+  switch(*ptr)
+    {
+    case 'b':
+    case 'B':
+      *rv_ *= 1ULL;
+      break;
+
+    case 'k':
+    case 'K':
+      *rv_ *= 1024ULL;
+      break;
+
+    case 'm':
+    case 'M':
+      *rv_ *= (1024ULL * 1024ULL);
+      break;
+
+    case 'g':
+    case 'G':
+      *rv_ *= (1024ULL * 1024ULL * 1024ULL);
+      break;
+
+    default:
+      return -EINVAL;
+    }
+
+  return 0;
+}
+
 int
 str::from(const std::string_view  val_,
           int64_t                *rv_)

src/from_string.hpp

@@ -29,6 +29,7 @@ namespace str
 {
   int from(const std::string_view, bool *);
   int from(const std::string_view, int *);
+  int from(const std::string_view, uint32_t *);
   int from(const std::string_view, uint64_t *);
   int from(const std::string_view, int64_t *);
   int from(const std::string_view, std::string *);

src/mergerfs.cpp

@@ -18,6 +18,8 @@
 #include "mergerfs_fsck.hpp"
 #include "mergerfs_collect_info.hpp"
 
+#include "CLI11.hpp"
+
 #include "fs_path.hpp"
 #include "fs_readahead.hpp"
 #include "fs_umount2.hpp"

src/option_parser.cpp

@@ -53,6 +53,12 @@ enum
     MERGERFS_OPT_VERSION
   };
 
+struct OptParseState
+{
+  std::vector<std::string> opts;
+  std::vector<std::string> branches;
+  Config::ErrVec *errs;
+};
 
 static
 void
@@ -79,30 +85,29 @@ _set_kv_option(const std::string &key_,
 
 static
 void
-_set_fuse_threads(Config &cfg_)
+_set_fuse_threads()
 {
-  fuse_config_set_read_thread_count(cfg_.fuse_read_thread_count);
-  fuse_config_set_process_thread_count(cfg_.fuse_process_thread_count);
-  fuse_config_set_process_thread_queue_depth(cfg_.fuse_process_thread_queue_depth);
-  fuse_config_set_pin_threads(cfg_.fuse_pin_threads);
+  fuse_config_set_read_thread_count(cfg.fuse_read_thread_count);
+  fuse_config_set_process_thread_count(cfg.fuse_process_thread_count);
+  fuse_config_set_process_thread_queue_depth(cfg.fuse_process_thread_queue_depth);
+  fuse_config_set_pin_threads(cfg.fuse_pin_threads);
 }
 
 static
 void
-_set_fsname(Config    &cfg_,
-            fuse_args *args_)
+_set_fsname(fuse_args *args_)
 {
-  if(cfg_.fsname->empty())
+  if(cfg.fsname->empty())
     {
       std::vector<std::string> paths;
 
-      cfg_.branches->to_paths(paths);
+      cfg.branches->to_paths(paths);
 
       if(paths.size() > 0)
-        cfg_.fsname = str::remove_common_prefix_and_join(paths,':');
+        cfg.fsname = str::remove_common_prefix_and_join(paths,':');
     }
 
-  ::_set_kv_option("fsname",cfg_.fsname,args_);
+  ::_set_kv_option("fsname",cfg.fsname,args_);
 }
 
 static
@@ -114,10 +119,9 @@ _set_subtype(fuse_args *args_)
 
 static
 void
-_set_default_options(fuse_args *args_,
-                     Config    &cfg_)
+_set_default_options(fuse_args *args_)
 {
-  if(cfg_.kernel_permissions_check)
+  if(cfg.kernel_permissions_check)
     ::_set_option("default_permissions",args_);
 
   if(geteuid() == 0)
@@ -158,8 +162,7 @@ _should_ignore(const std::string &key_)
 
 static
 int
-_parse_and_process_kv_arg(Config            &cfg_,
-                          Config::ErrVec    *errs_,
+_parse_and_process_kv_arg(Config::ErrVec    *errs_,
                           const std::string &key_,
                           const std::string &val_)
 {
@@ -169,7 +172,7 @@ _parse_and_process_kv_arg(Config            &cfg_,
 
   rv = 0;
   if(key == "config")
-    return ((cfg_.from_file(val_,errs_) < 0) ? 1 : 0);
+    return ((cfg.from_file(val_,errs_) < 0) ? 1 : 0);
   ef(key == "attr_timeout")
     key = "cache.attr";
   ef(key == "entry_timeout")
@@ -189,10 +192,10 @@ _parse_and_process_kv_arg(Config            &cfg_,
   ef(::_should_ignore(key_))
     return 0;
 
-  if(cfg_.has_key(key) == false)
+  if(cfg.has_key(key) == false)
     return 1;
 
-  rv = cfg_.set_raw(key,val);
+  rv = cfg.set_raw(key,val);
   if(rv)
     errs_->push_back({rv,key+'='+val});
 
@@ -201,9 +204,8 @@ _parse_and_process_kv_arg(Config            &cfg_,
 
 static
 int
-_process_opt(Config           &cfg_,
-            Config::ErrVec    *errs_,
-            const std::string &arg_)
+_process_opt(Config::ErrVec    *errs_,
+             const std::string &arg_)
 {
   std::string key;
   std::string val;
@@ -212,20 +214,19 @@ _process_opt(Config           &cfg_,
   key = str::trim(key);
   val = str::trim(val);
 
-  return ::_parse_and_process_kv_arg(cfg_,errs_,key,val);
+  return ::_parse_and_process_kv_arg(errs_,key,val);
 }
 
 static
 int
-_process_branches(Config        &cfg_,
-                 Config::ErrVec *errs_,
-                 const char     *arg_)
+_process_branches(Config::ErrVec *errs_,
+                  const char     *arg_)
 {
   int rv;
   std::string arg;
 
   arg = arg_;
-  rv = cfg_.set_raw("branches",arg);
+  rv = cfg.set_raw("branches",arg);
   if(rv)
     errs_->push_back({rv,"branches="+arg});
 
@@ -234,15 +235,14 @@ _process_branches(Config        &cfg_,
 
 static
 int
-_process_mount(Config        &cfg_,
-              Config::ErrVec *errs_,
-              const char     *arg_)
+_process_mount(Config::ErrVec *errs_,
+               const char     *arg_)
 {
   int rv;
   std::string arg;
 
   arg = arg_;
-  rv = cfg_.set_raw("mount",arg);
+  rv = cfg.set_raw("mount",arg);
   if(rv)
     errs_->push_back({rv,"mount="+arg});
 
@@ -251,26 +251,26 @@ _process_mount(Config        &cfg_,
 
 static
 void
-_postprocess_passthrough(Config &cfg_)
+_postprocess_passthrough()
 {
-  if(cfg_.passthrough == Passthrough::ENUM::OFF)
+  if(cfg.passthrough == Passthrough::ENUM::OFF)
     return;
 
-  if(cfg_.cache_files == CacheFiles::ENUM::OFF)
+  if(cfg.cache_files == CacheFiles::ENUM::OFF)
     {
       SysLog::warning("'cache.files' can not be 'off' when using 'passthrough'."
                       " Setting 'cache.files=full'");
-      cfg_.cache_files = CacheFiles::ENUM::FULL;
+      cfg.cache_files = CacheFiles::ENUM::FULL;
     }
 
-  if(cfg_.writeback_cache == true)
+  if(cfg.writeback_cache == true)
     {
       SysLog::warning("'cache.writeback' can not be enabled when using 'passthrough'."
                       " Setting 'cache.writeback=false'");
-      cfg_.writeback_cache = false;
+      cfg.writeback_cache = false;
     }
 
-  if(cfg_.moveonenospc.enabled == true)
+  if(cfg.moveonenospc.enabled == true)
     {
       SysLog::warning("`moveonenospc` will not function when `passthrough` is enabled");
     }
@@ -292,18 +292,16 @@ _option_processor(void       *data_,
                   int         key_,
                   fuse_args  *outargs_)
 {
-  Config::ErrVec *errs = (Config::ErrVec*)data_;
+  OptParseState &state = *(OptParseState*)data_;
 
   switch(key_)
     {
     case FUSE_OPT_KEY_OPT:
-      return ::_process_opt(cfg,errs,arg_);
+      return ::_process_opt(state.errs,arg_);
 
     case FUSE_OPT_KEY_NONOPT:
-      if(cfg.branches->empty())
-        return ::_process_branches(cfg,errs,arg_);
-      else
-        return ::_process_mount(cfg,errs,arg_);
+      state.branches.push_back(arg_);
+      return 0;
 
     case MERGERFS_OPT_HELP:
       ::_usage();
@@ -341,15 +339,14 @@ _option_processor(void       *data_,
 
 static
 void
-_check_for_mount_loop(Config         &cfg_,
-                      Config::ErrVec *errs_)
+_check_for_mount_loop(Config::ErrVec *errs_)
 {
   fs::path mount;
   std::vector<fs::path> branches;
   std::error_code ec;
 
-  mount    = *cfg_.mountpoint;
-  branches = cfg_.branches->to_paths();
+  mount    = *cfg.mountpoint;
+  branches = cfg.branches->to_paths();
   for(const auto &branch : branches)
     {
       if(std::filesystem::equivalent(branch,mount,ec))
@@ -365,25 +362,25 @@ _check_for_mount_loop(Config         &cfg_,
 
 static
 void
-_print_warnings(Config &cfg_)
+_print_warnings()
 {
-  if(cfg_.passthrough != Passthrough::ENUM::OFF)
+  if(cfg.passthrough != Passthrough::ENUM::OFF)
     {
-      if(cfg_.cache_files == CacheFiles::ENUM::OFF)
+      if(cfg.cache_files == CacheFiles::ENUM::OFF)
         {
           SysLog::warning("'cache.files' can not be 'off' when using 'passthrough'."
                           " Setting 'cache.files=auto-full'");
-          cfg_.cache_files = CacheFiles::ENUM::AUTO_FULL;
+          cfg.cache_files = CacheFiles::ENUM::AUTO_FULL;
         }
 
-      if(cfg_.writeback_cache == true)
+      if(cfg.writeback_cache == true)
         {
           SysLog::warning("'cache.writeback' can not be enabled when using 'passthrough'."
                           " Setting 'cache.writeback=false'");
-          cfg_.writeback_cache = false;
+          cfg.writeback_cache = false;
         }
 
-      if(cfg_.moveonenospc.enabled == true)
+      if(cfg.moveonenospc.enabled == true)
         {
           SysLog::warning("`moveonenospc` will not function when `passthrough` is enabled");
         }
@@ -392,10 +389,10 @@ _print_warnings(Config &cfg_)
 
 static
 void
-_cleanup_options(Config &cfg_)
+_cleanup_options()
 {
-  if(!cfg_.symlinkify)
-    cfg_.symlinkify_timeout = -1;
+  if(!cfg.symlinkify)
+    cfg.symlinkify_timeout = -1;
 }
 
 namespace options
@@ -413,25 +410,49 @@ namespace options
         FUSE_OPT_KEY("--version",MERGERFS_OPT_VERSION),
         {NULL,-1U,0}
       };
+    OptParseState state{.errs=errs_};
 
     fuse_opt_parse(args_,
-                   errs_,
+                   &state,
                    opts,
                    ::_option_processor);
 
+    if(state.branches.size() < 2)
+      errs_->push_back({0,"mountpoint not set"});
+    if(state.branches.size() < 1)
+      errs_->push_back({0,"branches not set"});
+    if(!errs_->empty())
+      return;
+
+    _process_mount(errs_,
+                   state.branches.back().c_str());
+
+    state.branches.pop_back();
+    _process_branches(errs_,
+                      str::join(state.branches,':').c_str());
+
     if(cfg.branches->empty())
       errs_->push_back({0,"branches not set"});
     if(cfg.mountpoint->empty())
       errs_->push_back({0,"mountpoint not set"});
+    ::_check_for_mount_loop(errs_);
+    if(!errs_->empty())
+      return;
 
-    ::_postprocess_passthrough(cfg);
-    ::_check_for_mount_loop(cfg,errs_);
-    ::_set_default_options(args_,cfg);
-    ::_set_fsname(cfg,args_);
+    fuse_opt_add_arg(args_,
+                     cfg.mountpoint.to_string().c_str());
+
+    ::_postprocess_passthrough();
+    ::_set_default_options(args_);
+    ::_set_fsname(args_);
     ::_set_subtype(args_);
-    ::_set_fuse_threads(cfg);
-    ::_print_warnings(cfg);
-    ::_cleanup_options(cfg);
+    ::_set_fuse_threads();
+    ::_print_warnings();
+    ::_cleanup_options();
+
+    _set_option(fmt::format("passthrough-max-stack-depth={}",
+                            cfg.passthrough_max_stack_depth.to_string()),
+                args_);
 
     cfg.finish_initializing();
   }

src/to_string.cpp

@@ -36,6 +36,12 @@ str::to(const int int_)
   return fmt::format("{}",int_);
 }
 
+std::string
+str::to(const uint32_t i_)
+{
+  return fmt::format("{}",i_);
+}
+
 std::string
 str::to(const uint64_t uint64_)
 {

src/to_string.hpp

@@ -29,6 +29,7 @@ namespace str
 {
   std::string to(const bool);
   std::string to(const int);
+  std::string to(const uint32_t);
   std::string to(const uint64_t);
   std::string to(const int64_t);
   std::string to(const std::string&);