/*
* This routine hasn't been optimised to take advantage of the
* passed sc. Yet.
*/
int
storeUnregister(store_client * sc, StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, data));
#endif
if (mem == NULL)
return 0;
debug(20, 3) ("storeUnregister: called for '%s'\n", storeKeyText(e->hash.key));
if (sc == NULL)
return 0;
if (mem->clients.head == NULL)
return 0;
dlinkDelete(&sc->node, &mem->clients);
mem->nclients--;
if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
storeSwapOut(e);
if (sc->swapin_sio) {
storeClose(sc->swapin_sio);
cbdataUnlock(sc->swapin_sio);
sc->swapin_sio = NULL;
statCounter.swap.ins++;
}
if (NULL != sc->callback) {
/* callback with ssize = -1 to indicate unexpected termination */
debug(20, 3) ("storeUnregister: store_client for %s has a callback\n",
mem->url);
storeClientCallback(sc, -1);
}
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sc->delay_id);
#endif
cbdataUnlock(sc->callback_data); /* we're done with it now */
/*assert(!sc->flags.disk_io_pending); */
cbdataFree(sc);
assert(e->lock_count > 0);
storeSwapOutMaintainMemObject(e);
if (mem->nclients == 0)
CheckQuickAbort(e);
return 1;
}
/*
* This routine hasn't been optimised to take advantage of the
* passed sc. Yet.
*/
int
storeClientUnregister(store_client * sc, StoreEntry * e, void *owner)
{
MemObject *mem = e->mem_obj;
if (sc == NULL)
return 0;
debug(20, 3) ("storeClientUnregister: called for '%s'\n", storeKeyText(e->hash.key));
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, owner));
#endif
assert(sc->entry == e);
if (mem->clients.head == NULL)
return 0;
dlinkDelete(&sc->node, &mem->clients);
mem->nclients--;
if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
storeSwapOut(e);
if (sc->swapin_sio) {
storeClose(sc->swapin_sio);
cbdataUnlock(sc->swapin_sio);
sc->swapin_sio = NULL;
statCounter.swap.ins++;
}
if (NULL != sc->new_callback) {
/* callback with ssize = -1 to indicate unexpected termination */
debug(20, 3) ("storeClientUnregister: store_client for %s has a callback\n",
mem->url);
storeClientCallback(sc, -1);
}
stmemNodeUnref(&sc->node_ref);
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sc->delay_id);
#endif
storeSwapOutMaintainMemObject(e);
if (mem->nclients == 0)
CheckQuickAbort(e);
storeUnlockObject(sc->entry);
sc->entry = NULL;
cbdataFree(sc);
return 1;
}
static void
storeClientCopy3(StoreEntry * e, store_client * sc)
{
MemObject *mem = e->mem_obj;
ssize_t sz;
if (storeClientNoMoreToSend(e, sc)) {
/* There is no more to send! */
storeClientCallback(sc, 0);
return;
}
if (e->store_status == STORE_PENDING && sc->seen_offset >= mem->inmem_hi) {
/* client has already seen this, wait for more */
debug(20, 3) ("storeClientCopy3: Waiting for more\n");
/* If the read is backed off and all clients have seen all the data in
* memory, re-poll the fd */
if ((EBIT_TEST(e->flags, ENTRY_DEFER_READ)) &&
(storeLowestMemReaderOffset(e) == mem->inmem_hi)) {
debug(20, 3) ("storeClientCopy3: %s - clearing ENTRY_DEFER_READ\n", e->mem_obj->url);
/* Clear the flag and re-poll the fd */
storeResumeRead(e);
}
return;
}
/*
* Slight weirdness here. We open a swapin file for any
* STORE_DISK_CLIENT, even if we can copy the requested chunk
* from memory in the next block. We must try to open the
* swapin file before sending any data to the client side. If
* we postpone the open, and then can not open the file later
* on, the client loses big time. Its transfer just gets cut
* off. Better to open it early (while the client side handler
* is clientCacheHit) so that we can fall back to a cache miss
* if needed.
*/
if (STORE_DISK_CLIENT == sc->type && NULL == sc->swapin_sio) {
debug(20, 3) ("storeClientCopy3: Need to open swap in file\n");
/* gotta open the swapin file */
if (storeTooManyDiskFilesOpen()) {
/* yuck -- this causes a TCP_SWAPFAIL_MISS on the client side */
storeClientCallback(sc, -1);
return;
} else if (!sc->flags.disk_io_pending) {
/* Don't set store_io_pending here */
storeSwapInStart(sc);
if (NULL == sc->swapin_sio) {
storeClientCallback(sc, -1);
return;
}
/*
* If the open succeeds we either copy from memory, or
* schedule a disk read in the next block.
*/
} else {
debug(20, 1) ("WARNING: Averted multiple fd operation (1)\n");
return;
}
}
if (sc->copy_offset >= mem->inmem_lo && sc->copy_offset < mem->inmem_hi) {
/* What the client wants is in memory */
debug(20, 3) ("storeClientCopy3: Copying from memory\n");
sz = stmemCopy(&mem->data_hdr,
sc->copy_offset, sc->copy_buf, sc->copy_size);
if (EBIT_TEST(e->flags, RELEASE_REQUEST))
storeSwapOutMaintainMemObject(e);
storeClientCallback(sc, sz);
return;
}
/* What the client wants is not in memory. Schedule a disk read */
assert(STORE_DISK_CLIENT == sc->type);
assert(!sc->flags.disk_io_pending);
debug(20, 3) ("storeClientCopy3: reading from STORE\n");
storeClientFileRead(sc);
}
