record_store_v1_base.h

Go to the documentation of this file.

#pragma once

#include "mongo/stdx/unordered_set.h"
#include "mongo/util/concurrency/spin_lock.h"

#include "mongo/db/storage/mmap_v1/diskloc.h"
#include "mongo/db/storage/record_store.h"

namespace mongo {

class DeletedRecord;
class ExtentManager;
class MmapV1RecordHeader;
class OperationContext;

struct Extent;

class RecordStoreV1MetaData {
public:
    virtual ~RecordStoreV1MetaData() {}

    virtual const DiskLoc& capExtent() const = 0;
    virtual void setCapExtent(OperationContext* opCtx, const DiskLoc& loc) = 0;

    virtual const DiskLoc& capFirstNewRecord() const = 0;
    virtual void setCapFirstNewRecord(OperationContext* opCtx, const DiskLoc& loc) = 0;

    bool capLooped() const {
        return capFirstNewRecord().isValid();
    }

    virtual long long dataSize() const = 0;
    virtual long long numRecords() const = 0;

    virtual void incrementStats(OperationContext* opCtx,
                                long long dataSizeIncrement,
                                long long numRecordsIncrement) = 0;

    virtual void setStats(OperationContext* opCtx, long long dataSize, long long numRecords) = 0;

    virtual DiskLoc deletedListEntry(int bucket) const = 0;
    virtual void setDeletedListEntry(OperationContext* opCtx, int bucket, const DiskLoc& loc) = 0;

    virtual DiskLoc deletedListLegacyGrabBag() const = 0;
    virtual void setDeletedListLegacyGrabBag(OperationContext* opCtx, const DiskLoc& loc) = 0;

    virtual void orphanDeletedList(OperationContext* opCtx) = 0;

    virtual const DiskLoc& firstExtent(OperationContext* opCtx) const = 0;
    virtual void setFirstExtent(OperationContext* opCtx, const DiskLoc& loc) = 0;

    virtual const DiskLoc& lastExtent(OperationContext* opCtx) const = 0;
    virtual void setLastExtent(OperationContext* opCtx, const DiskLoc& loc) = 0;

    virtual bool isCapped() const = 0;

    virtual bool isUserFlagSet(int flag) const = 0;
    virtual int userFlags() const = 0;
    virtual bool setUserFlag(OperationContext* opCtx, int flag) = 0;
    virtual bool clearUserFlag(OperationContext* opCtx, int flag) = 0;
    virtual bool replaceUserFlags(OperationContext* opCtx, int flags) = 0;

    virtual int lastExtentSize(OperationContext* opCtx) const = 0;
    virtual void setLastExtentSize(OperationContext* opCtx, int newMax) = 0;

    virtual long long maxCappedDocs() const = 0;
};

class SavedCursorRegistry {
public:
    struct SavedCursor {
        SavedCursor() : _registry(NULL) {}
        virtual ~SavedCursor() {
            if (_registry)
                _registry->unregisterCursor(this);
        }
        DiskLoc bucket;
        BSONObj key;
        DiskLoc loc;

    private:
        friend class SavedCursorRegistry;
        // Non-null iff registered. Accessed by owner or writer with MODE_X collection lock
        SavedCursorRegistry* _registry;
    };

    ~SavedCursorRegistry();

    void registerCursor(SavedCursor* cursor);

    bool unregisterCursor(SavedCursor* cursor);

    void invalidateCursorsForBucket(DiskLoc bucket);

private:
    SpinLock _mutex;
    typedef stdx::unordered_set<SavedCursor*>
        SavedCursorSet;  // SavedCursor pointers not owned here
    SavedCursorSet _cursors;
};

class RecordStoreV1Base : public RecordStore {
public:
    static const int Buckets = 26;
    static const int MaxAllowedAllocation = 16 * 1024 * 1024 + 512 * 1024;

    static const int bucketSizes[];

    // ------------

    class IntraExtentIterator;

    RecordStoreV1Base(StringData ns,
                      RecordStoreV1MetaData* details,
                      ExtentManager* em,
                      bool isSystemIndexes);

    virtual ~RecordStoreV1Base();

    const std::string& getIdent() const override {
        MONGO_UNREACHABLE;
    }

    virtual long long dataSize(OperationContext* opCtx) const {
        return _details->dataSize();
    }
    virtual long long numRecords(OperationContext* opCtx) const {
        return _details->numRecords();
    }

    virtual int64_t storageSize(OperationContext* opCtx,
                                BSONObjBuilder* extraInfo = NULL,
                                int level = 0) const;

    virtual RecordData dataFor(OperationContext* opCtx, const RecordId& loc) const;

    virtual bool findRecord(OperationContext* opCtx, const RecordId& loc, RecordData* rd) const;

    void deleteRecord(OperationContext* opCtx, const RecordId& dl);

    StatusWith<RecordId> insertRecord(
        OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota);

    Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                      const DocWriter* const* docs,
                                      const Timestamp*,
                                      size_t nDocs,
                                      RecordId* idsOut) final;

