/*
- * $Id: store_swapout.cc,v 1.109 2007/04/17 05:40:18 wessels Exp $
+ * $Id: store_swapout.cc,v 1.110 2007/04/17 23:05:17 wessels Exp $
*
* DEBUG: section 20 Storage Manager Swapout Functions
* AUTHOR: Duane Wessels
* It's overhead is therefor, significant.
*/
void
-storeSwapOut(StoreEntry * e)
+StoreEntry::swapOut()
{
- if (!e->mem_obj)
+ if (!mem_obj)
return;
- if (!e->swapoutPossible())
+ if (!swapoutPossible())
return;
- MemObject *mem = e->mem_obj;
-
- debug(20, 7) ("storeSwapOut: mem->inmem_lo = %d\n",
- (int) mem->inmem_lo);
+ debug(20, 7) ("storeSwapOut: mem_obj->inmem_lo = %d\n",
+ (int) mem_obj->inmem_lo);
- debug(20, 7) ("storeSwapOut: mem->endOffset() = %d\n",
- (int) mem->endOffset());
+ debug(20, 7) ("storeSwapOut: mem_obj->endOffset() = %d\n",
+ (int) mem_obj->endOffset());
debug(20, 7) ("storeSwapOut: swapout.queue_offset = %d\n",
- (int) mem->swapout.queue_offset);
+ (int) mem_obj->swapout.queue_offset);
- if (mem->swapout.sio.getRaw())
+ if (mem_obj->swapout.sio.getRaw())
debug(20, 7) ("storeSwapOut: storeOffset() = %d\n",
- (int) mem->swapout.sio->offset());
+ (int) mem_obj->swapout.sio->offset());
- ssize_t swapout_maxsize = (ssize_t) (mem->endOffset() - mem->swapout.queue_offset);
+ ssize_t swapout_maxsize = (ssize_t) (mem_obj->endOffset() - mem_obj->swapout.queue_offset);
assert(swapout_maxsize >= 0);
- off_t const lowest_offset = mem->lowestMemReaderOffset();
+ off_t const lowest_offset = mem_obj->lowestMemReaderOffset();
debug(20, 7) ("storeSwapOut: lowest_offset = %d\n",
(int) lowest_offset);
* Grab the swapout_size and check to see whether we're going to defer
* the swapout based upon size
*/
- if ((e->store_status != STORE_OK) && (swapout_maxsize < store_maxobjsize)) {
+ if ((store_status != STORE_OK) && (swapout_maxsize < store_maxobjsize)) {
/*
* NOTE: the store_maxobjsize here is the max of optional
* max-size values from 'cache_dir' lines. It is not the
return;
}
- e->trimMemory();
+ trimMemory();
#if SIZEOF_OFF_T == 4
- if (mem->endOffset() > 0x7FFF0000) {
+ if (mem_obj->endOffset() > 0x7FFF0000) {
debug(20, 0) ("WARNING: preventing off_t overflow for %s\n", storeUrl(e));
storeAbort(e);
return;
}
#endif
- if (e->swap_status == SWAPOUT_WRITING)
- assert(mem->inmem_lo <= (off_t)mem->objectBytesOnDisk() );
+ if (swap_status == SWAPOUT_WRITING)
+ assert(mem_obj->inmem_lo <= (off_t)mem_obj->objectBytesOnDisk() );
- if (!storeSwapOutAble(e))
+ if (!swapOutAble())
return;
debug(20, 7) ("storeSwapOut: swapout_size = %d\n",
(int) swapout_maxsize);
if (swapout_maxsize == 0) {
- if (e->store_status == STORE_OK)
- storeSwapOutFileClose(e);
+ if (store_status == STORE_OK)
+ swapOutFileClose();
return; /* Nevermore! */
}
- if (e->store_status == STORE_PENDING) {
+ if (store_status == STORE_PENDING) {
/* wait for a full block to write */
if (swapout_maxsize < SM_PAGE_SIZE)
* Wait until we are below the disk FD limit, only if the
* next server-side read won't be deferred.
*/
- if (storeTooManyDiskFilesOpen() && !e->checkDeferRead(-1))
+ if (storeTooManyDiskFilesOpen() && !checkDeferRead(-1))
return;
}
/* Ok, we have stuff to swap out. Is there a swapout.sio open? */
- if (e->swap_status == SWAPOUT_NONE) {
- assert(mem->swapout.sio == NULL);
- assert(mem->inmem_lo == 0);
+ if (swap_status == SWAPOUT_NONE) {
+ assert(mem_obj->swapout.sio == NULL);
+ assert(mem_obj->inmem_lo == 0);
- if (storeCheckCachable(e))
- storeSwapOutStart(e);
+ if (storeCheckCachable(this))
+ storeSwapOutStart(this);
else
return;
/* ENTRY_CACHABLE will be cleared and we'll never get here again */
}
- if (mem->swapout.sio == NULL)
+ if (mem_obj->swapout.sio == NULL)
return;
- doPages(e);
+ doPages(this);
- if (NULL == mem->swapout.sio.getRaw())
+ if (NULL == mem_obj->swapout.sio.getRaw())
/* oops, we're not swapping out any more */
return;
- if (e->store_status == STORE_OK) {
+ if (store_status == STORE_OK) {
/*
* If the state is STORE_OK, then all data must have been given
* to the filesystem at this point because storeSwapOut() is
* not going to be called again for this entry.
*/
- assert(mem->endOffset() == mem->swapout.queue_offset);
- storeSwapOutFileClose(e);
+ assert(mem_obj->endOffset() == mem_obj->swapout.queue_offset);
+ swapOutFileClose();
}
}
void
-storeSwapOutFileClose(StoreEntry * e)
+StoreEntry::swapOutFileClose()
{
- MemObject *mem = e->mem_obj;
- assert(mem != NULL);
- debug(20, 3) ("storeSwapOutFileClose: %s\n", e->getMD5Text());
- debug(20, 3) ("storeSwapOutFileClose: sio = %p\n", mem->swapout.sio.getRaw());
+ assert(mem_obj != NULL);
+ debug(20, 3) ("storeSwapOutFileClose: %s\n", getMD5Text());
+ debug(20, 3) ("storeSwapOutFileClose: sio = %p\n", mem_obj->swapout.sio.getRaw());
- if (mem->swapout.sio == NULL)
+ if (mem_obj->swapout.sio == NULL)
return;
- storeClose(mem->swapout.sio);
+ storeClose(mem_obj->swapout.sio);
}
static void
/*
* Is this entry a candidate for writing to disk?
*/
-int
-storeSwapOutAble(const StoreEntry * e)
+bool
+StoreEntry::swapOutAble() const
{
dlink_node *node;
- if (e->mem_obj->swapout.sio.getRaw() != NULL)
- return 1;
+ if (mem_obj->swapout.sio.getRaw() != NULL)
+ return true;
- if (e->mem_obj->inmem_lo > 0)
- return 0;
+ if (mem_obj->inmem_lo > 0)
+ return false;
/*
* If there are DISK clients, we must write to disk
* RBC 20030708: We can use disk to avoid mem races, so this shouldn't be
* an assert.
*/
- for (node = e->mem_obj->clients.head; node; node = node->next) {
+ for (node = mem_obj->clients.head; node; node = node->next) {
if (((store_client *) node->data)->getType() == STORE_DISK_CLIENT)
- return 1;
+ return true;
}
/* Don't pollute the disk with icons and other special entries */
- if (EBIT_TEST(e->flags, ENTRY_SPECIAL))
- return 0;
+ if (EBIT_TEST(flags, ENTRY_SPECIAL))
+ return false;
- if (!EBIT_TEST(e->flags, ENTRY_CACHABLE))
- return 0;
+ if (!EBIT_TEST(flags, ENTRY_CACHABLE))
+ return false;
- if (!e->mem_obj->isContiguous())
- return 0;
+ if (!mem_obj->isContiguous())
+ return false;
- return 1;
+ return true;
}
projects / thirdparty / squid.git / commitdiff
