ExitCode _initAndListen(ServiceContext* serviceContext, int listenPort) {
    Client::initThread("initandlisten", serviceContext->getService(ClusterRole::ShardServer));
    ....
    // Start watchdog!
    startWatchdog(serviceContext);
    ....
    return waitForShutdown();
}

void startWatchdog(ServiceContext* service) {
    Seconds period{gWatchdogPeriodSeconds.load()};
    if (period < Seconds::zero()) {
        // Skip starting the watchdog if the user has not asked for it.
        watchdogEnabled = false;
        return;
    }
 
    watchdogEnabled = true;
    std::vector<std::unique_ptr<WatchdogCheck>> checks;
 
    // Check for the data directory.
    auto dataCheck =
        std::make_unique<DirectoryCheck>(boost::filesystem::path(storageGlobalParams.dbpath));
    checks.push_back(std::move(dataCheck));
 
    // Check for the journal.
    auto journalDirectory = boost::filesystem::path(storageGlobalParams.dbpath);
    journalDirectory /= "journal";
    if (boost::filesystem::exists(journalDirectory)) {
        auto journalCheck = std::make_unique<DirectoryCheck>(journalDirectory);
 
        checks.push_back(std::move(journalCheck));
    }
    ....
 
    // Check for the log directory.
    if (!serverGlobalParams.logpath.empty()) {
        boost::filesystem::path logFile(serverGlobalParams.logpath);
        auto logPath = logFile.parent_path();
 
        auto logCheck = std::make_unique<DirectoryCheck>(logPath);
        checks.push_back(std::move(logCheck));
    }
 
    // Check for the audit directories.
    for (auto&& path : getWatchdogPaths()) {
        auto auditCheck = std::make_unique<DirectoryCheck>(path);
        checks.push_back(std::move(auditCheck));
    }
 
    WatchdogMonitorInterface::set(
        service,
        std::make_unique<WatchdogMonitor>(
            std::move(checks), watchdogCheckPeriod, period, watchdogTerminate));
 
    // Install the new WatchdogMonitor
    auto staticMonitor = WatchdogMonitorInterface::get(service);
    // start!
    staticMonitor->start();
}
 
}

void WatchdogPeriodicThread::start() {
    {
        stdx::lock_guard<Latch> lock(_mutex);
 
        invariant(_state == State::kNotStarted);
        _state = State::kStarted;
 
        // Start the thread.
        // do Loop!
        _thread = stdx::thread([this] { this->doLoop(); });
    }
}

void WatchdogPeriodicThread::doLoop() {
    ....
 
    // infinite loop
    while (true) {
        ....
        // timer start
        Date_t startTime = preciseClockSource->now();
 
        {
            stdx::unique_lock<Latch> lock(_mutex);
            MONGO_IDLE_THREAD_BLOCK;
 
            // wait while period
            while ((startTime + _period) > preciseClockSource->now()) {
                auto oldPeriod = _period;
                try {
                    opCtx->waitForConditionOrInterruptUntil(
                        _condvar, lock, startTime + _period, [&] {
                            return oldPeriod != _period || _state == State::kShutdownRequested;
                        });
                }
        ....
 
        // Run watchdog!
        run(opCtx.get());
    }
}

public:
    WatchdogCheckThread(std::vector<std::unique_ptr<WatchdogCheck>> checks, Milliseconds period);
...
void WatchdogCheckThread::run(OperationContext* opCtx) {
    for (auto& check : _checks) {
        ...
        if (_shouldRunChecks.load()) {
            // Run checkers before inserted.
            check->run(opCtx);
        ...
        }
    }
}

constexpr StringData DirectoryCheck::kProbeFileName;
constexpr StringData DirectoryCheck::kProbeFileNameExt;
 
void DirectoryCheck::run(OperationContext* opCtx) {
    // Ensure we have unique file names if multiple processes share the same logging directory
    // This is why file named "watchdog_prob_{pid}.txt" is occurred.
    boost::filesystem::path file = _directory;
    file /= kProbeFileName.toString();
    file += ProcessId::getCurrent().toString();
    file += kProbeFileNameExt.toString();
 
    // Check files.
    checkFile(opCtx, file);
    ....
}

/**
 * Check a directory is ok
 * 1. Open up a direct_io to a new file
 * 2. Write to the file
 * 3. Read from the file
 * 4. Close file
 */
void checkFile(OperationContext* opCtx, const boost::filesystem::path& file) {
    Date_t now = opCtx->getServiceContext()->getPreciseClockSource()->now();
    std::string nowStr = now.toString();
 
    // Create file descriptor.
    int fd = open(file.generic_string().c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    ....
 
    struct stat st;
    if (fstat(fd, &st) < 0) {
        ....
        st.st_blksize = 4096;
    }
 
    unsigned long alignment = st.st_blksize;
    unsigned long alignedSize = boost::alignment::align_up(nowStr.size(), alignment);
    char* alignedBuf = static_cast<char*>(boost::alignment::aligned_alloc(alignment, alignedSize));
    ScopeGuard cleanupBuf([alignedBuf]() { boost::alignment::aligned_free(alignedBuf); });
 
    memset(alignedBuf, 0, alignedSize);
    memcpy(alignedBuf, nowStr.c_str(), nowStr.size());
 
    ssize_t bytesWrittenInWrite = -1;
    while (bytesWrittenInWrite == -1) {
        // Write now.toString().
        bytesWrittenInWrite = write(fd, alignedBuf, alignedSize);
        ....
    }
    ....
 
    // Write to disk through fsync.
    if (fsync(fd)) {
        ....
    }
 
    ssize_t bytesReadInRead = -1;
    while (bytesReadInRead == -1) {
        // Read from disk.
        bytesReadInRead = pread(fd, alignedBuf, alignedSize, 0);
        if (bytesReadInRead == -1) {
            auto ec = lastSystemError();
            if (ec != systemError(EINTR)) {
                ....
                fassertNoTrace(4083, !ec);
            }
        }
    }
 
    // Close file descriptor.
    if (close(fd)) {
        ...
        fassertNoTrace(4084, !ec);
    }
}