Head

GCC Code Coverage Report

Directory:	cvmfs/		Exec	Total	Coverage
File:	cvmfs/fuse_remount.cc	Lines:	0	153	0.0 %
Date:	2019-02-03 02:48:13	Branches:	0	66	0.0 %


/**
 * This file is part of the CernVM File System.
 */

#include "cvmfs_config.h"
#include "fuse_remount.h"

#include <errno.h>
#include <poll.h>
#include <unistd.h>

#include <cassert>
#include <cstdlib>
#include <cstring>

#include "backoff.h"
#include "catalog_mgr_client.h"
#include "fuse_inode_gen.h"
#include "logging.h"
#include "lru_md.h"
#include "mountpoint.h"
#include "platform.h"
#include "statistics.h"
#include "util/posix.h"

using namespace std;  // NOLINT


/**
 * Executed by the trigger thread, or triggered from cvmfs_talk.  Moves into
 * drainout mode if a new catalog is available online.
 */
FuseRemounter::Status FuseRemounter::Check() {
  FenceGuard fence_guard(&fence_maintenance_);
  if (IsInMaintenanceMode())
    return kStatusMaintenance;

  LogCvmfs(kLogCvmfs, kLogDebug,
           "catalog TTL expired, checking revision against blacklists");
  if (mountpoint_->ReloadBlacklists() &&
      mountpoint_->catalog_mgr()->IsRevisionBlacklisted())
  {
    LogCvmfs(kLogCatalog, kLogDebug | kLogSyslogErr,
            "repository revision blacklisted, aborting");
    abort();
  }

  LogCvmfs(kLogCvmfs, kLogDebug, "remounting root catalog");
  catalog::LoadError retval = mountpoint_->catalog_mgr()->Remount(true);
  switch (retval) {
    case catalog::kLoadNew:
      SetOfflineMode(false);
      if (atomic_cas32(&drainout_mode_, 0, 1)) {
        // As of this point, fuse callbacks return zero as cache timeout
        LogCvmfs(kLogCvmfs, kLogDebug,
                 "new catalog revision available, "
                 "draining out meta-data caches");
        invalidator_handle_.Reset();
        invalidator_->InvalidateInodes(&invalidator_handle_);
        atomic_inc32(&drainout_mode_);
        // drainout_mode_ == 2, IsInDrainoutMode is now 'true'
      } else {
        LogCvmfs(kLogCvmfs, kLogDebug, "already in drainout mode, leaving");
      }
      return kStatusDraining;
    case catalog::kLoadFail:
    case catalog::kLoadNoSpace:
      LogCvmfs(kLogCvmfs, kLogDebug,
               "reload failed (%s), applying short term TTL",
               catalog::Code2Ascii(retval));
      SetOfflineMode(true);
      catalogs_valid_until_ = time(NULL) + MountPoint::kShortTermTTL;
      SetAlarm(MountPoint::kShortTermTTL);
      return (retval == catalog::kLoadFail) ?
             kStatusFailGeneral : kStatusFailNoSpace;
    case catalog::kLoadUp2Date: {
      LogCvmfs(kLogCvmfs, kLogDebug,
               "catalog up to date (could be offline mode)");
      SetOfflineMode(mountpoint_->catalog_mgr()->offline_mode());
      unsigned ttl = offline_mode_ ?
        MountPoint::kShortTermTTL : mountpoint_->GetEffectiveTtlSec();
      catalogs_valid_until_ = time(NULL) + ttl;
      SetAlarm(ttl);
      return kStatusUp2Date;
    }
    default:
      abort();
  }
}


/**
 * Used from the TalkManager.  Continously calls 'check' until it returns with
 * "up to date" or a failure.
 */
FuseRemounter::Status FuseRemounter::CheckSynchronously() {
  BackoffThrottle throttle;
  while (true) {
    Status status = Check();
    switch (status) {
      case kStatusDraining:
        TryFinish();
        break;
      default:
        return status;
    }
    throttle.Throttle();
  }
}


