mmap_v1_extent_manager.h

Go to the documentation of this file.

// mmap_v1_extent_manager.h

#pragma once

#include <string>

#include <boost/filesystem/path.hpp>

#include "mongo/base/status.h"
#include "mongo/base/string_data.h"
#include "mongo/db/concurrency/lock_manager_defs.h"
#include "mongo/db/storage/mmap_v1/diskloc.h"
#include "mongo/db/storage/mmap_v1/extent_manager.h"
#include "mongo/db/storage/mmap_v1/record_access_tracker.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/stdx/mutex.h"

namespace mongo {

class DataFile;
class DataFileVersion;
class MmapV1RecordHeader;
class OperationContext;

struct Extent;

class MmapV1ExtentManager : public ExtentManager {
    MONGO_DISALLOW_COPYING(MmapV1ExtentManager);

public:
    class Factory : public ExtentManager::Factory {
        virtual std::unique_ptr<ExtentManager> create(StringData dbname,
                                                      StringData path,
                                                      bool directoryPerDB) final;
    };

    MmapV1ExtentManager(StringData dbname, StringData path, bool directoryPerDB);

    void close(OperationContext* opCtx) {
        _files.close(opCtx);
    }

    Status init(OperationContext* opCtx);

    int numFiles() const;
    long long fileSize() const;

    // must call Extent::reuse on the returned extent
    DiskLoc allocateExtent(OperationContext* opCtx, bool capped, int size, bool enforceQuota);

    void freeExtents(OperationContext* opCtx, DiskLoc firstExt, DiskLoc lastExt);

    void freeExtent(OperationContext* opCtx, DiskLoc extent);


    void freeListStats(OperationContext* opCtx, int* numExtents, int64_t* totalFreeSizeBytes) const;

    MmapV1RecordHeader* recordForV1(const DiskLoc& loc) const;

    std::unique_ptr<RecordFetcher> recordNeedsFetch(const DiskLoc& loc) const;

    Extent* extentForV1(const DiskLoc& loc) const;

    DiskLoc extentLocForV1(const DiskLoc& loc) const;

    Extent* getExtent(const DiskLoc& loc, bool doSanityCheck = true) const;

    DataFileVersion getFileFormat(OperationContext* opCtx) const final;
    void setFileFormat(OperationContext* opCtx, DataFileVersion newVersion) final;

    const DataFile* getOpenFile(int n) const final {
        return _getOpenFile(n);
    }

    virtual int maxSize() const;

    virtual CacheHint* cacheHint(const DiskLoc& extentLoc, const HintType& hint);

private:
    DiskLoc _allocFromFreeList(OperationContext* opCtx, int approxSize, bool capped);

    /* allocate a new Extent, does not check free list
    */
    DiskLoc _createExtent(OperationContext* opCtx, int approxSize, bool enforceQuota);

    DataFile* _addAFile(OperationContext* opCtx, int sizeNeeded, bool preallocateNextFile);


    MmapV1RecordHeader* _recordForV1(const DiskLoc& loc) const;

    DiskLoc _getFreeListStart() const;
    DiskLoc _getFreeListEnd() const;
    void _setFreeListStart(OperationContext* opCtx, DiskLoc loc);
    void _setFreeListEnd(OperationContext* opCtx, DiskLoc loc);

    const DataFile* _getOpenFile(int fileId) const;
    DataFile* _getOpenFile(int fileId);

    DiskLoc _createExtentInFile(
        OperationContext* opCtx, int fileNo, DataFile* f, int size, bool enforceQuota);

    boost::filesystem::path _fileName(int n) const;

    // -----

    const std::string _dbname;  // i.e. "test"
    const std::string _path;    // i.e. "/data/db"
    const bool _directoryPerDB;
    const ResourceId _rid;

    // This reference points into the MMAPv1 engine and is only valid as long as the
    // engine is valid. Not owned here.
    RecordAccessTracker* _recordAccessTracker;

    class FilesArray {
    public:
        FilesArray() : _size(0) {}
        ~FilesArray();

        void close(OperationContext* opCtx);

        DataFile* operator[](int n) const {
            invariant(n >= 0 && n < size());
            return _files[n];
        }

        bool empty() const {
            return size() == 0;
        }

        int size() const {
            return _size.load();
        }

        // Appends val to the array, taking ownership of its pointer
        void push_back(DataFile* val);

    private:
        stdx::mutex _writersMutex;
        AtomicInt32 _size;  // number of files in the array
        DataFile* _files[DiskLoc::MaxFiles];
    };

    FilesArray _files;
};
}