static void
storeAufsOpenDone(int unused, void *my_data, const char *unused2, int fd, int errflag)
{
storeIOState *sio = my_data;
squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
debug(79, 3) ("storeAufsOpenDone: FD %d, errflag %d\n", fd, errflag);
Opening_FD--;
aiostate->flags.opening = 0;
if (errflag || fd < 0) {
errno = errflag;
debug(79, 0) ("storeAufsOpenDone: %s\n", xstrerror());
debug(79, 1) ("\t%s\n", storeAufsDirFullPath(INDEXSD(sio->swap_dirn), sio->swap_filen, NULL));
storeAufsIOCallback(sio, DISK_ERROR);
return;
}
store_open_disk_fd++;
aiostate->fd = fd;
commSetCloseOnExec(fd);
fd_open(fd, FD_FILE, storeAufsDirFullPath(INDEXSD(sio->swap_dirn), sio->swap_filen, NULL));
if (FILE_MODE(sio->mode) == O_WRONLY) {
if (storeAufsKickWriteQueue(sio))
return;
} else if ((FILE_MODE(sio->mode) == O_RDONLY) && !aiostate->flags.close_request) {
if (storeAufsKickReadQueue(sio))
return;
#ifdef CC_FRAMEWORK
if (storeAufsKickZCopyQueue(sio))
return;
#endif
}
if (aiostate->flags.close_request)
storeAufsIOCallback(sio, errflag);
debug(79, 3) ("storeAufsOpenDone: exiting\n");
}
static int
storeAufsKickWriteQueue(storeIOState * sio)
{
squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
struct _queued_write *q = linklistShift(&aiostate->pending_writes);
if (NULL == q)
return 0;
debug(79, 3) ("storeAufsKickWriteQueue: writing queued chunk of %ld bytes\n",
(long int) q->size);
storeAufsWrite(INDEXSD(sio->swap_dirn), sio, q->buf, q->size, q->offset, q->free_func);
memPoolFree(aufs_qwrite_pool, q);
return 1;
}
static int
storeAufsKickZCopyQueue(storeIOState * sio)
{
squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
struct _queued_zcopy *q = linklistShift(&(aiostate->pending_zcopies));
if (NULL == q)
return 0;
debug(79, 3) ("storeAufsKickReadQueue: zcopying queued request of %ld bytes\n",(long int) q->size);
if (cbdataValid(q->callback_data))
storeAufsZCopy(INDEXSD(sio->swap_dirn), sio, q->zc_target_fd, q->size, q->offset, q->callback, q->callback_data);
cbdataUnlock(q->callback_data);
memPoolFree(aufs_qzcopy_pool, q);
return 1;
}
static void
storeDiskdReadDone(diomsg * M)
{
storeIOState *sio = M->callback_data;
STRCB *callback = sio->read.callback;
SwapDir *sd = INDEXSD(sio->swap_dirn);
diskdstate_t *diskdstate = sio->fsstate;
diskdinfo_t *diskdinfo = sd->fsdata;
void *their_data = sio->read.callback_data;
char *their_buf = diskdstate->read_buf;
char *sbuf;
size_t len;
int valid;
statCounter.syscalls.disk.reads++;
diskdstate->flags.reading = 0;
if (diskdstate->flags.close_request) {
debug(79, 2) ("storeDiskReadDone: closing, so ignore!\n");
return;
}
valid = cbdataValid(sio->read.callback_data);
cbdataUnlock(sio->read.callback_data);
debug(79, 3) ("storeDiskdReadDone: dirno %d, fileno %08x status %d\n",
sio->swap_dirn, sio->swap_filen, M->status);
if (M->status < 0) {
diskd_stats.read.fail++;
storeDiskdIOCallback(sio, DISK_ERROR);
return;
}
diskd_stats.read.success++;
sbuf = diskdinfo->shm.buf + M->shm_offset;
len = M->status;
sio->offset += len;
assert(callback);
assert(their_data);
sio->read.callback = NULL;
sio->read.callback_data = NULL;
if (valid) {
assert(!diskdstate->flags.close_request);
/*
* Only copy the data if the callback is still valid,
* if it isn't valid then the request should have been
* aborted.
* -- adrian
*/
xmemcpy(their_buf, sbuf, len); /* yucky copy */
callback(their_data, their_buf, len);
}
}
void
storeRecycle(StoreEntry * e)
{
if (e->swap_dirn >= 0 && !storeEntryLocked(e)) {
SwapDir *SD = INDEXSD(e->swap_dirn);
/* Expire the object */
storeExpireNow(e);
storeReleaseRequest(e);
/* Make the cache_dir forget about it */
SD->obj.recycle(SD, e);
}
/* Finally make the store layer forget about this object */
storeRelease(e);
}
static void
storeUfsIOCallback(storeIOState * sio, int errflag)
{
ufsstate_t *ufsstate = (ufsstate_t *) sio->fsstate;
debug(79, 3) ("storeUfsIOCallback: errflag=%d\n", errflag);
if (ufsstate->fd > -1) {
SwapDir *SD = INDEXSD(sio->swap_dirn);
ufsinfo_t *ufsinfo = (ufsinfo_t *) SD->fsdata;
file_close(ufsstate->fd);
store_open_disk_fd--;
ufsinfo->open_files--;
}
if (cbdataValid(sio->callback_data))
sio->callback(sio->callback_data, errflag, sio);
cbdataUnlock(sio->callback_data);
sio->callback_data = NULL;
sio->callback = NULL;
cbdataFree(sio);
}
void
storeUnlink(StoreEntry * e)
{
SwapDir *SD = INDEXSD(e->swap_dirn);
SD->obj.unlink(SD, e);
}