void FuseRemounter::EnterMaintenanceMode() {
  fence_maintenance_.Drain();
  atomic_cas32(&maintenance_mode_, 0, 1);
  fence_maintenance_.Open();

  // All running Check() and TryFinish() methods returned.  Both methods now
  // return immediately as noops.

  // Flush caches before reload of fuse module
  invalidator_handle_.Reset();
  invalidator_->InvalidateInodes(&invalidator_handle_);
  invalidator_handle_.WaitFor();
}

FuseRemounter::FuseRemounter(MountPoint *mountpoint,
                             cvmfs::InodeGenerationInfo *inode_generation_info,
                             struct fuse_chan **fuse_channel,
                             bool fuse_notify_invalidation)
    : mountpoint_(mountpoint),
      inode_generation_info_(inode_generation_info),
      invalidator_(new FuseInvalidator(mountpoint->inode_tracker(),
                                       fuse_channel, fuse_notify_invalidation)),
      invalidator_handle_(static_cast<int>(mountpoint->kcache_timeout_sec())),
      fence_(new Fence()),
      offline_mode_(false),
      catalogs_valid_until_(MountPoint::kIndefiniteDeadline) {
  memset(&thread_remount_trigger_, 0, sizeof(thread_remount_trigger_));
  pipe_remount_trigger_[0] = pipe_remount_trigger_[1] = -1;
  atomic_init32(&drainout_mode_);
  atomic_init32(&maintenance_mode_);
  atomic_init32(&critical_section_);
}

FuseRemounter::~FuseRemounter() {
  if (HasRemountTrigger()) {
    char quit = 'Q';
    WritePipe(pipe_remount_trigger_[1], &quit, 1);
    pthread_join(thread_remount_trigger_, NULL);
    ClosePipe(pipe_remount_trigger_);
  }
  delete invalidator_;
  delete fence_;
}


/**
 * Triggers the Check() method when the catalog TTL expires.  Works essentially
 * as an alarm() timer.
 */
void *FuseRemounter::MainRemountTrigger(void *data) {
  FuseRemounter *remounter = reinterpret_cast<FuseRemounter *>(data);
  LogCvmfs(kLogCvmfs, kLogDebug, "starting remount trigger");
  char c;
  int timeout_ms = -1;
  uint64_t deadline = 0;
  struct pollfd watch_ctrl;
  watch_ctrl.fd = remounter->pipe_remount_trigger_[0];
  watch_ctrl.events = POLLIN | POLLPRI;
  while (true) {
    watch_ctrl.revents = 0;
    int retval = poll(&watch_ctrl, 1, timeout_ms);
    if (retval < 0) {
      if (errno == EINTR) {
        if (timeout_ms >= 0) {
          uint64_t now = platform_monotonic_time();
          timeout_ms = (now > deadline) ? 0 : (deadline - now) * 1000;
        }
        continue;
      }
      LogCvmfs(kLogCvmfs, kLogSyslogErr | kLogDebug,
               "remount trigger connection failure (%d)", errno);
      abort();
    }

    if (retval == 0) {
      remounter->Check();
      timeout_ms = -1;
      continue;
    }

    assert(watch_ctrl.revents != 0);

    ReadPipe(remounter->pipe_remount_trigger_[0], &c, 1);
    if (c == 'Q')
      break;
    assert(c == 'T');
    ReadPipe(remounter->pipe_remount_trigger_[0], &timeout_ms, sizeof(int));
    deadline = platform_monotonic_time() + timeout_ms / 1000;
  }
  LogCvmfs(kLogCvmfs, kLogDebug, "stopping remount trigger");
  return NULL;
}


void FuseRemounter::SetAlarm(int timeout) {
  // Remounting could be called for a non auto-update repository
  if (!HasRemountTrigger())
    return;

  timeout *= 1000;  // timeout given in ms
  const unsigned buf_size = 1 + sizeof(int);
  char buf[buf_size];
  buf[0] = 'T';
  memcpy(&buf[1], &timeout, sizeof(timeout));
  WritePipe(pipe_remount_trigger_[1], buf, buf_size);
}


