github/mergerfs
4
0
Fork 0
mirror of https://github.com/trapexit/mergerfs.git synced 2026-10-21 06:16:25 +00:00
Code Issues Releases Wiki Activity
Files
6d218fa87fab613b7a733f5272e6c2ebfa79f030
mergerfs/src/fuse_create.cpp
T

350 lines
8.8 KiB
C++
Raw Blame History

/*
ISC License
Copyright (c) 2026, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
FILE CREATION WITH FUSE PASSTHROUGH SUPPORT
===========================================
This file implements FUSE create() which creates a new file and opens it.
Unlike fuse_open.cpp, this file does NOT use a retry loop because the
kernel guarantees serialization of create operations.
WHY NO RETRY LOOP?
------------------
The fuse_open.cpp retry loop handles the case where multiple threads race
to open an EXISTING file. With create(), the kernel serializes namespace
operations at the VFS layer - only one create for a given path can succeed.
Additionally, when a file is created, FUSE allocates a completely new
nodeid (inode number). Since mergerfs never reuses nodeids, there should
never be a collision in the open_files map.
PASSTHROUGH MODE
----------------
Like fuse_open.cpp, this file supports FUSE passthrough mode for improved
I/O performance. The backing_id is obtained from fuse_passthrough_open()
and stored in the OpenFile entry.
*/
#include "fuse_create.hpp"
#include "state.hpp"
#include "config.hpp"
#include "fs_readlink.hpp"
#include "errno.hpp"
#include "fileinfo.hpp"
#include "fs_acl.hpp"
#include "fs_close.hpp"
#include "fs_clonepath.hpp"
#include "fs_open.hpp"
#include "fs_open_as.hpp"
#include "fs_openat.hpp"
#include "fs_path.hpp"
#include "fuse_passthrough.hpp"
#include "procfs.hpp"
#include "syslog.hpp"
#include "ugid.hpp"
#include "fuse.h"
#include <string>
#include <vector>
/*
The kernel expects being able to issue read requests when running
with writeback caching enabled so we must change O_WRONLY to
O_RDWR.
With writeback caching enabled the kernel handles O_APPEND. Could
be an issue if the underlying file changes out of band but that is
true of any caching.
*/
static
void
_tweak_flags_cache_writeback(int *flags_)
{
if((*flags_ & O_ACCMODE) == O_WRONLY)
*flags_ = ((*flags_ & ~O_ACCMODE) | O_RDWR);
if(*flags_ & O_APPEND)
*flags_ &= ~O_APPEND;
}
static
bool
_rdonly(const int flags_)
{
return ((flags_ & O_ACCMODE) == O_RDONLY);
}
static
bool
_calculate_flush(FlushOnClose const flushonclose_,
int const flags_)
{
switch(flushonclose_)
{
case FlushOnCloseEnum::NEVER:
return false;
case FlushOnCloseEnum::OPENED_FOR_WRITE:
return !::_rdonly(flags_);
case FlushOnCloseEnum::ALWAYS:
return true;
}
return true;
}
static
void
_config_to_ffi_flags(Config &cfg_,
const int tid_,
fuse_file_info_t *ffi_)
{
switch(cfg_.cache_files)
{
case CacheFiles::ENUM::OFF:
ffi_->direct_io = 1;
ffi_->keep_cache = 0;
ffi_->auto_cache = 0;
break;
case CacheFiles::ENUM::PARTIAL:
ffi_->direct_io = 0;
ffi_->keep_cache = 0;
ffi_->auto_cache = 0;
break;
case CacheFiles::ENUM::FULL:
ffi_->direct_io = 0;
ffi_->keep_cache = 1;
ffi_->auto_cache = 0;
break;
case CacheFiles::ENUM::AUTO_FULL:
ffi_->direct_io = 0;
ffi_->keep_cache = 0;
ffi_->auto_cache = 1;
break;
case CacheFiles::ENUM::PER_PROCESS:
std::string proc_name;
proc_name = procfs::get_name(tid_);
if(cfg_.cache_files_process_names.count(proc_name) == 0)
{
ffi_->direct_io = 1;
ffi_->keep_cache = 0;
ffi_->auto_cache = 0;
}
else
{
ffi_->direct_io = 0;
ffi_->keep_cache = 0;
ffi_->auto_cache = 0;
}
break;
}
if(cfg_.parallel_direct_writes == true)
ffi_->parallel_direct_writes = ffi_->direct_io;
}
static
int
_create_core(const ugid_t ugid_,
const fs::path &fullpath_,
mode_t mode_,
const mode_t umask_,
const int flags_)
{
if(!fs::acl::dir_has_defaults(fullpath_))
mode_ &= ~umask_;
return fs::open_as(ugid_,fullpath_,flags_,mode_);
}
static
int
_create_core(const ugid_t ugid_,
const Branch *branch_,
const fs::path &fusepath_,
fuse_file_info_t *ffi_,
const mode_t mode_,
const mode_t umask_)
{
int rv;
FileInfo *fi;
fs::path fullpath;
fullpath = branch_->path / fusepath_;
rv = ::_create_core(ugid_,fullpath,mode_,umask_,ffi_->flags);
if(rv < 0)
return rv;
fi = new FileInfo(rv,*branch_,fusepath_,ffi_->direct_io);
ffi_->fh = fi->to_fh();
return 0;
}
static
int
_create(const ugid_t ugid_,
const Policy::Search &searchFunc_,
const Policy::Create &createFunc_,
const Branches &branches_,
const fs::path &fusepath_,
fuse_file_info_t *ffi_,
const mode_t mode_,
const mode_t umask_)
{
int rv;
fs::path fullpath;
fs::path fusedirpath;
std::vector<Branch*> createpaths;
std::vector<Branch*> existingpaths;
fusedirpath = fusepath_.parent_path();
rv = searchFunc_(branches_,fusedirpath,existingpaths);
if(rv < 0)
return rv;
rv = createFunc_(branches_,fusedirpath,createpaths);
if(rv < 0)
return rv;
rv = fs::clonepath(existingpaths[0]->path,
createpaths[0]->path,
fusedirpath);
if(rv < 0)
return rv;
return ::_create_core(ugid_,
createpaths[0],
fusepath_,
ffi_,
mode_,
umask_);
}
constexpr
u64
_(const PassthroughIOEnum e_,
cu64 m_)
{
return ((((u64)e_) << 32) | (m_ & O_ACCMODE));
}
static
int
_create(const fuse_req_ctx_t *ctx_,
const fs::path &fusepath_,
mode_t mode_,
fuse_file_info_t *ffi_)
{
auto &of = state.open_files;
::_config_to_ffi_flags(cfg,ctx_->pid,ffi_);
if(cfg.cache_writeback)
::_tweak_flags_cache_writeback(&ffi_->flags);
ffi_->noflush = !::_calculate_flush(cfg.flushonclose,ffi_->flags);
int rv = ::_create(ctx_,
cfg.func.getattr.policy,
cfg.func.create.policy,
cfg.branches,
fusepath_,
ffi_,
mode_,
ctx_->umask);
if(rv == -EROFS)
{
cfg.branches.find_and_set_mode_ro();
rv = ::_create(ctx_,
cfg.func.getattr.policy,
cfg.func.create.policy,
cfg.branches,
fusepath_,
ffi_,
mode_,
ctx_->umask);
}
if(rv < 0)
return rv;
FileInfo *fi = FileInfo::from_fh(ffi_->fh);
int backing_id = INVALID_BACKING_ID;
switch(_(cfg.passthrough_io,ffi_->flags))
{
case _(PassthroughIO::ENUM::RO,O_RDONLY):
case _(PassthroughIO::ENUM::WO,O_WRONLY):
case _(PassthroughIO::ENUM::RW,O_RDONLY):
case _(PassthroughIO::ENUM::RW,O_WRONLY):
case _(PassthroughIO::ENUM::RW,O_RDWR):
backing_id = FUSE::passthrough_open(fi->fd);
if(fuse_backing_id_is_valid(backing_id))
{
ffi_->backing_id = backing_id;
ffi_->passthrough = true;
ffi_->keep_cache = false;
}
break;
default:
break;
}
bool inserted = of.try_emplace(ctx_->nodeid,
backing_id,
fi);
// Really. This should never happen. FUSE should not be allowing a
// create for an existing nodeid. mergerfs doesn't reuse nodeids. It
// always uses a fixed generation value and always uses new nodeids.
if(not inserted)
{
const char *msg = "nodeid already exists in open_files map";
FUSE::passthrough_close(backing_id);
fs::close(fi->fd);
delete fi;
ffi_->fh = 0;
SysLog::crit(msg);
fmt::println(stderr,"{}",msg);
return -EIO;
}
return 0;
}
int
FUSE::create(const fuse_req_ctx_t *ctx_,
const char *fusepath_,
mode_t mode_,
fuse_file_info_t *ffi_)
{
const fs::path fusepath{fusepath_};
return ::_create(ctx_,fusepath,mode_,ffi_);
}
Reference in New Issue View Git Blame Copy Permalink