/* add client with fd to client list */
store_client *
storeClientRegister(StoreEntry * e, void *owner)
{
MemObject *mem = e->mem_obj;
store_client *sc;
assert(mem);
e->refcount++;
mem->nclients++;
sc = cbdataAlloc(store_client);
sc->callback_data = NULL;
sc->seen_offset = 0;
sc->copy_offset = 0;
sc->flags.disk_io_pending = 0;
sc->entry = e;
storeLockObject(sc->entry);
sc->type = storeClientType(e);
#if STORE_CLIENT_LIST_DEBUG
assert(!storeClientListSearch(mem, owner));
sc->owner = owner;
#endif
dlinkAdd(sc, &sc->node, &mem->clients);
#if DELAY_POOLS
sc->delay_id = 0;
#endif
return sc;
}
/* copy bytes requested by the client */
void
storeClientCopy(StoreEntry * e,
off_t seen_offset,
off_t copy_offset,
size_t size,
char *buf,
STCB * callback,
void *data)
{
store_client *sc;
assert(!EBIT_TEST(e->flags, ENTRY_ABORTED));
debug(20, 3) ("storeClientCopy: %s, seen %d, want %d, size %d, cb %p, cbdata %p\n",
storeKeyText(e->key),
(int) seen_offset,
(int) copy_offset,
(int) size,
callback,
data);
sc = storeClientListSearch(e->mem_obj, data);
assert(sc != NULL);
assert(sc->callback == NULL);
sc->copy_offset = copy_offset;
sc->seen_offset = seen_offset;
sc->callback = callback;
sc->copy_buf = buf;
sc->copy_size = size;
sc->copy_offset = copy_offset;
storeClientCopy2(e, sc);
}
/* add client with fd to client list */
void
storeClientListAdd(StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
store_client **T;
store_client *sc;
assert(mem);
if (storeClientListSearch(mem, data) != NULL)
return;
e->refcount++;
mem->nclients++;
sc = memAllocate(MEM_STORE_CLIENT);
cbdataAdd(sc, memFree, MEM_STORE_CLIENT); /* sc is callback_data for file_read */
cbdataLock(data); /* locked while we point to it */
sc->callback_data = data;
sc->seen_offset = 0;
sc->copy_offset = 0;
sc->flags.disk_io_pending = 0;
sc->entry = e;
sc->type = storeClientType(e);
if (sc->type == STORE_DISK_CLIENT)
/* assert we'll be able to get the data we want */
/* maybe we should open swapin_fd here */
assert(e->swap_file_number > -1 || storeSwapOutAble(e));
for (T = &mem->clients; *T; T = &(*T)->next);
*T = sc;
#if DELAY_POOLS
sc->delay_id = 0;
#endif
}
/* copy bytes requested by the client */
void
storeClientCopy(store_client * sc,
StoreEntry * e,
squid_off_t seen_offset,
squid_off_t copy_offset,
size_t size,
char *buf,
STCB * callback,
void *data)
{
assert(!EBIT_TEST(e->flags, ENTRY_ABORTED));
debug(20, 3) ("storeClientCopy: %s, seen %" PRINTF_OFF_T ", want %" PRINTF_OFF_T ", size %d, cb %p, cbdata %p\n",
storeKeyText(e->hash.key),
seen_offset,
copy_offset,
(int) size,
callback,
data);
assert(sc != NULL);
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, data));
#endif
assert(sc->callback == NULL);
assert(sc->entry == e);
sc->seen_offset = seen_offset;
sc->callback = callback;
sc->copy_buf = buf;
sc->copy_size = size;
sc->copy_offset = copy_offset;
storeClientCopy2(e, sc);
}
/* add client with fd to client list */
store_client *
storeClientListAdd(StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
store_client *sc;
assert(mem);
#if STORE_CLIENT_LIST_DEBUG
if (storeClientListSearch(mem, data) != NULL)
assert(1 == 0); /* XXX die! */
#endif
e->refcount++;
mem->nclients++;
sc = cbdataAlloc(store_client);
cbdataLock(data); /* locked while we point to it */
sc->callback_data = data;
sc->seen_offset = 0;
sc->copy_offset = 0;
sc->flags.disk_io_pending = 0;
sc->entry = e;
sc->type = storeClientType(e);
dlinkAdd(sc, &sc->node, &mem->clients);
#if DELAY_POOLS
sc->delay_id = 0;
#endif
return sc;
}
int
storeClientCopyPending(StoreEntry * e, void *data)
{
/* return 1 if there is a callback registered for this client */
store_client *sc = storeClientListSearch(e->mem_obj, data);
if (sc == NULL)
return 0;
if (sc->callback == NULL)
return 0;
return 1;
}
int
storeClientCopyPending(store_client * sc, StoreEntry * e, void *data)
{
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, data));
#endif
assert(sc->entry == e);
if (sc == NULL)
return 0;
if (sc->callback == NULL)
return 0;
return 1;
}
/*
* 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;
}
/* copy bytes requested by the client */
void
storeClientCopy(store_client * sc,
StoreEntry * e,
squid_off_t seen_offset,
squid_off_t copy_offset,
size_t size,
char *buf,
STCB * callback,
void *data)
{
debug(20, 3) ("storeClientCopy: %s, seen %" PRINTF_OFF_T ", want %" PRINTF_OFF_T ", size %d, cb %p, cbdata %p\n",
storeKeyText(e->hash.key),
seen_offset,
copy_offset,
(int) size,
callback,
data);
assert(sc != NULL);
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, data));
#endif
assert(sc->callback == NULL);
assert(sc->entry == e);
sc->seen_offset = seen_offset;
sc->callback = callback;
sc->callback_data = data;
cbdataLock(sc->callback_data);
sc->copy_buf = buf;
sc->copy_size = size;
sc->copy_offset = copy_offset;
/* If the read is being deferred, run swapout in case this client has the
* lowest seen_offset. storeSwapOut() frees the memory and clears the
* ENTRY_DEFER_READ bit if necessary */
if (EBIT_TEST(e->flags, ENTRY_DEFER_READ)) {
storeSwapOut(e);
}
storeClientCopy2(e, sc);
}
