21 #ifndef CVMFS_LIBCVMFS
22 #ifdef FUSE_CAP_EXPORT_SUPPORT
23 #define CVMFS_NFS_SUPPORT
25 #warning "No NFS support, Fuse too old"
48 #include "google/protobuf/stubs/common.h"
56 #ifdef CVMFS_NFS_SUPPORT
94 timestamp_last_ = time(NULL);
110 if (instance.length() > 24)
113 if (!instance_sanitizer.
IsValid(instance)) {
114 boot_error_ =
"invalid instance name (" + instance +
"), " +
115 "only characters a-z, A-Z, 0-9, _ are allowed";
130 boot_error_ =
"Failure: shared local disk cache and alien cache mutually "
131 "exclusive. Please turn off shared local disk cache.";
136 boot_error_ =
"Failure: quota management and alien cache mutually "
137 "exclusive. Please turn off quota limit.";
144 boot_error_ =
"Failure: libcvmfs supports only unmanaged exclusive cache "
153 "'CVMFS_CACHE_BASE' and 'CVMFS_CACHE_DIR' are mutually exclusive";
184 unsigned length_tempdir = file_system->
workspace_.length() + 1;
185 sqlite3_temp_directory =
static_cast<char *
>(sqlite3_malloc(length_tempdir));
186 snprintf(sqlite3_temp_directory,
223 "Overall number of file open operations");
225 "Overall number of directory open operations");
227 "Number of lookups");
229 "Number of negative lookups");
232 "Number of stats for stale (open, meanwhile changed) regular files");
234 "Overall number of statsfs calls");
236 "Number of statsfs calls that accessed the cached statfs info");
239 "Number of links read");
241 "Number of inode forgets");
243 "Number of stale inodes that got replaced by an up-to-date version");
245 "Number of currently opened files");
247 "Number of currently opened directories");
249 "Number of I/O errors"));
251 "EIO returned to calling process. Sum of individual eio counters");
253 "EIO returned to calling process. cvmfs.cc:cvmfs_lookup()");
255 "EIO returned to calling process. cvmfs.cc:ReplyNegative()");
257 "EIO returned to calling process. cvmfs.cc:cvmfs_opendir()");
259 "EIO returned to calling process. cvmfs.cc:cvmfs_open()");
261 "EIO returned to calling process. cvmfs.cc:cvmfs_read()");
263 "EIO returned to calling process. cvmfs.cc:cvmfs_open()");
265 "EIO returned to calling process. cvmfs.cc:cvmfs_read()");
267 "EIO returned to calling process. cvmfs.cc:cvmfs_read()");
269 "EMFILE returned to calling process. cvmfs.cc:cvmfs_read()");
297 const string &instance
394 boot_error_ =
"Failure: libcvmfs does not support NFS export.";
468 if (sqlite3_temp_directory) {
469 sqlite3_free(sqlite3_temp_directory);
470 sqlite3_temp_directory = NULL;
499 google::protobuf::ShutdownProtobufLibrary();
511 boot_error_ =
"could not acquire workspace lock (" +
526 boot_error_ =
"could not acquire workspace lock (" +
537 int sqlite_extended_error,
541 int sqlite_error = sqlite_extended_error & 0xFF;
542 switch (sqlite_error) {
543 case SQLITE_INTERNAL:
549 case SQLITE_CANTOPEN:
561 message, sqlite_extended_error);
571 const string &generic_parameter,
572 const string &instance)
578 if ((generic_parameter ==
"CVMFS_CACHE_SHARED") &&
581 return "CVMFS_SHARED_CACHE";
583 if ((generic_parameter ==
"CVMFS_CACHE_ALIEN") &&
586 return "CVMFS_ALIEN_CACHE";
588 if ((generic_parameter ==
"CVMFS_CACHE_SERVER_MODE") &&
591 return "CVMFS_SERVER_CACHE_MODE";
593 if ((generic_parameter ==
"CVMFS_CACHE_QUOTA_LIMIT") &&
596 return "CVMFS_QUOTA_LIMIT";
598 return generic_parameter;
601 return "CVMFS_CACHE_" + instance +
"_" + generic_parameter.substr(12);
625 boot_error_ =
"circular cache definition: " + instance;
633 string instance_type;
635 instance_type =
"posix";
640 if (instance_type ==
"posix") {
642 }
else if (instance_type ==
"ram") {
644 }
else if (instance_type ==
"tiered") {
646 }
else if (instance_type ==
"external") {
649 boot_error_ =
"invalid cache manager type for '" + instance +
"':" +
662 vector<string> cmd_line;
679 if (!plugin_handle->
IsValid()) {
686 if (cache_mgr == NULL) {
687 boot_error_ =
"failed to create external cache manager for " + instance;
707 boot_error_ =
"Failed to setup posix cache '" + instance +
"' in " +
715 const bool ignore_failure = settings.
is_alien;
732 uint64_t sz_cache_bytes;
748 if (optarg ==
"libc") {
750 }
else if (optarg ==
"heap") {
754 MkCacheParm(
"CVMFS_CACHE_MALLOC", instance) +
"=" + optarg;
759 sz_cache_bytes =
RoundUp8(std::max(static_cast<uint64_t>(40 * 1024 * 1024),
766 if (cache_mgr == NULL) {
767 boot_error_ =
"failed to create ram cache manager for " + instance;
802 if (tiered == NULL) {
803 boot_error_ =
"Failed to setup tiered cache manager " + instance;
808 MkCacheParm(
"CVMFS_CACHE_LOWER_READONLY", instance), &optarg) &&
824 "looks like cvmfs has been crashed previously");
828 boot_error_ =
"could not open running sentinel (" +
869 setenv(
"CVMFS_ARCH",
GetArch().c_str(), 1 );
879 if (options_mgr.
GetValue(
"CVMFS_SYSLOG_LEVEL", &optarg))
881 if (options_mgr.
GetValue(
"CVMFS_SYSLOG_FACILITY", &optarg))
883 if (options_mgr.
GetValue(
"CVMFS_USYSLOG", &optarg))
885 if (options_mgr.
GetValue(
"CVMFS_DEBUGLOG", &optarg))
887 if (options_mgr.
GetValue(
"CVMFS_SYSLOG_PREFIX", &optarg)) {
901 #ifdef CVMFS_NFS_SUPPORT
905 string no_nfs_sentinel;
909 no_nfs_sentinel = posix_cache_mgr->
cache_path() +
"/no_nfs_maps." +
name_;
912 const bool ignore_failure = posix_cache_mgr->
alien_cache();
913 CreateFile(no_nfs_sentinel, 0600, ignore_failure);
918 boot_error_ =
"NFS source only works with POSIX cache manager.";
927 if (!no_nfs_sentinel.empty() &&
FileExists(no_nfs_sentinel)) {
928 boot_error_ =
"Cache was used without NFS maps before. "
929 "It has to be wiped out.";
938 boot_error_ =
"Cache directory and workspace must be identical for "
975 if (tokens.size() != 2) {
977 "invalid format for CVMFS_NFS_INTERLEAVED_INODES: " + optarg;
998 int64_t quota_threshold = settings.
quota_limit / 2;
1002 "using workspace %s to protect cache database in %s",
1004 cache_workspace +=
":" + settings.
workspace;
1015 if (quota_mgr == NULL) {
1016 boot_error_ =
"Failed to initialize shared lru cache";
1026 if (quota_mgr == NULL) {
1035 "cache is already beyond quota size "
1036 "(size: %" PRId64
", capacity: %" PRId64
"), cleaning up",
1038 if (!quota_mgr->
Cleanup(quota_threshold)) {
1049 "CernVM-FS: quota initialized, current size %luMB",
1050 quota_mgr->
GetSize() / (1024 * 1024));
1061 assert(retval == SQLITE_OK);
1062 retval = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
1063 assert(retval == SQLITE_OK);
1067 retval = sqlite3_vfs_register(sqlite3_vfs_find(
"unix-none"), 1);
1068 assert(retval == SQLITE_OK);
1091 "'CVMFS_CACHE_BASE' and 'CVMFS_CACHE_DIR' are mutually exclusive";
1103 const int mode = 0770;
1125 "failed to load/store %s/uuid",
workspace_.c_str());
1127 assert(uuid_cache_ != NULL);
1206 bool append =
false;
1209 boot_error_ =
"failed to load blacklist " + blacklist;
1216 string config_repository_path;
1218 blacklist = config_repository_path +
"blacklist";
1222 boot_error_ =
"failed to load blacklist from config repository";
1239 bool append =
false;
1283 if (options_mgr == NULL)
1286 fqrn, file_system, options_mgr));
1327 string authz_helper;
1329 authz_helper = optarg;
1332 authz_search_path = optarg;
1364 if (root_hash.
IsNull()) {
1368 bool alt_root_path =
1374 boot_error_ =
"Failed to initialize root file catalog";
1394 unsigned soft_limit;
1395 unsigned hard_limit;
1417 if (optarg.compare(
"EXTERNAL") == 0) {
1442 "Development option: Activate ignore signature failures during download. "
1443 "DO NOT USE IN PRODUCTION");
1449 string forced_proxy_template;
1451 forced_proxy_template = optarg;
1453 forced_proxy_template);
1462 if (proxies ==
"") {
1463 boot_error_ =
"failed to discover HTTP proxy servers";
1467 string fallback_proxies;
1469 fallback_proxies = optarg;
1480 std::vector<std::string> host_chain;
1482 if (max_servers > 0 && max_servers < host_chain.size()) {
1483 host_chain.resize(max_servers);
1503 if (optarg.size() > 1000) {
1505 "CVMFS_HTTP_TRACING_HEADERS too large ( max 1000 chars, given %ld )",
1508 std::vector<std::string> tokens =
SplitString(optarg,
'|');
1511 for (
unsigned int i = 0; i < tokens.size(); i++) {
1512 std::string token =
Trim(tokens[i]);
1514 std::vector<std::string> key_val =
SplitString(token,
':');
1516 if (key_val.size() != 2) {
1518 "Http tracing header: Skipping current token part of "
1519 "CVMFS_HTTP_TRACING_HEADERS! Invalid "
1520 "<key:value> pair. Token: %s", token.c_str());
1524 std::string prefix =
"X-CVMFS-";
1525 std::string key =
Trim(key_val[0]);
1527 if (!sanitizer.
IsValid(key)) {
1529 "Http tracing header: Skipping current token part of "
1530 "CVMFS_HTTP_TRACING_HEADERS! Invalid key. Only alphanumeric keys "
1531 "are allowed (a-z, A-Z, 0-9). Token: %s", token.c_str());
1535 std::string final_token = prefix + key +
": " +
Trim(key_val[1]);
1547 std::string roaming_value;
1552 "DNS roaming is enabled for this repository.");
1564 "DNS roaming is disabled for this repository.");
1591 public_keys = optarg;
1606 if (public_keys.size() > 0) {
1608 public_keys.c_str());
1624 "overall number of accessed inodes");
1626 "overall number of evicted inodes");
1628 "currently active inodes");
1630 "overall number of inode lookups");
1632 "overall number of successful path lookups");
1634 "overall number of unsuccessful path lookups");
1637 "overall number of added negative cache entries");
1639 "overall number of evicted negative cache entries");
1641 "overall number of prune calls");
1644 "overall number of added page cache entries");
1646 "overall number of evicted page cache entries");
1648 "overall number of direct I/O open calls");
1650 "overall number of open calls where the file's page cache gets flushed");
1652 "overall number of open calls where the file's page cache is reused");
1671 const double memcache_unit_size =
1674 const unsigned memcache_num_units =
1675 mem_cache_size /
static_cast<unsigned>(memcache_unit_size);
1677 const unsigned mask_64 = ~((1 << 6) - 1);
1703 boot_error_ =
"tracer is only supported in the fuse module";
1707 string tracebuffer_file = optarg;
1718 assert(tracebuffer_size <= INT_MAX
1719 && tracebuffer_threshold <= INT_MAX);
1721 "Initialising tracer with buffer size %" PRIu64
" and threshold %" PRIu64,
1722 tracebuffer_size, tracebuffer_threshold);
1744 string history_path;
1752 "failed to open history database (%s)", history_path.c_str());
1761 string repository_date;
1765 if (repository_utctime == 0) {
1766 boot_error_ =
"invalid timestamp in CVMFS_REPOSITORY_DATE: " +
1767 repository_date +
". Use YYYY-MM-DDTHH:MM:SSZ";
1771 retval = tag_db->GetByDate(repository_utctime, &tag);
1773 boot_error_ =
"no repository state as early as utc timestamp " +
1779 "time stamp %s UTC resolved to tag '%s'",
1809 if (history_hash.
IsNull()) {
1838 return max_ttl ? std::min(max_ttl, catalog_ttl_sec) : catalog_ttl_sec;
1862 , uuid_(cvmfs::Uuid::
Create(
""))
1866 , telemetry_aggr_(NULL)
1867 , authz_fetcher_(NULL)
1868 , authz_session_mgr_(NULL)
1869 , authz_attachment_(NULL)
1870 , backoff_throttle_(NULL)
1873 , external_download_mgr_(NULL)
1875 , external_fetcher_(NULL)
1876 , inode_annotation_(NULL)
1878 , chunk_tables_(NULL)
1879 , simple_chunk_tables_(NULL)
1880 , inode_cache_(NULL)
1882 , md5path_cache_(NULL)
1884 , inode_tracker_(NULL)
1885 , dentry_tracker_(NULL)
1886 , page_cache_tracker_(NULL)
1887 , statfs_cache_(NULL)
1888 , resolv_conf_watcher_(NULL)
1889 , max_ttl_sec_(kDefaultMaxTtlSec)
1890 , kcache_timeout_sec_(static_cast<double>(kDefaultKCacheTtlSec))
1891 , fixed_catalog_(false)
1892 , enforce_acls_(false)
1893 , cache_symlinks_(false)
1894 , fuse_expire_entry_(false)
1895 , has_membership_req_(false)
1896 , talk_socket_path_(std::string(
"./cvmfs_io.") + fqrn)
1897 , talk_socket_uid_(0)
1898 , talk_socket_gid_(0)
1972 std::max(0.0, static_cast<double>(
String2Int64(optarg)));
1977 uint64_t statfs_time_cache_valid = 0;
1979 statfs_time_cache_valid =
static_cast<uint64_t
>(
String2Uint64(optarg));
1982 static_cast<int>(statfs_time_cache_valid));
1994 if (
ToUpper(optarg) ==
"ROOTONLY") {
1996 }
else if (
ToUpper(optarg) ==
"NEVER") {
1998 }
else if (
ToUpper(optarg) ==
"ALWAYS") {
2002 "unsupported setting: CVMFS_MAGIC_XATTRS_VISIBILITY=%s",
2007 std::set<gid_t> protected_xattr_gids;
2009 std::vector<string> tmp =
SplitString(optarg,
',');
2011 for (
size_t i = 0; i < tmp.size(); i++) {
2012 std::string trimmed =
Trim(tmp[i]);
2014 "Privileged gid for xattr added: %s", trimmed.c_str());
2015 protected_xattr_gids.insert(static_cast<gid_t>(
String2Uint64(trimmed)));
2018 std::set<std::string> protected_xattrs;
2020 std::vector<string> tmp =
SplitString(optarg,
',');
2022 for (
size_t i = 0; i < tmp.size(); i++) {
2023 std::string trimmed =
Trim(tmp[i]);
2025 "Protected xattr added: %s", trimmed.c_str());
2026 protected_xattrs.insert(trimmed);
2030 if (protected_xattr_gids.count(0) < 1) {
2031 protected_xattr_gids.insert(0);
2033 "Automatically added root to have access to protected xattrs.");
2037 protected_xattrs, protected_xattr_gids);
2060 boot_error_ =
"unknown owner of cvmfs_talk socket: " + optarg;
2072 telemetry_send_rate_sec =
static_cast<int>(
String2Uint64(optarg));
2080 telemetry_send_rate_sec,
2086 "Enable telemetry to report every %d seconds",
2087 telemetry_send_rate_sec);
2146 unsigned timeout_direct;
2165 std::vector<std::string> host_chain;
2176 std::vector<std::string> host_chain;
2178 if (max_servers > 0 && max_servers < host_chain.size()) {
2179 host_chain.resize(max_servers);
2184 string proxies =
"DIRECT";
2190 if (proxies ==
"") {
2191 boot_error_ =
"failed to discover external HTTP proxy servers";
2196 string fallback_proxies;
2198 fallback_proxies = optarg;
2279 if (!uid_map.Read(optarg)) {
2280 boot_error_ =
"failed to parse uid map " + optarg;
2286 if (!gid_map.Read(optarg)) {
2287 boot_error_ =
"failed to parse gid map " + optarg;
perf::Counter * n_eio_07_
IoErrorInfo io_error_info_
OptionsManager * options_mgr()
static const unsigned kDnsDefaultTimeoutMs
bool GetVOMSAuthz(std::string *authz) const
void SetLogSyslogFacility(const int local_facility)
FileSystem * file_system_
Counter * Register(const std::string &name, const std::string &desc)
void SetCounter(perf::Counter *c)
void RegisterFdMapping(int from, int to)
std::string nfs_maps_dir_
void SetLogSyslogLevel(const int level)
void Activate(const int buffer_size, const int flush_threshold, const std::string &trace_file)
download::DownloadManager * download_mgr_
perf::Counter * n_eio_08_
perf::Counter * n_emfile_
Log2Histogram * hist_fs_forget_multi_
perf::Counter * n_fs_statfs_cached_
static FileWatcher * Create()
void SetupInodeAnnotation()
catalog::InodeAnnotation * inode_annotation_
static NfsMapsSqlite * Create(const std::string &db_dir, const uint64_t root_inode, const bool rebuild, perf::Statistics *statistics_)
std::string workspace_fullpath_
static SqliteHistory * Open(const std::string &file_name)
void SetHostChain(const std::string &host_list)
static const unsigned kTracerFlushThreshold
virtual uint64_t GetSize()
static Publisher * Create(const SettingsPublisher &settings)
void SetMetalinkChain(const std::string &metalink_list)
void SetLowSpeedLimit(const unsigned low_speed_limit)
perf::Counter * n_fs_stat_stale_
Log2Histogram * hist_fs_opendir_
bool volatile_flag() const
virtual bool Cleanup(const uint64_t leave_size)
double kcache_timeout_sec_
signature::SignatureManager * signature_mgr_
void CreateFile(const std::string &path, const int mode, const bool ignore_failure)
perf::Counter * n_fs_lookup_
AuthzSessionManager * authz_session_mgr_
static const unsigned kDefaultRetries
string Trim(const string &raw, bool trim_newline)
string JoinStrings(const vector< string > &strings, const string &joint)
int fd_connection() const
perf::Statistics * statistics_
download::DownloadManager * download_mgr_
static const unsigned kDefaultTimeoutSec
bool CheckInstanceName(const std::string &instance)
perf::Statistics * statistics_
Log2Histogram * hist_fs_readlink_
static void SetupLoggingStandalone(const OptionsManager &options_mgr, const std::string &prefix)
void SetProxyChain(const std::string &proxy_list, const std::string &fallback_proxy_list, const ProxySetModes set_mode)
static NfsMapsLeveldb * Create(const std::string &leveldb_dir, const uint64_t root_inode, const bool rebuild, perf::Statistics *statistics)
perf::Counter * n_eio_total_
bool IsOn(const std::string ¶m_value) const
std::string GetUniqFileSuffix()
StatfsCache * statfs_cache_
download::DownloadManager * external_download_mgr_
MagicXattrManager * magic_xattr_mgr_
static const size_t kDefaultBufferSize
CacheManager * SetupCacheMgr(const std::string &instance)
const SettingsPublisher & settings() const
perf::Statistics * statistics_
static const char * kDefaultBlacklist
virtual bool AcquireQuotaManager(QuotaManager *quota_mgr)
static const unsigned kDefaultMaxTtl
bool CreateDownloadManagers()
std::string talk_socket_path_
perf::Counter * n_fs_stat_
perf::Counter * n_eio_05_
perf::Counter * no_open_files_
assert((mem||(size==0))&&"Out Of Memory")
void ReplaceCacheManager(CacheManager *new_cache_mgr)
static const int kLabelHistory
static void SetupGlobalEnvironmentParams()
bool UnregisterVfsRdOnly()
CacheManager * SetupRamCacheMgr(const std::string &instance)
static void LogSqliteError(void *user_data __attribute__((unused)), int sqlite_extended_error, const char *message)
static void CleanupInstance()
void EnableFuseExpireEntry()
static const unsigned kNfsMaps
string StringifyTime(const time_t seconds, const bool utc)
PosixCacheSettings DeterminePosixCacheSettings(const std::string &instance)
void SetDnsServer(const std::string &address)
void AssignGlobalArenas()
DownloadManager * Clone(const perf::StatisticsTemplate &statistics, const std::string &cloned_name)
virtual CacheManagerIds id()=0
void SetLogMicroSyslog(const std::string &filename)
bool IsOff(const std::string ¶m_value) const
perf::Counter * n_eio_01_
bool HasConfigRepository(const std::string &fqrn, std::string *config_path)
std::set< std::string > constructed_instances_
bool DetermineRootHash(shash::Any *root_hash)
static double GetEntrySize()
#define SetLogDebugFile(filename)
void SetTimeout(const unsigned seconds_proxy, const unsigned seconds_direct)
bool CreateCatalogManager()
struct cvmcache_object_info __attribute__
void RemapCatalogFd(int from, int to)
static const unsigned kNfsNone
std::string path_crash_guard_
IntegerMap< uint64_t > OwnerMap
catalog::WritableCatalogManager * catalog_mgr_
static const char * kDefaultAuthzSearchPath
FileSystem(const FileSystemInfo &fs_info)
static const unsigned kLibPathCacheSize
void SetFqrn(const std::string &fqrn)
OptionsManager * options_mgr_
Log2Histogram * hist_fs_getattr_
Log2Histogram * hist_fs_releasedir_
bool FileExists(const std::string &path)
void ReplaceCacheManager(CacheManager *new_cache_mgr)
void DisableCacheSymlinks()
void SetDnsTtlLimits(const unsigned min_seconds, const unsigned max_seconds)
perf::Counter * n_fs_readlink_
int64_t String2Int64(const string &value)
void SetMaxTtlMn(unsigned value_minutes)
string ToUpper(const string &mixed_case)
static const unsigned kDefaultBackoffInitMs
perf::Counter * n_fs_forget_
MountPoint(const std::string &fqrn, FileSystem *file_system, OptionsManager *options_mgr)
void GetLimitNoFile(unsigned *soft_limit, unsigned *hard_limit)
void SetProxyGroupResetDelay(const unsigned seconds)
static CacheManager * Create(CacheManager *upper_cache, CacheManager *lower_cache)
static const unsigned kDefaultNumConnections
void Set(const int64_t val)
static const unsigned kNfsMapsHa
lru::Md5PathCache * md5path_cache_
vector< string > SplitString(const string &str, char delim)
static TelemetryAggregator * Create(Statistics *statistics, int send_rate, OptionsManager *options_mgr, MountPoint *mount_point, const std::string &fqrn, const TelemetrySelector type)
static PosixCacheManager * Create(const std::string &cache_path, const bool alien_cache, const RenameWorkarounds rename_workaround=kRenameNormal, const bool do_refcount=true)
bool RegisterVfsRdOnly(CacheManager *cache_mgr, perf::Statistics *statistics, const VfsOptions options)
static AuthzSessionManager * Create(AuthzFetcher *authz_fetcher, perf::Statistics *statistics)
std::string membership_req_
glue::DentryTracker * dentry_tracker_
int Fetch(const CacheManager::LabeledObject &object, const std::string &alt_url="")
perf::Counter * n_fs_read_
signature::SignatureManager * signature_mgr_
perf::Counter * n_eio_06_
static const char * kDefaultCacheMgrInstance
bool HasSuffix(const std::string &str, const std::string &suffix, const bool ignore_case)
bool IsRevisionBlacklisted()
virtual uint64_t GetCapacity()
glue::PageCacheTracker * page_cache_tracker_
bool SetShardingPolicy(const ShardingPolicySelector type)
bool found_previous_crash_
const char kSuffixCatalog
loader::Failures boot_status_
Failures Fetch(const std::string &base_url, const std::string &repository_name, const uint64_t minimum_timestamp, const shash::Any *base_catalog, signature::SignatureManager *signature_manager, download::DownloadManager *download_manager, ManifestEnsemble *ensemble)
bool CheckPosixCacheSettings(const PosixCacheSettings &settings)
perf::TelemetryAggregator * telemetry_aggr_
perf::Counter * n_fs_inode_replace_
ChunkTables * chunk_tables_
CacheManager * cache_mgr()
void SetupDnsTuning(download::DownloadManager *manager)
cvmfs::Uuid * uuid_cache_
unsigned GetEffectiveTtlSec()
int TryLockFile(const std::string &path)
bool MkdirDeep(const std::string &path, const mode_t mode, bool verify_writable)
int LockFile(const std::string &path)
void SetIpPreference(const dns::IpPreference preference)
static const unsigned kDefaultBackoffMaxMs
lru::InodeCache * inode_cache_
CacheManager * SetupPosixCacheMgr(const std::string &instance)
download::DownloadManager * download_mgr()
perf::Counter * n_fs_open_
static uint64_t RoundUp8(const uint64_t size)
bool SetupPosixQuotaMgr(const PosixCacheSettings &settings, CacheManager *cache_mgr)
static SqliteMemoryManager * GetInstance()
static PosixQuotaManager * Create(const std::string &cache_workspace, const uint64_t limit, const uint64_t cleanup_threshold, const bool rebuild_database)
void SetRetryParameters(const unsigned max_retries, const unsigned backoff_init_ms, const unsigned backoff_max_ms)
string StringifyInt(const int64_t value)
static const unsigned kInodeCacheFactor
void SetMaxIpaddrPerProxy(unsigned limit)
void EnableIgnoreSignatureFailures()
void Inc(class Counter *counter)
bool HasPrefix(const string &str, const string &prefix, const bool ignore_case)
perf::Counter * n_eio_04_
Log2Histogram * hist_fs_readdir_
bool GetValue(const std::string &key, std::string *value) const
void SetExternalDownloadManager(download::DownloadManager *download_mgr)
OptionsManager * options_mgr_
bool LoadBlacklist(const std::string &path_blacklist, bool append)
BackoffThrottle * backoff_throttle_
AuthzAttachment * authz_attachment_
void SetProxyTemplates(const std::string &direct, const std::string &forced)
SimpleChunkTables * simple_chunk_tables_
bool InitFixed(const shash::Any &root_hash, bool alternative_path)
perf::Counter * n_eio_03_
static const unsigned kDefaultNfiles
static FileSystem * Create(const FileSystemInfo &fs_info)
bool has_custom_sqlitevfs_
perf::Counter * n_fs_statfs_
time_t IsoTimestamp2UtcTime(const std::string &iso8601)
static Uuid * Create(const std::string &store_path)
pthread_mutex_t lock_max_ttl_
static const char * kDefaultCacheBase
string ResolveProxyDescription(const string &cvmfs_proxies, const std::string &path_fallback_cache, DownloadManager *download_manager)
uint64_t String2Uint64(const string &value)
static const unsigned kTracerBufferSize
perf::Counter * n_eio_02_
catalog::ClientCatalogManager * catalog_mgr_
void UseSystemCertificatePath()
bool CreateSignatureManager()
std::string error_msg() const
bool GetUidOf(const std::string &username, uid_t *uid, gid_t *main_gid)
static ExternalCacheManager * Create(int fd_connection, unsigned max_open_fds, const std::string &ident)
AuthzFetcher * authz_fetcher_
bool FetchHistory(std::string *history_path)
perf::Statistics * statistics()
shash::Any history() const
static const unsigned kDefaultQuotaLimit
static PosixQuotaManager * CreateShared(const std::string &exe_path, const std::string &cache_workspace, const uint64_t limit, const uint64_t cleanup_threshold, bool foreground)
void ResetErrorCounters()
Log2Histogram * hist_fs_lookup_
bool LoadPublicRsaKeys(const std::string &path_list)
void SetRegularDownloadManager(download::DownloadManager *download_mgr)
void RegisterHandler(const std::string &file_path, EventHandler *handler)
void GetTimeout(unsigned *seconds_proxy, unsigned *seconds_direct)
static const unsigned kDefaultMemcacheSize
void SetFailoverIndefinitely()
FileSystem * file_system_
std::string repository_tag_
static const unsigned kDefaultMinTtl
void SetDnsParameters(const unsigned retries, const unsigned timeout_ms)
bool CreateResolvConfWatcher()
Any MkFromHexPtr(const HexPtr hex, const char suffix)
static ExternalQuotaManager * Create(ExternalCacheManager *cache_mgr)
Log2Histogram * hist_fs_read_
void SetCatalogWatermark(unsigned limit)
void SetMetalinkResetDelay(const unsigned seconds)
std::vector< std::string > blacklist_paths_
cvmfs::Fetcher * fetcher_
file_watcher::FileWatcher * resolv_conf_watcher_
static const unsigned kDnsDefaultRetries
bool GeoSortServers(std::vector< std::string > *servers, std::vector< uint64_t > *output_order=NULL)
bool SetupExternalDownloadMgr(bool dogeosort)
void SetOwnerMaps(const OwnerMap &uid_map, const OwnerMap &gid_map)
CacheManager * SetupExternalCacheMgr(const std::string &instance)
static void CleanupInstance()
perf::Counter * n_fs_lookup_negative_
Log2Histogram * hist_fs_open_
virtual bool AcquireQuotaManager(QuotaManager *quota_mgr)=0
std::string cache_mgr_instance_
std::string path_workspace_lock_
virtual void IncGeneration(const uint64_t by)=0
Log2Histogram * hist_fs_release_
void SetLogSyslogPrefix(const std::string &prefix)
std::string MakeCanonicalPath(const std::string &path)
static const int kDefaultTelemetrySendRateSec
OptionsManager * options_mgr_
perf::Counter * no_open_dirs_
glue::InodeTracker * inode_tracker_
static PluginHandle * CreatePlugin(const std::string &locator, const std::vector< std::string > &cmd_line)
bool IsDefined(const std::string &key)
static const int kMinimumTelemetrySendRateSec
void GetHostInfo(std::vector< std::string > *host_chain, std::vector< int > *rtt, unsigned *current_host)
void set_membership(const std::string &m)
CacheManager * SetupTieredCacheMgr(const std::string &instance)
std::vector< std::string > FindFilesBySuffix(const std::string &dir, const std::string &suffix)
lru::PathCache * path_cache_
CacheManager * cache_mgr_
static const inode_t kInodeOffset
void AddHTTPTracingHeader(const std::string &header)
void SetCredentialsAttachment(CredentialsAttachment *ca)
static ClientCtx * GetInstance()
virtual bool AcquireQuotaManager(QuotaManager *quota_mgr)
cvmfs::Uuid * uuid_cache()
cvmfs::Fetcher * external_fetcher_
perf::Counter * n_fs_dir_open_
std::string MkCacheParm(const std::string &generic_parameter, const std::string &instance)
void UnlockFile(const int filedes)
download::DownloadManager * external_download_mgr()
void SetInodeAnnotation(InodeAnnotation *new_annotation)
virtual void SetInodeResidue(unsigned residue_class, unsigned remainder)
void SetHostResetDelay(const unsigned seconds)
static MountPoint * Create(const std::string &fqrn, FileSystem *file_system, OptionsManager *options_mgr=NULL)
Log2Histogram * hist_fs_forget_
CVMFS_EXPORT void LogCvmfs(const LogSource source, const int mask, const char *format,...)