GCC Code Coverage Report

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