MemMap.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_IPC_STORE_MAP_H
#define SQUID_IPC_STORE_MAP_H
 
#include "debug/Stream.h"
#include "ipc/mem/FlexibleArray.h"
#include "ipc/mem/Pointer.h"
#include "ipc/ReadWriteLock.h"
#include "sbuf/SBuf.h"
#include "store/forward.h"
#include "store_key_md5.h"
#include "tools.h"
 
#include <atomic>
 
namespace Ipc
{
 
// The MEMMAP_SLOT_KEY_SIZE and MEMMAP_SLOT_DATA_SIZE must be enough big
// to hold cached keys and data. Currently MemMap used only to store SSL
// shared session data which have keys of 32bytes and at most 10K data
#define MEMMAP_SLOT_KEY_SIZE 32
#define MEMMAP_SLOT_DATA_SIZE 10*1024
 
class MemMapSlot
{
public:
    MemMapSlot();
    size_t size() const {return sizeof(MemMapSlot);}
    size_t keySize() const {return sizeof(key);}
    bool sameKey(const cache_key *const aKey) const;
    void set(const unsigned char *aKey, const void *block, size_t blockSize, time_t expire = 0);
    bool empty() const;
    bool reading() const { return lock.readers; }
    bool writing() const { return lock.writing; }
 
    std::atomic<uint8_t> waitingToBeFreed; 
    mutable ReadWriteLock lock; 
    unsigned char key[MEMMAP_SLOT_KEY_SIZE]; 
    unsigned char p[MEMMAP_SLOT_DATA_SIZE]; 
    size_t pSize;
    time_t expire;
};
 
class MemMapCleaner;
 
class MemMap
{
public:
    typedef MemMapSlot Slot;
 
    class Shared
    {
    public:
        Shared(const int aLimit, const size_t anExtrasSize);
        size_t sharedMemorySize() const;
        static size_t SharedMemorySize(const int limit, const size_t anExtrasSize);
        ~Shared();
 
        const int limit; 
        const size_t extrasSize; 
        std::atomic<int> count; 
        Ipc::Mem::FlexibleArray<Slot> slots; 
    };
 
public:
    typedef Mem::Owner<Shared> Owner;
 
    static Owner *Init(const char *const path, const int limit);
 
    MemMap(const char *const aPath);
 
    Slot *openForWriting(const cache_key *const key, sfileno &fileno);
 
    Slot *openForWritingAt(sfileno fileno, bool overwriteExisting = true);
 
    void closeForWriting(const sfileno fileno);
 
    void switchWritingToReading(const sfileno fileno);
 
    const Slot *peekAtReader(const sfileno fileno) const;
 
    void free(const sfileno fileno);
 
    const Slot *openForReading(const cache_key *const key, sfileno &fileno);
 
    const Slot *openForReadingAt(const sfileno fileno);
 
    void closeForReading(const sfileno fileno);
 
    bool full() const; 
    bool valid(const int n) const; 
    int entryCount() const; 
    int entryLimit() const; 
 
    void updateStats(ReadWriteLockStats &stats) const;
 
    MemMapCleaner *cleaner;
 
protected:
    static Owner *Init(const char *const path, const int limit, const size_t extrasSize);
 
    const SBuf path; 
    Mem::Pointer<Shared> shared;
 
private:
    int slotIndexByKey(const cache_key *const key) const;
    Slot &slotByKey(const cache_key *const key);
 
    Slot *openForReading(Slot &s);
    void abortWriting(const sfileno fileno);
    void freeIfNeeded(Slot &s);
    void freeLocked(Slot &s, bool keepLocked);
};
 
class MemMapCleaner
{
public:
    virtual ~MemMapCleaner() {}
 
    virtual void noteFreeMapSlot(const sfileno slotId) = 0;
};
 
} // namespace Ipc
 
#endif /* SQUID_IPC_STORE_MAP_H */