src/store_swapout.cc

   1
   2 /*
   3  * DEBUG: section 20    Storage Manager Swapout Functions
   4  * AUTHOR: Duane Wessels
   5  *
   6  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   7  * ----------------------------------------------------------
   8  *
   9  *  Squid is the result of efforts by numerous individuals from
  10  *  the Internet community; see the CONTRIBUTORS file for full
  11  *  details.   Many organizations have provided support for Squid's
  12  *  development; see the SPONSORS file for full details.  Squid is
  13  *  Copyrighted (C) 2001 by the Regents of the University of
  14  *  California; see the COPYRIGHT file for full details.  Squid
  15  *  incorporates software developed and/or copyrighted by other
  16  *  sources; see the CREDITS file for full details.
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License as published by
  20  *  the Free Software Foundation; either version 2 of the License, or
  21  *  (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  31  *
  32  */
  33
  34 #include "squid.h"
  35 #include "cbdata.h"
  36 #include "globals.h"
  37 #include "Store.h"
  38 #include "StoreClient.h"
  39 /* FIXME: Abstract the use of this more */
  40 #include "mem_node.h"
  41 #include "MemObject.h"
  42 #include "SquidConfig.h"
  43 #include "StatCounters.h"
  44 #include "store_log.h"
  45 #include "swap_log_op.h"
  46 #include "SwapDir.h"
  47
  48 static void storeSwapOutStart(StoreEntry * e);
  49 static StoreIOState::STIOCB storeSwapOutFileClosed;
  50 static StoreIOState::STFNCB storeSwapOutFileNotify;
  51
  52 // wrapper to cross C/C++ ABI boundary. xfree is extern "C" for libraries.
  53 static void xfree_cppwrapper(void *x)
  54 {
  55     xfree(x);
  56 }
  57
  58 /* start swapping object to disk */
  59 static void
  60 storeSwapOutStart(StoreEntry * e)
  61 {
  62     MemObject *mem = e->mem_obj;
  63     StoreIOState::Pointer sio;
  64     assert(mem);
  65     /* Build the swap metadata, so the filesystem will know how much
  66      * metadata there is to store
  67      */
  68     debugs(20, 5, "storeSwapOutStart: Begin SwapOut '" << e->url() << "' to dirno " <<
  69            e->swap_dirn << ", fileno " << std::hex << std::setw(8) << std::setfill('0') <<
  70            std::uppercase << e->swap_filen);
  71     e->swap_status = SWAPOUT_WRITING;
  72     mem->swapout.decision = MemObject::SwapOut::swStarted;
  73     /* If we start swapping out objects with OutOfBand Metadata,
  74      * then this code needs changing
  75      */
  76
  77     /* TODO: make some sort of data,size refcounted immutable buffer
  78      * and stop fooling ourselves with "const char*" buffers.
  79      */
  80
  81     // Create metadata now, possibly in vain: storeCreate needs swap_hdr_sz.
  82     const char *buf = e->getSerialisedMetaData ();
  83     assert(buf);
  84
  85     /* Create the swap file */
  86     generic_cbdata *c = new generic_cbdata(e);
  87     sio = storeCreate(e, storeSwapOutFileNotify, storeSwapOutFileClosed, c);
  88
  89     if (sio == NULL) {
  90         e->swap_status = SWAPOUT_NONE;
  91         mem->swapout.decision = MemObject::SwapOut::swImpossible;
  92         delete c;
  93         xfree((char*)buf);
  94         storeLog(STORE_LOG_SWAPOUTFAIL, e);
  95         return;
  96     }
  97
  98     mem->swapout.sio = sio;
  99     /* Don't lock until after create, or the replacement
 100      * code might get confused */
 101
 102     e->lock("storeSwapOutStart");
 103     /* Pick up the file number if it was assigned immediately */
 104     e->swap_filen = mem->swapout.sio->swap_filen;
 105
 106     e->swap_dirn = mem->swapout.sio->swap_dirn;
 107
 108     /* write out the swap metadata */
 109     storeIOWrite(mem->swapout.sio, buf, mem->swap_hdr_sz, 0, xfree_cppwrapper);
 110 }
 111
 112 static void
 113 storeSwapOutFileNotify(void *data, int errflag, StoreIOState::Pointer self)
 114 {
 115     generic_cbdata *c = (generic_cbdata *)data;
 116     StoreEntry *e = (StoreEntry *)c->data;
 117     MemObject *mem = e->mem_obj;
 118     assert(e->swap_status == SWAPOUT_WRITING);
 119     assert(mem);
 120     assert(mem->swapout.sio == self);
 121     assert(errflag == 0);
 122     assert(e->swap_filen < 0); // if this fails, call SwapDir::disconnect(e)
 123     e->swap_filen = mem->swapout.sio->swap_filen;
 124     e->swap_dirn = mem->swapout.sio->swap_dirn;
 125 }
 126
 127 static bool
 128 doPages(StoreEntry *anEntry)
 129 {
 130     MemObject *mem = anEntry->mem_obj;
 131
 132     do {
 133         // find the page containing the first byte we have not swapped out yet
 134         mem_node *page =
 135             mem->data_hdr.getBlockContainingLocation(mem->swapout.queue_offset);
 136
 137         if (!page)
 138             break; // wait for more data to become available
 139
 140         // memNodeWriteComplete() and absence of buffer offset math below
 141         // imply that we always write from the very beginning of the page
 142         assert(page->start() == mem->swapout.queue_offset);
 143
 144         /*
 145          * Get the length of this buffer. We are assuming(!) that the buffer
 146          * length won't change on this buffer, or things are going to be very
 147          * strange. I think that after the copy to a buffer is done, the buffer
 148          * size should stay fixed regardless so that this code isn't confused,
 149          * but we can look at this at a later date or whenever the code results
 150          * in bad swapouts, whichever happens first. :-)
 151          */
 152         ssize_t swap_buf_len = page->nodeBuffer.length;
 153
 154         debugs(20, 3, "storeSwapOut: swap_buf_len = " << swap_buf_len);
 155
 156         assert(swap_buf_len > 0);
 157
 158         debugs(20, 3, "storeSwapOut: swapping out " << swap_buf_len << " bytes from " << mem->swapout.queue_offset);
 159
 160         mem->swapout.queue_offset += swap_buf_len;
 161
 162         // Quit if write() fails. Sio is going to call our callback, and that
 163         // will cleanup, but, depending on the fs, that call may be async.
 164         const bool ok = mem->swapout.sio->write(
 165                             mem->data_hdr.NodeGet(page),
 166                             swap_buf_len,
 167                             -1,
 168                             memNodeWriteComplete);
 169
 170         if (!ok || anEntry->swap_status != SWAPOUT_WRITING)
 171             return false;
 172
 173         int64_t swapout_size = mem->endOffset() - mem->swapout.queue_offset;
 174
 175         if (anEntry->store_status == STORE_PENDING)
 176             if (swapout_size < SM_PAGE_SIZE)
 177                 break;
 178
 179         if (swapout_size <= 0)
 180             break;
 181     } while (true);
 182
 183     // either wait for more data or call swapOutFileClose()
 184     return true;
 185 }
 186
 187 /* This routine is called every time data is sent to the client side.
 188  * It's overhead is therefor, significant.
 189  */
 190 void
 191 StoreEntry::swapOut()
 192 {
 193     if (!mem_obj)
 194         return;
 195
 196     // this flag may change so we must check even if we are swappingOut
 197     if (EBIT_TEST(flags, ENTRY_ABORTED)) {
 198         assert(EBIT_TEST(flags, RELEASE_REQUEST));
 199         // StoreEntry::abort() already closed the swap out file, if any
 200         // no trimming: data producer must stop production if ENTRY_ABORTED
 201         return;
 202     }
 203
 204     const bool weAreOrMayBeSwappingOut = swappingOut() || mayStartSwapOut();
 205
 206     Store::Root().memoryOut(*this, weAreOrMayBeSwappingOut);
 207
 208     if (mem_obj->swapout.decision < MemObject::SwapOut::swPossible)
 209         return; // nothing else to do
 210
 211     // Aborted entries have STORE_OK, but swapoutPossible rejects them. Thus,
 212     // store_status == STORE_OK below means we got everything we wanted.
 213
 214     debugs(20, 7, HERE << "storeSwapOut: mem->inmem_lo = " << mem_obj->inmem_lo);
 215     debugs(20, 7, HERE << "storeSwapOut: mem->endOffset() = " << mem_obj->endOffset());
 216     debugs(20, 7, HERE << "storeSwapOut: swapout.queue_offset = " << mem_obj->swapout.queue_offset);
 217
 218     if (mem_obj->swapout.sio != NULL)
 219         debugs(20, 7, "storeSwapOut: storeOffset() = " << mem_obj->swapout.sio->offset()  );
 220
 221     int64_t const lowest_offset = mem_obj->lowestMemReaderOffset();
 222
 223     debugs(20, 7, HERE << "storeSwapOut: lowest_offset = " << lowest_offset);
 224
 225 #if SIZEOF_OFF_T <= 4
 226
 227     if (mem_obj->endOffset() > 0x7FFF0000) {
 228         debugs(20, DBG_CRITICAL, "WARNING: preventing off_t overflow for " << url());
 229         abort();
 230         return;
 231     }
 232
 233 #endif
 234     if (swap_status == SWAPOUT_WRITING)
 235         assert(mem_obj->inmem_lo <=  mem_obj->objectBytesOnDisk() );
 236
 237     // buffered bytes we have not swapped out yet
 238     const int64_t swapout_maxsize = mem_obj->availableForSwapOut();
 239     assert(swapout_maxsize >= 0);
 240     debugs(20, 7, "storeSwapOut: swapout_size = " << swapout_maxsize);
 241
 242     if (swapout_maxsize == 0) { // swapped everything we got
 243         if (store_status == STORE_OK) { // got everything we wanted
 244             assert(mem_obj->object_sz >= 0);
 245             swapOutFileClose(StoreIOState::wroteAll);
 246         }
 247         // else need more data to swap out
 248         return;
 249     }
 250
 251     if (store_status == STORE_PENDING) {
 252         /* wait for a full block to write */
 253
 254         if (swapout_maxsize < SM_PAGE_SIZE)
 255             return;
 256
 257         /*
 258          * Wait until we are below the disk FD limit, only if the
 259          * next server-side read won't be deferred.
 260          */
 261         if (storeTooManyDiskFilesOpen() && !checkDeferRead(-1))
 262             return;
 263     }
 264
 265     /* Ok, we have stuff to swap out.  Is there a swapout.sio open? */
 266     if (swap_status == SWAPOUT_NONE) {
 267         assert(mem_obj->swapout.sio == NULL);
 268         assert(mem_obj->inmem_lo == 0);
 269         storeSwapOutStart(this); // sets SwapOut::swImpossible on failures
 270     }
 271
 272     if (mem_obj->swapout.sio == NULL)
 273         return;
 274
 275     if (!doPages(this))
 276         /* oops, we're not swapping out any more */
 277         return;
 278
 279     if (store_status == STORE_OK) {
 280         /*
 281          * If the state is STORE_OK, then all data must have been given
 282          * to the filesystem at this point because storeSwapOut() is
 283          * not going to be called again for this entry.
 284          */
 285         assert(mem_obj->object_sz >= 0);
 286         assert(mem_obj->endOffset() == mem_obj->swapout.queue_offset);
 287         swapOutFileClose(StoreIOState::wroteAll);
 288     }
 289 }
 290
 291 void
 292 StoreEntry::swapOutFileClose(int how)
 293 {
 294     assert(mem_obj != NULL);
 295     debugs(20, 3, "storeSwapOutFileClose: " << getMD5Text() << " how=" << how);
 296     debugs(20, 3, "storeSwapOutFileClose: sio = " << mem_obj->swapout.sio.getRaw());
 297
 298     if (mem_obj->swapout.sio == NULL)
 299         return;
 300
 301     storeClose(mem_obj->swapout.sio, how);
 302 }
 303
 304 static void
 305 storeSwapOutFileClosed(void *data, int errflag, StoreIOState::Pointer self)
 306 {
 307     generic_cbdata *c = (generic_cbdata *)data;
 308     StoreEntry *e = (StoreEntry *)c->data;
 309     MemObject *mem = e->mem_obj;
 310     assert(mem->swapout.sio == self);
 311     assert(e->swap_status == SWAPOUT_WRITING);
 312     cbdataFree(c);
 313
 314     // if object_size is still unknown, the entry was probably aborted
 315     if (errflag || e->objectLen() < 0) {
 316         debugs(20, 2, "storeSwapOutFileClosed: dirno " << e->swap_dirn << ", swapfile " <<
 317                std::hex << std::setw(8) << std::setfill('0') << std::uppercase <<
 318                e->swap_filen << ", errflag=" << errflag);
 319
 320         if (errflag == DISK_NO_SPACE_LEFT) {
 321             /* FIXME: this should be handle by the link from store IO to
 322              * Store, rather than being a top level API call.
 323              */
 324             e->store()->diskFull();
 325             storeConfigure();
 326         }
 327
 328         if (e->swap_filen >= 0)
 329             e->unlink();
 330
 331         assert(e->swap_status == SWAPOUT_NONE);
 332
 333         e->releaseRequest();
 334     } else {
 335         /* swapping complete */
 336         debugs(20, 3, "storeSwapOutFileClosed: SwapOut complete: '" << e->url() << "' to " <<
 337                e->swap_dirn  << ", " << std::hex << std::setw(8) << std::setfill('0') <<
 338                std::uppercase << e->swap_filen);
 339         debugs(20, 5, HERE << "swap_file_sz = " <<
 340                e->objectLen() << " + " << mem->swap_hdr_sz);
 341
 342         e->swap_file_sz = e->objectLen() + mem->swap_hdr_sz;
 343         e->swap_status = SWAPOUT_DONE;
 344         e->store()->swappedOut(*e);
 345
 346         // XXX: For some Stores, it is pointless to re-check cachability here
 347         // and it leads to double counts in store_check_cachable_hist. We need
 348         // another way to signal a completed but failed swapout. Or, better,
 349         // each Store should handle its own logging and LOG state setting.
 350         if (e->checkCachable()) {
 351             storeLog(STORE_LOG_SWAPOUT, e);
 352             storeDirSwapLog(e, SWAP_LOG_ADD);
 353         }
 354
 355         ++statCounter.swap.outs;
 356     }
 357
 358     debugs(20, 3, "storeSwapOutFileClosed: " << __FILE__ << ":" << __LINE__);
 359     mem->swapout.sio = NULL;
 360     e->unlock("storeSwapOutFileClosed");
 361 }
 362
 363 bool
 364 StoreEntry::mayStartSwapOut()
 365 {
 366     // must be checked in the caller
 367     assert(!EBIT_TEST(flags, ENTRY_ABORTED));
 368     assert(!swappingOut());
 369
 370     if (!Config.cacheSwap.n_configured)
 371         return false;
 372
 373     assert(mem_obj);
 374     MemObject::SwapOut::Decision &decision = mem_obj->swapout.decision;
 375
 376     // if we decided that starting is not possible, do not repeat same checks
 377     if (decision == MemObject::SwapOut::swImpossible) {
 378         debugs(20, 3, HERE << " already rejected");
 379         return false;
 380     }
 381
 382     // if we swapped out already, do not start over
 383     if (swap_status == SWAPOUT_DONE) {
 384         debugs(20, 3, "already did");
 385         decision = MemObject::SwapOut::swImpossible;
 386         return false;
 387     }
 388
 389     // if we stared swapping out already, do not start over
 390     if (decision == MemObject::SwapOut::swStarted) {
 391         debugs(20, 3, "already started");
 392         decision = MemObject::SwapOut::swImpossible;
 393         return false;
 394     }
 395
 396     // if we decided that swapout is possible, do not repeat same checks
 397     if (decision == MemObject::SwapOut::swPossible) {
 398         debugs(20, 3, "already allowed");
 399         return true;
 400     }
 401
 402     if (!checkCachable()) {
 403         debugs(20, 3,  HERE << "not cachable");
 404         decision = MemObject::SwapOut::swImpossible;
 405         return false;
 406     }
 407
 408     if (EBIT_TEST(flags, ENTRY_SPECIAL)) {
 409         debugs(20, 3,  HERE  << url() << " SPECIAL");
 410         decision = MemObject::SwapOut::swImpossible;
 411         return false;
 412     }
 413
 414     if (mem_obj->inmem_lo > 0) {
 415         debugs(20, 3, "storeSwapOut: (inmem_lo > 0)  imem_lo:" <<  mem_obj->inmem_lo);
 416         decision = MemObject::SwapOut::swImpossible;
 417         return false;
 418     }
 419
 420     if (!mem_obj->isContiguous()) {
 421         debugs(20, 3, "storeSwapOut: not Contiguous");
 422         decision = MemObject::SwapOut::swImpossible;
 423         return false;
 424     }
 425
 426     // check cache_dir max-size limit if all cache_dirs have it
 427     if (store_maxobjsize >= 0) {
 428         // TODO: add estimated store metadata size to be conservative
 429
 430         // use guaranteed maximum if it is known
 431         const int64_t expectedEnd = mem_obj->expectedReplySize();
 432         debugs(20, 7,  HERE << "expectedEnd = " << expectedEnd);
 433         if (expectedEnd > store_maxobjsize) {
 434             debugs(20, 3,  HERE << "will not fit: " << expectedEnd <<
 435                    " > " << store_maxobjsize);
 436             decision = MemObject::SwapOut::swImpossible;
 437             return false; // known to outgrow the limit eventually
 438         }
 439
 440         // use current minimum (always known)
 441         const int64_t currentEnd = mem_obj->endOffset();
 442         if (currentEnd > store_maxobjsize) {
 443             debugs(20, 3,  HERE << "does not fit: " << currentEnd <<
 444                    " > " << store_maxobjsize);
 445             decision = MemObject::SwapOut::swImpossible;
 446             return false; // already does not fit and may only get bigger
 447         }
 448
 449         // prevent final default swPossible answer for yet unknown length
 450         if (expectedEnd < 0 && store_status != STORE_OK) {
 451             const int64_t maxKnownSize = mem_obj->availableForSwapOut();
 452             debugs(20, 7, HERE << "maxKnownSize= " << maxKnownSize);
 453             /*
 454              * NOTE: the store_maxobjsize here is the global maximum
 455              * size of object cacheable in any of Squid cache stores
 456              * both disk and memory stores.
 457              *
 458              * However, I am worried that this
 459              * deferance may consume a lot of memory in some cases.
 460              * Should we add an option to limit this memory consumption?
 461              */
 462             debugs(20, 5,  HERE << "Deferring swapout start for " <<
 463                    (store_maxobjsize - maxKnownSize) << " bytes");
 464             return true; // may still fit, but no final decision yet
 465         }
 466     }
 467
 468     decision = MemObject::SwapOut::swPossible;
 469     return true;
 470 }