MemObject.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_MEMOBJECT_H
#define SQUID_MEMOBJECT_H
 
#include "base/DelayedAsyncCalls.h"
#include "dlink.h"
#include "http/RequestMethod.h"
#include "HttpReply.h"
#include "RemovalPolicy.h"
#include "SquidString.h"
#include "stmem.h"
#include "store/forward.h"
#include "StoreIOBuffer.h"
#include "StoreIOState.h"
#include "typedefs.h" //for IRCB
 
#if USE_DELAY_POOLS
#include "DelayId.h"
#endif
 
typedef void STMCB (void *data, StoreIOBuffer wroteBuffer);
 
class store_client;
class PeerSelector;
 
class MemObject
{
    MEMPROXY_CLASS(MemObject);
 
public:
    static size_t inUseCount();
 
    void dump() const;
    MemObject();
    ~MemObject();
 
    void setUris(char const *aStoreId, char const *aLogUri, const HttpRequestMethod &aMethod);
 
    bool hasUris() const;
 
    void write(const StoreIOBuffer &buf);
    void unlinkRequest() { request = nullptr; }
 
    const HttpReply &baseReply() const { return *reply_; }
 
    const HttpReplyPointer &updatedReply() const { return updatedReply_; }
 
    const HttpReply &freshestReply() const {
        if (updatedReply_)
            return *updatedReply_;
        else
            return baseReply();
    }
 
    HttpReply &adjustableBaseReply();
 
    void replaceBaseReply(const HttpReplyPointer &r);
 
    void updateReply(const HttpReply &r) { updatedReply_ = &r; }
 
    bool appliedUpdates = false;
 
    void stat (MemBuf * mb) const;
 
    int64_t endOffset () const;
 
    void markEndOfReplyHeaders();
 
    int64_t expectedReplySize() const;
    int64_t size() const;
    void reset();
    int64_t lowestMemReaderOffset() const;
    bool readAheadPolicyCanRead() const;
    void addClient(store_client *);
    /* XXX belongs in MemObject::swapout, once swaphdrsz is managed
     * better
     */
    int64_t objectBytesOnDisk() const;
    int64_t policyLowestOffsetToKeep(bool swap) const;
    int64_t availableForSwapOut() const; 
    void trimSwappable();
    void trimUnSwappable();
    bool isContiguous() const;
    int mostBytesWanted(int max, bool ignoreDelayPools) const;
    void setNoDelay(bool const newValue);
#if USE_DELAY_POOLS
    DelayId mostBytesAllowed() const;
#endif
 
#if URL_CHECKSUM_DEBUG
 
    void checkUrlChecksum() const;
#endif
 
    const char *urlXXX() const { return storeId(); }
 
    const char *storeId() const;
 
    const char *logUri() const;
 
    HttpRequestMethod method;
    mem_hdr data_hdr;
    int64_t inmem_lo = 0;
    dlink_list clients;
 
    size_t clientCount() const {return nclients;}
 
    bool clientIsFirst(void *sc) const {return (clients.head && sc == clients.head->data);}
 
    int nclients = 0;
 
    class SwapOut
    {
    public:
        int64_t queue_offset = 0; 
        StoreIOState::Pointer sio;
 
        typedef enum { swNeedsCheck = 0, swImpossible = -1, swPossible = +1, swStarted } Decision;
        Decision decision = swNeedsCheck; 
    };
 
    SwapOut swapout;
 
    /* TODO: Remove this change-minimizing hack */
    using Io = Store::IoStatus;
    static constexpr Io ioUndecided = Store::ioUndecided;
    static constexpr Io ioReading = Store::ioReading;
    static constexpr Io ioWriting = Store::ioWriting;
    static constexpr Io ioDone = Store::ioDone;
 
    class XitTable
    {
    public:
        void open(const int32_t anIndex, const Io anIo)
        {
            index = anIndex;
            io = anIo;
        }
 
        void close()
        {
            index = -1;
            io = Store::ioDone;
        }
 
        int32_t index = -1; 
        Io io = ioUndecided; 
    };
    XitTable xitTable; 
 
    class MemCache
    {
    public:
        int32_t index = -1; 
        int64_t offset = 0; 
 
        Io io = ioUndecided; 
    };
    MemCache memCache; 
 
    HttpRequestPointer request;
 
    struct timeval start_ping;
    IRCB *ping_reply_callback;
    PeerSelector *ircb_data = nullptr;
 
    AsyncCallPointer abortCallback;
    RemovalPolicyNode repl;
    int id = 0;
    int64_t object_sz = -1;
    size_t swap_hdr_sz = 0;
#if URL_CHECKSUM_DEBUG
    unsigned int chksum = 0;
#endif
 
    SBuf vary_headers;
 
    void delayRead(const AsyncCallPointer &);
    void kickReads();
 
private:
    HttpReplyPointer reply_; 
    HttpReplyPointer updatedReply_; 
 
    mutable String storeId_; 
    mutable String logUri_;  
 
    DelayedAsyncCalls deferredReads;
};
 
extern RemovalPolicy *mem_policy;
 
#endif /* SQUID_MEMOBJECT_H */