Mirror
/
mergerfs
mirror of https://github.com/trapexit/mergerfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Removing eplup

pull/1601/head
François-Xavier Payet 4 days ago
parent
fc26b35e46
commit
2411402723
5 changed files with 1 additions and 317 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      mkdocs/docs/config/functions_categories_policies.md
  2. 4
      src/policies.cpp
  3. 4
      src/policies.hpp
  4. 236
      src/policy_eplup.cpp
  5. 70
      src/policy_eplup.hpp

4
mkdocs/docs/config/functions_categories_policies.md
View File

@ -90,7 +90,7 @@ suddenly become read-only when it encounters an error.
Policies, as described below, are of two basic classifications. `path
preserving` and `non-path preserving`.
All policies which start with `ep` (`epff`, `eplfs`, `eplus`, `eplup`, `epmfs`,
All policies which start with `ep` (`epff`, `eplfs`, `eplus`, `epmfs`,
`eprand`) are `path preserving`. `ep` stands for `existing path`.
A path preserving policy will only consider branches where the relative
@ -129,8 +129,6 @@ percentage of space
| eprand (existing path, random) | Calls **epall** and then randomizes. Returns 1. |
| epff (existing path, first found) | Given the order of the branches, as defined at mount time or configured at runtime, act on the first one found where the relative path exists. |
| eplfs (existing path, least free space) | Of all the branches on which the relative path exists choose the branch with the least free space. |
| eplup (existing path, least used percent) | Of all the branches on which the relative path exists choose the branch with the least used
percentage of space |
| eplus (existing path, least used space) | Of all the branches on which the relative path exists choose the branch with the least used space. |
| epall (existing path, all) | For **mkdir**, **mknod**, and **symlink** it will apply to all found. **create** works like **epff** (but more expensive because it doesn't stop after finding a valid branch). |
| newest | Pick the file / directory with the largest mtime. |

4
src/policies.cpp
View File

@ -28,7 +28,6 @@
FUNC(epff) \
FUNC(eplfs) \
FUNC(eplus) \
FUNC(eplup) \
FUNC(epmfs) \
FUNC(eppfrd) \
FUNC(eprand) \
@ -75,7 +74,6 @@ Policy::EPAll::Action Policies::Action::epall;
Policy::EPFF::Action Policies::Action::epff;
Policy::EPLFS::Action Policies::Action::eplfs;
Policy::EPLUS::Action Policies::Action::eplus;
Policy::EPLUP::Action Policies::Action::eplup;
Policy::EPMFS::Action Policies::Action::epmfs;
Policy::EPPFRD::Action Policies::Action::eppfrd;
Policy::EPRand::Action Policies::Action::eprand;
@ -98,7 +96,6 @@ Policy::EPAll::Create Policies::Create::epall;
Policy::EPFF::Create Policies::Create::epff;
Policy::EPLFS::Create Policies::Create::eplfs;
Policy::EPLUS::Create Policies::Create::eplus;
Policy::EPLUP::Create Policies::Create::eplup;
Policy::EPMFS::Create Policies::Create::epmfs;
Policy::EPPFRD::Create Policies::Create::eppfrd;
Policy::EPRand::Create Policies::Create::eprand;
@ -121,7 +118,6 @@ Policy::EPAll::Search Policies::Search::epall;
Policy::EPFF::Search Policies::Search::epff;
Policy::EPLFS::Search Policies::Search::eplfs;
Policy::EPLUS::Search Policies::Search::eplus;
Policy::EPLUP::Search Policies::Search::eplup;
Policy::EPMFS::Search Policies::Search::epmfs;
Policy::EPPFRD::Search Policies::Search::eppfrd;
Policy::EPRand::Search Policies::Search::eprand;

4
src/policies.hpp
View File

@ -23,7 +23,6 @@
#include "policy_epff.hpp"
#include "policy_eplfs.hpp"
#include "policy_eplus.hpp"
#include "policy_eplup.hpp"
#include "policy_epmfs.hpp"
#include "policy_eppfrd.hpp"
#include "policy_eprand.hpp"
@ -51,7 +50,6 @@ struct Policies
static Policy::EPAll::Action epall;
static Policy::EPFF::Action epff;
static Policy::EPLFS::Action eplfs;
static Policy::EPLUP::Action eplup;
static Policy::EPLUS::Action eplus;
static Policy::EPMFS::Action epmfs;
static Policy::EPPFRD::Action eppfrd;
@ -79,7 +77,6 @@ struct Policies
static Policy::EPAll::Create epall;
static Policy::EPFF::Create epff;
static Policy::EPLFS::Create eplfs;
static Policy::EPLUP::Create eplup;
static Policy::EPLUS::Create eplus;
static Policy::EPMFS::Create epmfs;
static Policy::EPPFRD::Create eppfrd;
@ -107,7 +104,6 @@ struct Policies
static Policy::EPAll::Search epall;
static Policy::EPFF::Search epff;
static Policy::EPLFS::Search eplfs;
static Policy::EPLUP::Search eplup;
static Policy::EPLUS::Search eplus;
static Policy::EPMFS::Search epmfs;
static Policy::EPPFRD::Search eppfrd;

236
src/policy_eplup.cpp
View File

@ -1,236 +0,0 @@
/*
Copyright (c) 2025, François-Xavier Payet <fx@payet.io>
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.
*/
#include "policy_eplup.hpp"
#include "errno.hpp"
#include "fs_exists.hpp"
#include "fs_info.hpp"
#include "fs_path.hpp"
#include "fs_statvfs_cache.hpp"
#include "policy.hpp"
#include "policy_error.hpp"
#include "rwlock.hpp"
#include <limits>
#include <string>
using std::string;
static int
_create(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_)
{
int rv;
int error;
fs::info_t info;
Branch *obranch;
obranch = nullptr;
error = ENOENT;
uint64_t best_used = 0;
uint64_t best_total = 1; /* avoid div-by-zero */
for (auto &branch : *branches_)
{
if (branch.ro_or_nc())
error_and_continue(error, EROFS);
if (!fs::exists(branch.path, fusepath_))
error_and_continue(error, ENOENT);
rv = fs::info(branch.path, &info);
if (rv < 0)
error_and_continue(error, ENOENT);
if (info.readonly)
error_and_continue(error, EROFS);
if (info.spaceavail < branch.minfreespace())
error_and_continue(error, ENOSPC);
uint64_t used = info.spaceused;
uint64_t total = info.spaceused + info.spaceavail;
if (total == 0)
{
used = 0;
total = 1;
}
if (obranch == nullptr)
{
best_used = used;
best_total = total;
obranch = &branch;
continue;
}
unsigned __int128 lhs = (unsigned __int128)used * (unsigned __int128)best_total;
unsigned __int128 rhs = (unsigned __int128)best_used * (unsigned __int128)total;
if (lhs >= rhs)
continue;
best_used = used;
best_total = total;
obranch = &branch;
}
if (obranch == nullptr)
return -error;
paths_.emplace_back(obranch);
return 0;
}
static int
_action(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_)
{
int rv;
int error;
fs::info_t info;
Branch *obranch;
obranch = nullptr;
error = ENOENT;
uint64_t best_used = 0;
uint64_t best_total = 1;
for (auto &branch : *branches_)
{
if (branch.ro())
error_and_continue(error, EROFS);
if (!fs::exists(branch.path, fusepath_))
error_and_continue(error, ENOENT);
rv = fs::info(branch.path, &info);
if (rv < 0)
error_and_continue(error, ENOENT);
if (info.readonly)
error_and_continue(error, EROFS);
uint64_t used = info.spaceused;
uint64_t total = info.spaceused + info.spaceavail;
if (total == 0)
{
used = 0;
total = 1;
}
if (obranch == nullptr)
{
best_used = used;
best_total = total;
obranch = &branch;
continue;
}
unsigned __int128 lhs = (unsigned __int128)used * (unsigned __int128)best_total;
unsigned __int128 rhs = (unsigned __int128)best_used * (unsigned __int128)total;
if (lhs >= rhs)
continue;
best_used = used;
best_total = total;
obranch = &branch;
}
if (obranch == nullptr)
return -error;
paths_.emplace_back(obranch);
return 0;
}
static int
_search(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_)
{
int rv;
uint64_t used;
uint64_t avail;
uint64_t best_used = 0;
uint64_t best_total = 1;
Branch *obranch;
obranch = nullptr;
for (auto &branch : *branches_)
{
if (!fs::exists(branch.path, fusepath_))
continue;
rv = fs::statvfs_cache_spaceused(branch.path, &used);
if (rv < 0)
continue;
rv = fs::statvfs_cache_spaceavail(branch.path, &avail);
if (rv < 0)
continue;
uint64_t total = used + avail;
if (total == 0)
{
used = 0;
total = 1;
}
if (obranch == nullptr)
{
best_used = used;
best_total = total;
obranch = &branch;
continue;
}
unsigned __int128 lhs = (unsigned __int128)used * (unsigned __int128)best_total;
unsigned __int128 rhs = (unsigned __int128)best_used * (unsigned __int128)total;
if (lhs >= rhs)
continue;
best_used = used;
best_total = total;
obranch = &branch;
}
if (obranch == nullptr)
return -ENOENT;
paths_.emplace_back(obranch);
return 0;
}
int Policy::EPLUP::Action::operator()(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_) const
{
return ::_action(branches_, fusepath_, paths_);
}
int Policy::EPLUP::Create::operator()(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_) const
{
return ::_create(branches_, fusepath_, paths_);
}
int Policy::EPLUP::Search::operator()(const Branches::Ptr &branches_,
const fs::path &fusepath_,
std::vector<Branch *> &paths_) const
{
return ::_search(branches_, fusepath_, paths_);
}

70
src/policy_eplup.hpp
View File

@ -1,70 +0,0 @@
/*
ISC License
Copyright (c) 2025, François-Xavier Payet <fx@payet.io>
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.
*/
#pragma once
#include "policy.hpp"
namespace Policy
{
namespace EPLUP
{
class Action final : public Policy::ActionImpl
{
public:
Action()
: Policy::ActionImpl("eplup")
{
}
public:
int operator()(const Branches::Ptr &,
const fs::path &,
std::vector<Branch *> &) const final;
};
class Create final : public Policy::CreateImpl
{
public:
Create()
: Policy::CreateImpl("eplup")
{
}
public:
int operator()(const Branches::Ptr &,
const fs::path &,
std::vector<Branch *> &) const final;
bool path_preserving(void) const final { return true; }
};
class Search final : public Policy::SearchImpl
{
public:
Search()
: Policy::SearchImpl("eplup")
{
}
public:
int operator()(const Branches::Ptr &,
const fs::path &,
std::vector<Branch *> &) const final;
};
}
}
Write Preview
Loading…
Cancel
Save