void FuseRemounter::SetOfflineMode(bool value) {
  if (value == offline_mode_)
    return;
  offline_mode_ = value;

  if (offline_mode_) {
    LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslogWarn,
             "warning, could not apply updated catalog revision, "
             "entering offline mode");
    perf::Inc(mountpoint_->file_system()->n_io_error());
  } else {
    LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslog, "recovered from offline mode");
  }
}


void FuseRemounter::Spawn() {
  invalidator_->Spawn();
  if (!mountpoint_->fixed_catalog()) {
    MakePipe(pipe_remount_trigger_);
    int retval = pthread_create(
      &thread_remount_trigger_, NULL, MainRemountTrigger, this);
    assert(retval == 0);

    SetOfflineMode(mountpoint_->catalog_mgr()->offline_mode());
    unsigned ttl = offline_mode_ ?
      MountPoint::kShortTermTTL : mountpoint_->GetEffectiveTtlSec();
    catalogs_valid_until_ = time(NULL) + ttl;
    SetAlarm(ttl);
  }
}


/**
 * Applies a previously started remount operation.  This is called from the
 * fuse callbacks or from CheckSynchronously().  Usually, the method quits
 * immediately except when a new catalog is available and the kernel caches are
 * flushed.
 */
void FuseRemounter::TryFinish() {
  FenceGuard fence_guard(&fence_maintenance_);
  if (IsInMaintenanceMode())
    return;
  if (!EnterCriticalSection())
    return;
  if (!IsInDrainoutMode()) {
    LeaveCriticalSection();
    return;
  }

  // No one else is in this code path and we have a valid FuseInvalidator handle

  if (!invalidator_handle_.IsDone()) {
    LeaveCriticalSection();
    return;
  }
  LogCvmfs(kLogCvmfs, kLogDebug, "caches drained out, applying new catalog");

  // No new inserts into caches
  mountpoint_->inode_cache()->Pause();
  mountpoint_->path_cache()->Pause();
  mountpoint_->md5path_cache()->Pause();
  mountpoint_->inode_cache()->Drop();
  mountpoint_->path_cache()->Drop();
  mountpoint_->md5path_cache()->Drop();

  // Ensure that all Fuse callbacks left the catalog query code
  fence_->Drain();
  catalog::LoadError retval = mountpoint_->catalog_mgr()->Remount(false);
  if (mountpoint_->inode_annotation()) {
    inode_generation_info_->inode_generation =
      mountpoint_->inode_annotation()->GetGeneration();
  }
  mountpoint_->ReEvaluateAuthz();
  fence_->Open();

  mountpoint_->inode_cache()->Resume();
  mountpoint_->path_cache()->Resume();
  mountpoint_->md5path_cache()->Resume();

  atomic_xadd32(&drainout_mode_, -2);  // 2 --> 0, end of drainout mode

  if ((retval == catalog::kLoadFail) || (retval == catalog::kLoadNoSpace)) {
    // Can temporarily "escape" offline mode if update came from updated
    // alien cache
    SetOfflineMode(true);
    catalogs_valid_until_ = time(NULL) + MountPoint::kShortTermTTL;
    SetAlarm(MountPoint::kShortTermTTL);
  } else {
    SetOfflineMode(false);
    LogCvmfs(kLogCvmfs, kLogSyslog, "switched to catalog revision %d",
             mountpoint_->catalog_mgr()->GetRevision());
    catalogs_valid_until_ = time(NULL) + mountpoint_->GetEffectiveTtlSec();
    SetAlarm(mountpoint_->GetEffectiveTtlSec());
  }

  LeaveCriticalSection();
}


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/**
2			* This file is part of the CernVM File System.
3			*/
4
5			#include "cvmfs_config.h"
6			#include "fuse_remount.h"
7
8			#include <errno.h>
9			#include <poll.h>
10			#include <unistd.h>
11
12			#include <cassert>
13			#include <cstdlib>
14			#include <cstring>
15
16			#include "backoff.h"
17			#include "catalog_mgr_client.h"
18			#include "fuse_inode_gen.h"
19			#include "logging.h"
20			#include "lru_md.h"
21			#include "mountpoint.h"
22			#include "platform.h"
23			#include "statistics.h"
24			#include "util/posix.h"
25
26			using namespace std; // NOLINT
27
28
29			/**
30			* Executed by the trigger thread, or triggered from cvmfs_talk. Moves into
31			* drainout mode if a new catalog is available online.
32			*/
33			FuseRemounter::Status FuseRemounter::Check() {
34			FenceGuard fence_guard(&fence_maintenance_);
35			if (IsInMaintenanceMode())
36			return kStatusMaintenance;
37
38			LogCvmfs(kLogCvmfs, kLogDebug,
39			"catalog TTL expired, checking revision against blacklists");
40			if (mountpoint_->ReloadBlacklists() &&
41			mountpoint_->catalog_mgr()->IsRevisionBlacklisted())
42			{
43			LogCvmfs(kLogCatalog, kLogDebug \| kLogSyslogErr,
44			"repository revision blacklisted, aborting");
45			abort();
46			}
47
48			LogCvmfs(kLogCvmfs, kLogDebug, "remounting root catalog");
49			catalog::LoadError retval = mountpoint_->catalog_mgr()->Remount(true);
50			switch (retval) {
51			case catalog::kLoadNew:
52			SetOfflineMode(false);
53			if (atomic_cas32(&drainout_mode_, 0, 1)) {
54			// As of this point, fuse callbacks return zero as cache timeout
55			LogCvmfs(kLogCvmfs, kLogDebug,
56			"new catalog revision available, "
57			"draining out meta-data caches");
58			invalidator_handle_.Reset();
59			invalidator_->InvalidateInodes(&invalidator_handle_);
60			atomic_inc32(&drainout_mode_);
61			// drainout_mode_ == 2, IsInDrainoutMode is now 'true'
62			} else {
63			LogCvmfs(kLogCvmfs, kLogDebug, "already in drainout mode, leaving");
64			}
65			return kStatusDraining;
66			case catalog::kLoadFail:
67			case catalog::kLoadNoSpace:
68			LogCvmfs(kLogCvmfs, kLogDebug,
69			"reload failed (%s), applying short term TTL",
70			catalog::Code2Ascii(retval));
71			SetOfflineMode(true);
72			catalogs_valid_until_ = time(NULL) + MountPoint::kShortTermTTL;
73			SetAlarm(MountPoint::kShortTermTTL);
74			return (retval == catalog::kLoadFail) ?
75			kStatusFailGeneral : kStatusFailNoSpace;
76			case catalog::kLoadUp2Date: {
77			LogCvmfs(kLogCvmfs, kLogDebug,
78			"catalog up to date (could be offline mode)");
79			SetOfflineMode(mountpoint_->catalog_mgr()->offline_mode());
80			unsigned ttl = offline_mode_ ?
81			MountPoint::kShortTermTTL : mountpoint_->GetEffectiveTtlSec();
82			catalogs_valid_until_ = time(NULL) + ttl;
83			SetAlarm(ttl);
84			return kStatusUp2Date;
85			}
86			default:
87			abort();
88			}
89			}
90
91
92			/**
93			* Used from the TalkManager. Continously calls 'check' until it returns with
94			* "up to date" or a failure.
95			*/
96			FuseRemounter::Status FuseRemounter::CheckSynchronously() {
97			BackoffThrottle throttle;
98			while (true) {
99			Status status = Check();
100			switch (status) {
101			case kStatusDraining:
102			TryFinish();
103			break;
104			default:
105			return status;
106			}
107			throttle.Throttle();
108			}
109			}
110
111
112			void FuseRemounter::EnterMaintenanceMode() {
113			fence_maintenance_.Drain();
114			atomic_cas32(&maintenance_mode_, 0, 1);
115			fence_maintenance_.Open();
116
117			// All running Check() and TryFinish() methods returned. Both methods now
118			// return immediately as noops.
119
120			// Flush caches before reload of fuse module
121			invalidator_handle_.Reset();
122			invalidator_->InvalidateInodes(&invalidator_handle_);
123			invalidator_handle_.WaitFor();
124			}
125
126			FuseRemounter::FuseRemounter(MountPoint *mountpoint,
127			cvmfs::InodeGenerationInfo *inode_generation_info,
128			struct fuse_chan **fuse_channel,
129			bool fuse_notify_invalidation)
130			: mountpoint_(mountpoint),
131			inode_generation_info_(inode_generation_info),
132			invalidator_(new FuseInvalidator(mountpoint->inode_tracker(),
133			fuse_channel, fuse_notify_invalidation)),
134			invalidator_handle_(static_cast<int>(mountpoint->kcache_timeout_sec())),
135			fence_(new Fence()),
136			offline_mode_(false),
137			catalogs_valid_until_(MountPoint::kIndefiniteDeadline) {
138			memset(&thread_remount_trigger_, 0, sizeof(thread_remount_trigger_));
139			pipe_remount_trigger_[0] = pipe_remount_trigger_[1] = -1;
140			atomic_init32(&drainout_mode_);
141			atomic_init32(&maintenance_mode_);
142			atomic_init32(&critical_section_);
143			}
144
145			FuseRemounter::~FuseRemounter() {
146			if (HasRemountTrigger()) {
147			char quit = 'Q';
148			WritePipe(pipe_remount_trigger_[1], &quit, 1);
149			pthread_join(thread_remount_trigger_, NULL);
150			ClosePipe(pipe_remount_trigger_);
151			}
152			delete invalidator_;
153			delete fence_;
154			}
155
156
157			/**
158			* Triggers the Check() method when the catalog TTL expires. Works essentially
159			* as an alarm() timer.
160			*/
161			void FuseRemounter::MainRemountTrigger(void data) {
162			FuseRemounter remounter = reinterpret_cast<FuseRemounter >(data);
163			LogCvmfs(kLogCvmfs, kLogDebug, "starting remount trigger");
164			char c;
165			int timeout_ms = -1;
166			uint64_t deadline = 0;
167			struct pollfd watch_ctrl;
168			watch_ctrl.fd = remounter->pipe_remount_trigger_[0];
169			watch_ctrl.events = POLLIN \| POLLPRI;
170			while (true) {
171			watch_ctrl.revents = 0;
172			int retval = poll(&watch_ctrl, 1, timeout_ms);
173			if (retval < 0) {
174			if (errno == EINTR) {
175			if (timeout_ms >= 0) {
176			uint64_t now = platform_monotonic_time();
177			timeout_ms = (now > deadline) ? 0 : (deadline - now) * 1000;
178			}
179			continue;
180			}
181			LogCvmfs(kLogCvmfs, kLogSyslogErr \| kLogDebug,
182			"remount trigger connection failure (%d)", errno);
183			abort();
184			}
185
186			if (retval == 0) {
187			remounter->Check();
188			timeout_ms = -1;
189			continue;
190			}
191
192			assert(watch_ctrl.revents != 0);
193
194			ReadPipe(remounter->pipe_remount_trigger_[0], &c, 1);
195			if (c == 'Q')
196			break;
197			assert(c == 'T');
198			ReadPipe(remounter->pipe_remount_trigger_[0], &timeout_ms, sizeof(int));
199			deadline = platform_monotonic_time() + timeout_ms / 1000;
200			}
201			LogCvmfs(kLogCvmfs, kLogDebug, "stopping remount trigger");
202			return NULL;
203			}
204
205
206			void FuseRemounter::SetAlarm(int timeout) {
207			// Remounting could be called for a non auto-update repository
208			if (!HasRemountTrigger())
209			return;
210
211			timeout *= 1000; // timeout given in ms
212			const unsigned buf_size = 1 + sizeof(int);
213			char buf[buf_size];
214			buf[0] = 'T';
215			memcpy(&buf[1], &timeout, sizeof(timeout));
216			WritePipe(pipe_remount_trigger_[1], buf, buf_size);
217			}
218
219
220			void FuseRemounter::SetOfflineMode(bool value) {
221			if (value == offline_mode_)
222			return;
223			offline_mode_ = value;
224
225			if (offline_mode_) {
226			LogCvmfs(kLogCvmfs, kLogDebug \| kLogSyslogWarn,
227			"warning, could not apply updated catalog revision, "
228			"entering offline mode");
229			perf::Inc(mountpoint_->file_system()->n_io_error());
230			} else {
231			LogCvmfs(kLogCvmfs, kLogDebug \| kLogSyslog, "recovered from offline mode");
232			}
233			}
234
235
236			void FuseRemounter::Spawn() {
237			invalidator_->Spawn();
238			if (!mountpoint_->fixed_catalog()) {
239			MakePipe(pipe_remount_trigger_);
240			int retval = pthread_create(
241			&thread_remount_trigger_, NULL, MainRemountTrigger, this);
242			assert(retval == 0);
243
244			SetOfflineMode(mountpoint_->catalog_mgr()->offline_mode());
245			unsigned ttl = offline_mode_ ?
246			MountPoint::kShortTermTTL : mountpoint_->GetEffectiveTtlSec();
247			catalogs_valid_until_ = time(NULL) + ttl;
248			SetAlarm(ttl);
249			}
250			}
251
252
253			/**
254			* Applies a previously started remount operation. This is called from the
255			* fuse callbacks or from CheckSynchronously(). Usually, the method quits
256			* immediately except when a new catalog is available and the kernel caches are
257			* flushed.
258			*/
259			void FuseRemounter::TryFinish() {
260			FenceGuard fence_guard(&fence_maintenance_);
261			if (IsInMaintenanceMode())
262			return;
263			if (!EnterCriticalSection())
264			return;
265			if (!IsInDrainoutMode()) {
266			LeaveCriticalSection();
267			return;
268			}
269
270			// No one else is in this code path and we have a valid FuseInvalidator handle
271
272			if (!invalidator_handle_.IsDone()) {
273			LeaveCriticalSection();
274			return;
275			}
276			LogCvmfs(kLogCvmfs, kLogDebug, "caches drained out, applying new catalog");
277
278			// No new inserts into caches
279			mountpoint_->inode_cache()->Pause();
280			mountpoint_->path_cache()->Pause();
281			mountpoint_->md5path_cache()->Pause();
282			mountpoint_->inode_cache()->Drop();
283			mountpoint_->path_cache()->Drop();
284			mountpoint_->md5path_cache()->Drop();
285
286			// Ensure that all Fuse callbacks left the catalog query code
287			fence_->Drain();
288			catalog::LoadError retval = mountpoint_->catalog_mgr()->Remount(false);
289			if (mountpoint_->inode_annotation()) {
290			inode_generation_info_->inode_generation =
291			mountpoint_->inode_annotation()->GetGeneration();
292			}
293			mountpoint_->ReEvaluateAuthz();
294			fence_->Open();
295
296			mountpoint_->inode_cache()->Resume();
297			mountpoint_->path_cache()->Resume();
298			mountpoint_->md5path_cache()->Resume();
299
300			atomic_xadd32(&drainout_mode_, -2); // 2 --> 0, end of drainout mode
301
302			if ((retval == catalog::kLoadFail) \|\| (retval == catalog::kLoadNoSpace)) {
303			// Can temporarily "escape" offline mode if update came from updated
304			// alien cache
305			SetOfflineMode(true);
306			catalogs_valid_until_ = time(NULL) + MountPoint::kShortTermTTL;
307			SetAlarm(MountPoint::kShortTermTTL);
308			} else {
309			SetOfflineMode(false);
310			LogCvmfs(kLogCvmfs, kLogSyslog, "switched to catalog revision %d",
311			mountpoint_->catalog_mgr()->GetRevision());
312			catalogs_valid_until_ = time(NULL) + mountpoint_->GetEffectiveTtlSec();
313			SetAlarm(mountpoint_->GetEffectiveTtlSec());
314			}
315
316			LeaveCriticalSection();
317			}