RockRebuild.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_FS_ROCK_REBUILD_H
#define SQUID_FS_ROCK_REBUILD_H
 
#include "base/AsyncJob.h"
#include "base/RunnersRegistry.h"
#include "cbdata.h"
#include "fs/rock/forward.h"
#include "ipc/mem/Pointer.h"
#include "ipc/StoreMap.h"
#include "MemBuf.h"
#include "store_rebuild.h"
 
namespace Rock
{
 
class LoadingEntry;
class LoadingSlot;
class LoadingParts;
 
class Rebuild: public AsyncJob, private IndependentRunner
{
    CBDATA_CHILD(Rebuild);
 
public:
    class Stats
    {
    public:
        static SBuf Path(const char *dirPath);
        static Ipc::Mem::Owner<Stats> *Init(const SwapDir &);
 
        static size_t SharedMemorySize() { return sizeof(Stats); }
        size_t sharedMemorySize() const { return SharedMemorySize(); }
 
        bool completed(const SwapDir &) const;
 
        StoreRebuildData counts;
    };
 
    static bool Start(SwapDir &dir);
 
protected:
    static bool IsResponsible(const SwapDir &);
 
    Rebuild(SwapDir *dir, const Ipc::Mem::Pointer<Stats> &);
    ~Rebuild() override;
 
    /* Registered Runner API */
    void startShutdown() override;
 
    /* AsyncJob API */
    void start() override;
    bool doneAll() const override;
    void swanSong() override;
 
    bool doneLoading() const;
    bool doneValidating() const;
 
private:
    void checkpoint();
    void steps();
    void loadingSteps();
    void validationSteps();
    void loadOneSlot();
    void validateOneEntry(const sfileno fileNo);
    void validateOneSlot(const SlotId slotId);
    bool importEntry(Ipc::StoreMapAnchor &anchor, const sfileno slotId, const DbCellHeader &header);
    void freeBadEntry(const sfileno fileno, const char *eDescription);
 
    void failure(const char *msg, int errNo = 0);
 
    LoadingEntry loadingEntry(const sfileno fileNo);
    void startNewEntry(const sfileno fileno, const SlotId slotId, const DbCellHeader &header);
    void primeNewEntry(Ipc::StoreMapAnchor &anchor, const sfileno fileno, const DbCellHeader &header);
    void finalizeOrFree(const sfileno fileNo, LoadingEntry &le);
    void finalizeOrThrow(const sfileno fileNo, LoadingEntry &le);
    void addSlotToEntry(const sfileno fileno, const SlotId slotId, const DbCellHeader &header);
    void useNewSlot(const SlotId slotId, const DbCellHeader &header);
 
    LoadingSlot loadingSlot(const SlotId slotId);
    void mapSlot(const SlotId slotId, const DbCellHeader &header);
    void freeUnusedSlot(const SlotId slotId, const bool invalid);
    void freeSlot(const SlotId slotId, const bool invalid);
 
    template <class SlotIdType>
    void chainSlots(SlotIdType &from, const SlotId to);
 
    bool sameEntry(const sfileno fileno, const DbCellHeader &header) const;
 
    SBuf progressDescription() const;
 
    SwapDir *sd;
    LoadingParts *parts; 
 
    Ipc::Mem::Pointer<Stats> stats; 
 
    int64_t dbSize;
    int dbSlotSize; 
    int64_t dbSlotLimit; 
    int64_t dbEntryLimit; 
 
    int fd; // store db file descriptor
    int64_t dbOffset; // TODO: calculate in a method, using loadingPos
    int64_t loadingPos; 
    int64_t validationPos; 
    MemBuf buf; 
 
    StoreRebuildData &counts; 
 
    const bool resuming;
 
    static void Steps(void *data);
};
 
} // namespace Rock
 
#endif /* SQUID_FS_ROCK_REBUILD_H */