src/MemObject.h

   1 /*
   2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #ifndef SQUID_MEMOBJECT_H
  10 #define SQUID_MEMOBJECT_H
  11
  12 #include "CommRead.h"
  13 #include "dlink.h"
  14 #include "http/RequestMethod.h"
  15 #include "RemovalPolicy.h"
  16 #include "SquidString.h"
  17 #include "stmem.h"
  18 #include "StoreIOBuffer.h"
  19 #include "StoreIOState.h"
  20 #include "typedefs.h" //for IRCB
  21
  22 #if USE_DELAY_POOLS
  23 #include "DelayId.h"
  24 #endif
  25
  26 typedef void STMCB (void *data, StoreIOBuffer wroteBuffer);
  27 typedef void STABH(void *);
  28
  29 class store_client;
  30
  31 class MemObject
  32 {
  33     MEMPROXY_CLASS(MemObject);
  34
  35 public:
  36     static size_t inUseCount();
  37
  38     void dump() const;
  39     MemObject();
  40     ~MemObject();
  41
  42     /// Sets store ID, log URI, and request method (unless already set). Does
  43     /// not clobber the method so that, say, a HEAD hit for a GET entry keeps
  44     /// the GET method that matches the entry key. Same for the other parts of
  45     /// the trio because the entry filling code may expect them to be constant.
  46     /// XXX: Avoid this method. We plan to remove it and make the trio constant
  47     /// after addressing the XXX in MemStore::get().
  48     void setUris(char const *aStoreId, char const *aLogUri, const HttpRequestMethod &aMethod);
  49
  50     /// whether setUris() has been called
  51     bool hasUris() const;
  52
  53     void write(const StoreIOBuffer &buf);
  54     void unlinkRequest() { request = nullptr; }
  55     const HttpReplyPointer &getReply() const { return reply_; }
  56     void replaceReply(const HttpReplyPointer &r) { reply_ = r; }
  57     void stat (MemBuf * mb) const;
  58     int64_t endOffset () const;
  59     void markEndOfReplyHeaders(); ///< sets reply_->hdr_sz to endOffset()
  60     /// negative if unknown; otherwise, expected object_sz, expected endOffset
  61     /// maximum, and stored reply headers+body size (all three are the same)
  62     int64_t expectedReplySize() const;
  63     int64_t size() const;
  64     void reset();
  65     int64_t lowestMemReaderOffset() const;
  66     bool readAheadPolicyCanRead() const;
  67     void addClient(store_client *);
  68     /* XXX belongs in MemObject::swapout, once swaphdrsz is managed
  69      * better
  70      */
  71     int64_t objectBytesOnDisk() const;
  72     int64_t policyLowestOffsetToKeep(bool swap) const;
  73     int64_t availableForSwapOut() const; ///< buffered bytes we have not swapped out yet
  74     void trimSwappable();
  75     void trimUnSwappable();
  76     bool isContiguous() const;
  77     int mostBytesWanted(int max, bool ignoreDelayPools) const;
  78     void setNoDelay(bool const newValue);
  79 #if USE_DELAY_POOLS
  80     DelayId mostBytesAllowed() const;
  81 #endif
  82
  83 #if URL_CHECKSUM_DEBUG
  84
  85     void checkUrlChecksum() const;
  86 #endif
  87
  88     /// Before StoreID, code assumed that MemObject stores Request URI.
  89     /// After StoreID, some old code still incorrectly assumes that.
  90     /// Use this method to mark that incorrect assumption.
  91     const char *urlXXX() const { return storeId(); }
  92
  93     /// Entry StoreID (usually just Request URI); if a buggy code requests this
  94     /// before the information is available, returns an "[unknown_URI]" string.
  95     const char *storeId() const;
  96
  97     /// client request URI used for logging; storeId() by default
  98     const char *logUri() const;
  99
 100     HttpRequestMethod method;
 101     mem_hdr data_hdr;
 102     int64_t inmem_lo;
 103     dlink_list clients;
 104
 105     size_t clientCount() const {return nclients;}
 106
 107     bool clientIsFirst(void *sc) const {return (clients.head && sc == clients.head->data);}
 108
 109     int nclients;
 110
 111     class SwapOut
 112     {
 113     public:
 114         SwapOut() : queue_offset(0), decision(swNeedsCheck) {}
 115
 116         int64_t queue_offset; ///< number of bytes sent to SwapDir for writing
 117         StoreIOState::Pointer sio;
 118
 119         /// Decision states for StoreEntry::swapoutPossible() and related code.
 120         typedef enum { swNeedsCheck = 0, swImpossible = -1, swPossible = +1, swStarted } Decision;
 121         Decision decision; ///< current decision state
 122     };
 123
 124     SwapOut swapout;
 125
 126     /// cache "I/O" direction and status
 127     typedef enum { ioUndecided, ioWriting, ioReading, ioDone } Io;
 128
 129     /// State of an entry with regards to the [shared] in-transit table.
 130     class XitTable
 131     {
 132     public:
 133         XitTable(): index(-1), io(ioUndecided) {}
 134
 135         int32_t index; ///< entry position inside the in-transit table
 136         Io io; ///< current I/O state
 137     };
 138     XitTable xitTable; ///< current [shared] memory caching state for the entry
 139
 140     /// State of an entry with regards to the [shared] memory caching.
 141     class MemCache
 142     {
 143     public:
 144         MemCache(): index(-1), offset(0), io(ioUndecided) {}
 145
 146         int32_t index; ///< entry position inside the memory cache
 147         int64_t offset; ///< bytes written/read to/from the memory cache so far
 148
 149         Io io; ///< current I/O state
 150     };
 151     MemCache memCache; ///< current [shared] memory caching state for the entry
 152
 153     bool smpCollapsed; ///< whether this entry gets data from another worker
 154
 155     /* Read only - this reply must be preserved by store clients */
 156     /* The original reply. possibly with updated metadata. */
 157     HttpRequestPointer request;
 158
 159     struct timeval start_ping;
 160     IRCB *ping_reply_callback;
 161     void *ircb_data;
 162
 163     struct {
 164         STABH *callback;
 165         void *data;
 166     } abort;
 167     RemovalPolicyNode repl;
 168     int id;
 169     int64_t object_sz;
 170     size_t swap_hdr_sz;
 171 #if URL_CHECKSUM_DEBUG
 172
 173     unsigned int chksum;
 174 #endif
 175
 176     SBuf vary_headers;
 177
 178     void delayRead(DeferredRead const &);
 179     void kickReads();
 180
 181 private:
 182     HttpReplyPointer reply_;
 183
 184     mutable String storeId_; ///< StoreId for our entry (usually request URI)
 185     mutable String logUri_;  ///< URI used for logging (usually request URI)
 186
 187     DeferredReadManager deferredReads;
 188 };
 189
 190 /** global current memory removal policy */
 191 extern RemovalPolicy *mem_policy;
 192
 193 #endif /* SQUID_MEMOBJECT_H */
 194