    virtual Status updateRecord(OperationContext* opCtx,
                                const RecordId& oldLocation,
                                const char* data,
                                int len,
                                bool enforceQuota,
                                UpdateNotifier* notifier);

    virtual bool updateWithDamagesSupported() const;

    virtual StatusWith<RecordData> updateWithDamages(OperationContext* opCtx,
                                                     const RecordId& loc,
                                                     const RecordData& oldRec,
                                                     const char* damageSource,
                                                     const mutablebson::DamageVector& damages);

    virtual std::unique_ptr<RecordCursor> getCursorForRepair(OperationContext* opCtx) const;

    void increaseStorageSize(OperationContext* opCtx, int size, bool enforceQuota);

    virtual Status validate(OperationContext* opCtx,
                            ValidateCmdLevel level,
                            ValidateAdaptor* adaptor,
                            ValidateResults* results,
                            BSONObjBuilder* output);

    virtual void appendCustomStats(OperationContext* opCtx,
                                   BSONObjBuilder* result,
                                   double scale) const;

    virtual Status touch(OperationContext* opCtx, BSONObjBuilder* output) const;

    const RecordStoreV1MetaData* details() const {
        return _details.get();
    }

    // This keeps track of cursors saved during yielding, for invalidation purposes.
    SavedCursorRegistry savedCursors;

    DiskLoc getExtentLocForRecord(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc getNextRecord(OperationContext* opCtx, const DiskLoc& loc) const;
    DiskLoc getPrevRecord(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc getNextRecordInExtent(OperationContext* opCtx, const DiskLoc& loc) const;
    DiskLoc getPrevRecordInExtent(OperationContext* opCtx, const DiskLoc& loc) const;

    static int quantizeAllocationSpace(int minSize);

    static bool isQuantized(int recordSize);

    /* return which "deleted bucket" for this size object */
    static int bucket(int size);

    void waitForAllEarlierOplogWritesToBeVisible(OperationContext* opCtx) const override {}

    virtual void updateStatsAfterRepair(OperationContext* opCtx,
                                        long long numRecords,
                                        long long dataSize) {
        MONGO_UNREACHABLE;  // MMAPv1 has its own repair which doesn't call this.
    }

protected:
    virtual MmapV1RecordHeader* recordFor(const DiskLoc& loc) const;

    const DeletedRecord* deletedRecordFor(const DiskLoc& loc) const;

    virtual bool isCapped() const = 0;

    virtual bool shouldPadInserts() const = 0;

    virtual StatusWith<DiskLoc> allocRecord(OperationContext* opCtx,
                                            int lengthWithHeaders,
                                            bool enforceQuota) = 0;

    // TODO: document, remove, what have you
    virtual void addDeletedRec(OperationContext* opCtx, const DiskLoc& dloc) = 0;

    // TODO: another sad one
    virtual DeletedRecord* drec(const DiskLoc& loc) const;

    // just a wrapper for _extentManager->getExtent( loc );
    Extent* _getExtent(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc _getExtentLocForRecord(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc _getNextRecord(OperationContext* opCtx, const DiskLoc& loc) const;
    DiskLoc _getPrevRecord(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc _getNextRecordInExtent(OperationContext* opCtx, const DiskLoc& loc) const;
    DiskLoc _getPrevRecordInExtent(OperationContext* opCtx, const DiskLoc& loc) const;

    DiskLoc _findFirstSpot(OperationContext* opCtx, const DiskLoc& extDiskLoc, Extent* e);

    void _addRecordToRecListInExtent(OperationContext* opCtx, MmapV1RecordHeader* r, DiskLoc loc);

    StatusWith<RecordId> _insertRecord(OperationContext* opCtx,
                                       const char* data,
                                       int len,
                                       bool enforceQuota);

    std::unique_ptr<RecordStoreV1MetaData> _details;
    ExtentManager* _extentManager;
    bool _isSystemIndexes;

    friend class RecordStoreV1RepairCursor;
};

class RecordStoreV1Base::IntraExtentIterator final : public RecordCursor {
public:
    IntraExtentIterator(OperationContext* opCtx,
                        DiskLoc start,
                        const RecordStoreV1Base* rs,
                        bool forward = true)
        : _opCtx(opCtx), _curr(start), _rs(rs), _forward(forward) {}

    boost::optional<Record> next() final;
    void invalidate(OperationContext* opCtx, const RecordId& dl) final;
    void save() final {}
    bool restore() final {
        return true;
    }
    void detachFromOperationContext() final {
        _opCtx = nullptr;
    }
    void reattachToOperationContext(OperationContext* opCtx) final {
        _opCtx = opCtx;
    }
    std::unique_ptr<RecordFetcher> fetcherForNext() const final;

private:
    virtual const MmapV1RecordHeader* recordFor(const DiskLoc& loc) const {
        return _rs->recordFor(loc);
    }

    void advance();

    OperationContext* _opCtx;
    DiskLoc _curr;
    const RecordStoreV1Base* _rs;
    bool _forward;
};
}  // namespace mongo