GCC Code Coverage Report


Directory: cvmfs/
File: cvmfs/mountpoint.h
Date: 2025-08-31 02:39:21
Exec Total Coverage
Lines: 53 123 43.1%
Branches: 1 2 50.0%

Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 *
4 * Steers the booting of CernVM-FS repositories.
5 */
6
7 #ifndef CVMFS_MOUNTPOINT_H_
8 #define CVMFS_MOUNTPOINT_H_
9
10 #include <pthread.h>
11 #include <sys/statvfs.h>
12 #include <unistd.h>
13
14 #include <ctime>
15 #include <set>
16 #include <string>
17 #include <vector>
18
19 #include "cache.h"
20 #include "crypto/hash.h"
21 #include "file_watcher.h"
22 #include "duplex_testing.h"
23 #include "loader.h"
24 #include "magic_xattr.h"
25 #include "util/algorithm.h"
26 #include "util/pointer.h"
27
28 class AuthzAttachment;
29 class AuthzFetcher;
30 class AuthzSessionManager;
31 class BackoffThrottle;
32 class CacheManager;
33 namespace catalog {
34 class ClientCatalogManager;
35 class InodeAnnotation;
36 } // namespace catalog
37 struct ChunkTables;
38 namespace cvmfs {
39 class Fetcher;
40 class Uuid;
41 } // namespace cvmfs
42 namespace download {
43 class DownloadManager;
44 }
45 namespace glue {
46 class InodeTracker;
47 class DentryTracker;
48 class PageCacheTracker;
49 } // namespace glue
50 namespace lru {
51 class InodeCache;
52 class Md5PathCache;
53 class PathCache;
54 } // namespace lru
55 class NfsMaps;
56 class OptionsManager;
57 namespace perf {
58 class Counter;
59 class Statistics;
60 class TelemetryAggregator;
61 } // namespace perf
62 namespace signature {
63 class SignatureManager;
64 }
65 class SimpleChunkTables;
66 class Tracer;
67
68
69 /**
70 * Construction of FileSystem and MountPoint can go wrong. In this case, we'd
71 * like to know why. This is a base class for both FileSystem and MountPoint.
72 */
73 class BootFactory {
74 public:
75 1453 BootFactory() : boot_status_(loader::kFailUnknown) { }
76 10 bool IsValid() { return boot_status_ == loader::kFailOk; }
77 1435 loader::Failures boot_status() { return boot_status_; }
78 111 std::string boot_error() { return boot_error_; }
79
80 /**
81 * Used in the fuse module to artificially set boot errors that are specific
82 * to the fuse boot procedure.
83 */
84 void set_boot_status(loader::Failures code) { boot_status_ = code; }
85
86 protected:
87 loader::Failures boot_status_;
88 std::string boot_error_;
89 };
90
91
92 /**
93 * The FileSystem object initializes cvmfs' global state. It sets up sqlite and
94 * the cache directory and it can contain multiple mount points. It currently
95 * does so only for libcvmfs; the cvmfs fuse module has exactly one FileSystem
96 * object and one MountPoint object.
97 */
98 class FileSystem : SingleCopy, public BootFactory {
99 FRIEND_TEST(T_MountPoint, MkCacheParm);
100 FRIEND_TEST(T_MountPoint, CacheSettings);
101 FRIEND_TEST(T_MountPoint, CheckInstanceName);
102 FRIEND_TEST(T_MountPoint, CheckPosixCacheSettings);
103 FRIEND_TEST(T_Cvmfs, Basics);
104 FRIEND_TEST(T_VersionEnv, SetupGlobalEnvironmentParams);
105 FRIEND_TEST(T_VersionEnv, VersionNumericFormat);
106
107 public:
108 enum Type {
109 kFsFuse = 0,
110 kFsLibrary
111 };
112
113 struct FileSystemInfo {
114 890 FileSystemInfo()
115 1780 : type(kFsFuse)
116 890 , options_mgr(NULL)
117 890 , wait_workspace(false)
118 890 , foreground(false) { }
119 /**
120 * Name can is used to identify this particular instance of cvmfs in the
121 * cache (directory). Normally it is the fully qualified repository name.
122 * For libcvmfs and in other special mount conditions, it can be something
123 * else. Only file systems with different names can share a cache because
124 * the name is part of a lock file.
125 */
126 std::string name;
127
128 /**
129 * Used to fork & execve into different flavors of the binary, e.g. the
130 * quota manager.
131 */
132 std::string exe_path;
133
134 /**
135 * Fuse mount point or libcvmfs.
136 */
137 Type type;
138
139 /**
140 * All further configuration has to be present in the options manager.
141 */
142 OptionsManager *options_mgr;
143
144 /**
145 * Decides if FileSystem construction should block if the workspace is
146 * currently taken. This is used to coordinate fuse mounts where the next
147 * mount happens while the previous fuse module is not yet fully cleaned
148 * up.
149 */
150 bool wait_workspace;
151 /**
152 * The fuse module should not daemonize. That means the quota manager
153 * should not daemonize, too, but print debug messages to stdout.
154 */
155 bool foreground;
156 };
157
158 /**
159 * Keeps information about I/O errors, e.g. writing local files, permanent
160 * network errors, etc. It counts the number of errors and the timestamp
161 * of the latest errors for consumption by monitoring tools such as Nagios
162 */
163 class IoErrorInfo {
164 public:
165 IoErrorInfo();
166
167 void Reset();
168 void AddIoError();
169 void SetCounter(perf::Counter *c);
170 int64_t count();
171 time_t timestamp_last();
172
173 private:
174 perf::Counter *counter_;
175 time_t timestamp_last_;
176 };
177
178 /**
179 * No NFS maps.
180 */
181 static const unsigned kNfsNone = 0x00;
182 /**
183 * Normal NFS maps by leveldb
184 */
185 static const unsigned kNfsMaps = 0x01;
186 /**
187 * NFS maps maintained by sqlite so that they can reside on an NFS mount
188 */
189 static const unsigned kNfsMapsHa = 0x02;
190
191 static FileSystem *Create(const FileSystemInfo &fs_info);
192 ~FileSystem();
193
194 // Used to setup logging before the file system object is created
195 static void SetupLoggingStandalone(const OptionsManager &options_mgr,
196 const std::string &prefix);
197
198 615 bool IsNfsSource() { return nfs_mode_ & kNfsMaps; }
199 3 bool IsHaNfsSource() { return nfs_mode_ & kNfsMapsHa; }
200 void ResetErrorCounters();
201 void TearDown2ReadOnly();
202 void RemapCatalogFd(int from, int to);
203
204 // Used in cvmfs' RestoreState to prevent change of cache manager type
205 // during reload
206 void ReplaceCacheManager(CacheManager *new_cache_mgr);
207
208 1437 CacheManager *cache_mgr() { return cache_mgr_; }
209 18 std::string cache_mgr_instance() { return cache_mgr_instance_; }
210 std::string exe_path() { return exe_path_; }
211 6 bool found_previous_crash() { return found_previous_crash_; }
212 Log2Histogram *hist_fs_lookup() { return hist_fs_lookup_; }
213 Log2Histogram *hist_fs_forget() { return hist_fs_forget_; }
214 Log2Histogram *hist_fs_forget_multi() { return hist_fs_forget_multi_; }
215 Log2Histogram *hist_fs_getattr() { return hist_fs_getattr_; }
216 Log2Histogram *hist_fs_readlink() { return hist_fs_readlink_; }
217 Log2Histogram *hist_fs_opendir() { return hist_fs_opendir_; }
218 Log2Histogram *hist_fs_releasedir() { return hist_fs_releasedir_; }
219 Log2Histogram *hist_fs_readdir() { return hist_fs_readdir_; }
220 Log2Histogram *hist_fs_open() { return hist_fs_open_; }
221 Log2Histogram *hist_fs_read() { return hist_fs_read_; }
222 Log2Histogram *hist_fs_release() { return hist_fs_release_; }
223
224 perf::Counter *n_fs_dir_open() { return n_fs_dir_open_; }
225 perf::Counter *n_fs_forget() { return n_fs_forget_; }
226 perf::Counter *n_fs_inode_replace() { return n_fs_inode_replace_; }
227 perf::Counter *n_fs_lookup() { return n_fs_lookup_; }
228 perf::Counter *n_fs_lookup_negative() { return n_fs_lookup_negative_; }
229 perf::Counter *n_fs_open() { return n_fs_open_; }
230 perf::Counter *n_fs_read() { return n_fs_read_; }
231 perf::Counter *n_fs_readlink() { return n_fs_readlink_; }
232 888 perf::Counter *n_fs_stat() { return n_fs_stat_; }
233 perf::Counter *n_fs_stat_stale() { return n_fs_stat_stale_; }
234 perf::Counter *n_fs_statfs() { return n_fs_statfs_; }
235 perf::Counter *n_fs_statfs_cached() { return n_fs_statfs_cached_; }
236 IoErrorInfo *io_error_info() { return &io_error_info_; }
237 486 std::string name() { return name_; }
238 NfsMaps *nfs_maps() { return nfs_maps_; }
239 perf::Counter *no_open_dirs() { return no_open_dirs_; }
240 perf::Counter *no_open_files() { return no_open_files_; }
241 perf::Counter *n_eio_total() { return n_eio_total_; }
242 perf::Counter *n_eio_01() { return n_eio_01_; }
243 perf::Counter *n_eio_02() { return n_eio_02_; }
244 perf::Counter *n_eio_03() { return n_eio_03_; }
245 perf::Counter *n_eio_04() { return n_eio_04_; }
246 perf::Counter *n_eio_05() { return n_eio_05_; }
247 perf::Counter *n_eio_06() { return n_eio_06_; }
248 perf::Counter *n_eio_07() { return n_eio_07_; }
249 perf::Counter *n_eio_08() { return n_eio_08_; }
250 perf::Counter *n_emfile() { return n_emfile_; }
251 1048 OptionsManager *options_mgr() { return options_mgr_; }
252 489 perf::Statistics *statistics() { return statistics_; }
253 1324 Type type() { return type_; }
254 492 cvmfs::Uuid *uuid_cache() { return uuid_cache_; }
255 960 std::string workspace() { return workspace_; }
256
257 protected:
258 void SetHasCustomVfs(bool setting) { has_custom_sqlitevfs_ = setting; }
259
260 private:
261 /**
262 * Only one instance may be alive at any given time
263 */
264 static bool g_alive;
265 static const char *kDefaultCacheBase; // /var/lib/cvmfs
266 static const unsigned kDefaultQuotaLimit = 1024 * 1024 * 1024; // 1GB
267 static const unsigned kDefaultNfiles = 8192; // if CVMFS_NFILES is unset
268 static const char *kDefaultCacheMgrInstance; // "default"
269
270 struct PosixCacheSettings {
271 902 PosixCacheSettings()
272 902 : is_shared(false)
273 902 , is_alien(false)
274 902 , is_managed(false)
275 902 , avoid_rename(false)
276 902 , cache_base_defined(false)
277 902 , cache_dir_defined(false)
278 902 , quota_limit(0)
279 902 , do_refcount(true) { }
280 bool is_shared;
281 bool is_alien;
282 bool is_managed;
283 bool avoid_rename;
284 bool cache_base_defined;
285 bool cache_dir_defined;
286 /**
287 * Soft limit in bytes for the cache. The quota manager removes half the
288 * cache when the limit is exceeded.
289 */
290 int64_t quota_limit;
291 bool do_refcount;
292 std::string cache_path;
293 /**
294 * Different from cache_path only if CVMFS_WORKSPACE or
295 * CVMFS_CACHE_WORKSPACE is set.
296 */
297 std::string workspace;
298 };
299
300 static void LogSqliteError(void *user_data __attribute__((unused)),
301 int sqlite_extended_error,
302 const char *message);
303
304 explicit FileSystem(const FileSystemInfo &fs_info);
305
306 static void SetupGlobalEnvironmentParams();
307 void SetupLogging();
308 void CreateStatistics();
309 void SetupSqlite();
310 bool DetermineNfsMode();
311 bool SetupWorkspace();
312 bool SetupCwd();
313 bool LockWorkspace();
314 bool SetupCrashGuard();
315 bool SetupNfsMaps();
316 void SetupUuid();
317
318 std::string MkCacheParm(const std::string &generic_parameter,
319 const std::string &instance);
320 bool CheckInstanceName(const std::string &instance);
321 bool TriageCacheMgr();
322 CacheManager *SetupCacheMgr(const std::string &instance);
323 CacheManager *SetupPosixCacheMgr(const std::string &instance);
324 CacheManager *SetupRamCacheMgr(const std::string &instance);
325 CacheManager *SetupTieredCacheMgr(const std::string &instance);
326 CacheManager *SetupExternalCacheMgr(const std::string &instance);
327 PosixCacheSettings DeterminePosixCacheSettings(const std::string &instance);
328 bool CheckPosixCacheSettings(const PosixCacheSettings &settings);
329 bool SetupPosixQuotaMgr(const PosixCacheSettings &settings,
330 CacheManager *cache_mgr);
331
332 // See FileSystemInfo for the following fields
333 std::string name_;
334 std::string exe_path_;
335 Type type_;
336 /**
337 * Not owned by the FileSystem object
338 */
339 OptionsManager *options_mgr_;
340 bool wait_workspace_;
341 bool foreground_;
342
343 perf::Counter *n_fs_open_;
344 perf::Counter *n_fs_dir_open_;
345 perf::Counter *n_fs_lookup_;
346 perf::Counter *n_fs_lookup_negative_;
347 perf::Counter *n_fs_stat_;
348 perf::Counter *n_fs_stat_stale_;
349 perf::Counter *n_fs_statfs_;
350 perf::Counter *n_fs_statfs_cached_;
351 perf::Counter *n_fs_read_;
352 perf::Counter *n_fs_readlink_;
353 perf::Counter *n_fs_forget_;
354 perf::Counter *n_fs_inode_replace_;
355 perf::Counter *no_open_files_;
356 perf::Counter *no_open_dirs_;
357 perf::Counter *n_eio_total_;
358 perf::Counter *n_eio_01_;
359 perf::Counter *n_eio_02_;
360 perf::Counter *n_eio_03_;
361 perf::Counter *n_eio_04_;
362 perf::Counter *n_eio_05_;
363 perf::Counter *n_eio_06_;
364 perf::Counter *n_eio_07_;
365 perf::Counter *n_eio_08_;
366 perf::Counter *n_emfile_;
367 IoErrorInfo io_error_info_;
368 perf::Statistics *statistics_;
369
370 Log2Histogram *hist_fs_lookup_;
371 Log2Histogram *hist_fs_forget_;
372 Log2Histogram *hist_fs_forget_multi_;
373 Log2Histogram *hist_fs_getattr_;
374 Log2Histogram *hist_fs_readlink_;
375 Log2Histogram *hist_fs_opendir_;
376 Log2Histogram *hist_fs_releasedir_;
377 Log2Histogram *hist_fs_readdir_;
378 Log2Histogram *hist_fs_open_;
379 Log2Histogram *hist_fs_read_;
380 Log2Histogram *hist_fs_release_;
381
382 /**
383 * A writeable local directory. Only small amounts of data (few bytes) will
384 * be stored here. Needed because the cache can be read-only. The workspace
385 * and the cache directory can be identical. A workspace can be shared among
386 * FileSystem instances if their name is different.
387 */
388 std::string workspace_;
389 /**
390 * During setup, the fuse module changes its working directory to workspace.
391 * Afterwards, workspace_ is ".". Store the original one in
392 * workspace_fullpath_
393 */
394 std::string workspace_fullpath_;
395 int fd_workspace_lock_;
396 std::string path_workspace_lock_;
397
398 /**
399 * An empty file that is removed on proper shutdown.
400 */
401 std::string path_crash_guard_;
402
403 /**
404 * A crash guard was found, thus we assume the file system was not shutdown
405 * properly last time.
406 */
407 bool found_previous_crash_;
408
409 /**
410 * Only needed for fuse to detect and prevent double mounting at the same
411 * location.
412 */
413 std::string mountpoint_;
414 /**
415 * The user-provided name of the parimay cache manager or 'default' if none
416 * is specified.
417 */
418 std::string cache_mgr_instance_;
419 /**
420 * Keep track of all the cache instances to detect circular definitions with
421 * the tiered cache.
422 */
423 std::set<std::string> constructed_instances_;
424 std::string nfs_maps_dir_;
425 /**
426 * Combination of kNfs... flags
427 */
428 unsigned nfs_mode_;
429 CacheManager *cache_mgr_;
430 /**
431 * Persistent for the cache directory + name combination. It is used in the
432 * Geo-API to allow for per-client responses when no proxy is used.
433 */
434 cvmfs::Uuid *uuid_cache_;
435
436 /**
437 * TODO(jblomer): Move to MountPoint. Tricky because of the sqlite maps
438 * and the sqlite configuration done for the file catalogs.
439 */
440 NfsMaps *nfs_maps_;
441 /**
442 * Used internally to remember if the Sqlite memory manager need to be shut
443 * down.
444 */
445 bool has_custom_sqlitevfs_;
446 };
447
448 /**
449 * The StatfsCache class is a class purely designed as "struct" (= holding
450 * object for all its parameters).
451 * All its logic, including the locking mechanism, is implemented in the
452 * function cvmfs_statfs in cvmfs.cc
453 */
454 class StatfsCache : SingleCopy {
455 public:
456 370 explicit StatfsCache(uint64_t cacheValid)
457 370 : expiry_deadline_(0), cache_timeout_(cacheValid) {
458 370 memset(&info_, 0, sizeof(info_));
459 370 lock_ = reinterpret_cast<pthread_mutex_t *>(
460 370 smalloc(sizeof(pthread_mutex_t)));
461 370 const int retval = pthread_mutex_init(lock_, NULL);
462
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 370 times.
370 assert(retval == 0);
463 370 }
464 370 ~StatfsCache() {
465 370 pthread_mutex_destroy(lock_);
466 370 free(lock_);
467 370 }
468 uint64_t *expiry_deadline() { return &expiry_deadline_; }
469 const uint64_t cache_timeout() { return cache_timeout_; }
470 struct statvfs *info() { return &info_; }
471 pthread_mutex_t *lock() { return lock_; }
472
473 private:
474 pthread_mutex_t *lock_;
475 // Timestamp/deadline when the currently cached statvfs info_ becomes invalid
476 uint64_t expiry_deadline_;
477 // Time in seconds how long statvfs info_ should be cached
478 uint64_t cache_timeout_;
479 struct statvfs info_;
480 };
481
482 /**
483 * A MountPoint provides a clip around all the different *Manager objects that
484 * in combination represent a mounted cvmfs repository. Its main purpose is
485 * the controlled construction and deconstruction of the involved ensemble of
486 * classes based on the information passed from an options manager.
487 *
488 * A MountPoint is constructed on top of a successfully constructed FileSystem.
489 *
490 * We use pointers to manager classes to make the order of construction and
491 * destruction explicit and also to keep the include list for this header small.
492 */
493 class MountPoint : SingleCopy, public BootFactory {
494 public:
495 /**
496 * If catalog reload fails, try again in 3 minutes
497 */
498 static const unsigned kShortTermTTL = 180;
499 static const time_t kIndefiniteDeadline = time_t(-1);
500
501 static MountPoint *Create(const std::string &fqrn,
502 FileSystem *file_system,
503 OptionsManager *options_mgr = NULL);
504 ~MountPoint();
505
506 unsigned GetMaxTtlMn();
507 unsigned GetEffectiveTtlSec();
508 void SetMaxTtlMn(unsigned value_minutes);
509 void ReEvaluateAuthz();
510
511 AuthzSessionManager *authz_session_mgr() { return authz_session_mgr_; }
512 BackoffThrottle *backoff_throttle() { return backoff_throttle_; }
513 1663 catalog::ClientCatalogManager *catalog_mgr() { return catalog_mgr_; }
514 ChunkTables *chunk_tables() { return chunk_tables_; }
515 81 download::DownloadManager *download_mgr() { return download_mgr_; }
516 12 download::DownloadManager *external_download_mgr() {
517 12 return external_download_mgr_;
518 }
519 file_watcher::FileWatcher *resolv_conf_watcher() {
520 return resolv_conf_watcher_;
521 }
522 465 cvmfs::Fetcher *fetcher() { return fetcher_; }
523 bool fixed_catalog() { return fixed_catalog_; }
524 471 std::string fqrn() const { return fqrn_; }
525 // TODO(jblomer): use only a singler fetcher object
526 cvmfs::Fetcher *external_fetcher() { return external_fetcher_; }
527 465 FileSystem *file_system() { return file_system_; }
528 MagicXattrManager *magic_xattr_mgr() { return magic_xattr_mgr_; }
529 3 bool has_membership_req() { return has_membership_req_; }
530 bool enforce_acls() { return enforce_acls_; }
531 bool cache_symlinks() { return cache_symlinks_; }
532 bool fuse_expire_entry() { return fuse_expire_entry_; }
533 catalog::InodeAnnotation *inode_annotation() { return inode_annotation_; }
534 glue::InodeTracker *inode_tracker() { return inode_tracker_; }
535 lru::InodeCache *inode_cache() { return inode_cache_; }
536 double kcache_timeout_sec() { return kcache_timeout_sec_; }
537 1702 lru::Md5PathCache *md5path_cache() { return md5path_cache_; }
538 std::string membership_req() { return membership_req_; }
539 glue::DentryTracker *dentry_tracker() { return dentry_tracker_; }
540 glue::PageCacheTracker *page_cache_tracker() { return page_cache_tracker_; }
541 lru::PathCache *path_cache() { return path_cache_; }
542 std::string repository_tag() { return repository_tag_; }
543 SimpleChunkTables *simple_chunk_tables() { return simple_chunk_tables_; }
544 1395 perf::Statistics *statistics() { return statistics_; }
545 perf::TelemetryAggregator *telemetry_aggr() { return telemetry_aggr_; }
546 465 signature::SignatureManager *signature_mgr() { return signature_mgr_; }
547 uid_t talk_socket_uid() { return talk_socket_uid_; }
548 gid_t talk_socket_gid() { return talk_socket_gid_; }
549 std::string talk_socket_path() { return talk_socket_path_; }
550 Tracer *tracer() { return tracer_; }
551 cvmfs::Uuid *uuid() { return uuid_; }
552 StatfsCache *statfs_cache() { return statfs_cache_; }
553
554 bool ReloadBlacklists();
555 void DisableCacheSymlinks();
556 void EnableFuseExpireEntry();
557
558 MountPoint(const std::string &fqrn,
559 FileSystem *file_system,
560 OptionsManager *options_mgr);
561
562 private:
563 /**
564 * The maximum TTL can be used to cap a root catalogs registered ttl. By
565 * default this is disabled (= 0).
566 */
567 static const unsigned kDefaultMaxTtlSec = 0;
568 /**
569 * Let fuse cache dentries for 1 minute.
570 */
571 static const unsigned kDefaultKCacheTtlSec = 60;
572 /**
573 * Number of Md5Path entries in the libcvmfs cache.
574 */
575 static const unsigned kLibPathCacheSize = 32000;
576 /**
577 * Cache seven times more md5 paths than inodes in the fuse module.
578 */
579 static const unsigned kInodeCacheFactor = 7;
580 /**
581 * Default to 16M RAM for meta-data caches; does not include the inode tracker
582 */
583 static const unsigned kDefaultMemcacheSize = 16 * 1024 * 1024;
584 /**
585 * Where to look for external authz helpers.
586 */
587 static const char *kDefaultAuthzSearchPath; // "/usr/libexec/cvmfs/authz"
588 /**
589 * Maximum number of concurrent HTTP connections.
590 */
591 static const unsigned kDefaultNumConnections = 16;
592 /**
593 * Default network timeout
594 */
595 static const unsigned kDefaultTimeoutSec = 5;
596 static const unsigned kDefaultRetries = 1;
597 static const unsigned kDefaultBackoffInitMs = 2000;
598 static const unsigned kDefaultBackoffMaxMs = 10000;
599 /**
600 * Memory buffer sizes for an activated tracer
601 */
602 static const unsigned kTracerBufferSize = 8192;
603 static const unsigned kTracerFlushThreshold = 7000;
604 static const char *kDefaultBlacklist; // "/etc/cvmfs/blacklist"
605 /**
606 * Default values for telemetry aggregator
607 */
608 static const int kDefaultTelemetrySendRateSec = 5 * 60; // 5min
609 static const int kMinimumTelemetrySendRateSec = 5; // 5sec
610
611
612 void CreateStatistics();
613 void CreateAuthz();
614 bool CreateSignatureManager();
615 bool CheckBlacklists();
616 bool CreateDownloadManagers();
617 bool CreateResolvConfWatcher();
618 void CreateFetchers();
619 bool CreateCatalogManager();
620 void CreateTables();
621 bool CreateTracer();
622 bool SetupBehavior();
623 void SetupDnsTuning(download::DownloadManager *manager);
624 void SetupHttpTuning();
625 bool SetupExternalDownloadMgr(bool dogeosort);
626 void SetupInodeAnnotation();
627 bool SetupOwnerMaps();
628 bool DetermineRootHash(shash::Any *root_hash);
629 bool FetchHistory(std::string *history_path);
630 std::string ReplaceHosts(std::string hosts);
631 std::string GetUniqFileSuffix();
632
633 std::string fqrn_;
634 cvmfs::Uuid *uuid_;
635 /**
636 * In contrast to the manager objects, the FileSystem is not owned.
637 */
638 FileSystem *file_system_;
639 /**
640 * The options manager is not owned.
641 */
642 OptionsManager *options_mgr_;
643
644 perf::Statistics *statistics_;
645 perf::TelemetryAggregator *telemetry_aggr_;
646 AuthzFetcher *authz_fetcher_;
647 AuthzSessionManager *authz_session_mgr_;
648 AuthzAttachment *authz_attachment_;
649 BackoffThrottle *backoff_throttle_;
650 signature::SignatureManager *signature_mgr_;
651 download::DownloadManager *download_mgr_;
652 download::DownloadManager *external_download_mgr_;
653 cvmfs::Fetcher *fetcher_;
654 cvmfs::Fetcher *external_fetcher_;
655 catalog::InodeAnnotation *inode_annotation_;
656 catalog::ClientCatalogManager *catalog_mgr_;
657 ChunkTables *chunk_tables_;
658 SimpleChunkTables *simple_chunk_tables_;
659 lru::InodeCache *inode_cache_;
660 lru::PathCache *path_cache_;
661 lru::Md5PathCache *md5path_cache_;
662 Tracer *tracer_;
663 glue::InodeTracker *inode_tracker_;
664 glue::DentryTracker *dentry_tracker_;
665 glue::PageCacheTracker *page_cache_tracker_;
666 MagicXattrManager *magic_xattr_mgr_;
667 StatfsCache *statfs_cache_;
668
669 file_watcher::FileWatcher *resolv_conf_watcher_;
670
671 unsigned max_ttl_sec_;
672 pthread_mutex_t lock_max_ttl_;
673 double kcache_timeout_sec_;
674 bool fixed_catalog_;
675 bool enforce_acls_;
676 bool cache_symlinks_;
677 bool fuse_expire_entry_;
678 std::string repository_tag_;
679 std::vector<std::string> blacklist_paths_;
680
681 // TODO(jblomer): this should go in the catalog manager
682 std::string membership_req_;
683 bool has_membership_req_;
684
685 std::string talk_socket_path_;
686 uid_t talk_socket_uid_;
687 gid_t talk_socket_gid_;
688 }; // class MointPoint
689
690 #endif // CVMFS_MOUNTPOINT_H_
691