}voidstoreAufsRecycle(SwapDir * SD, StoreEntry * e){    debug(79, 3) ("storeAufsRecycle: fileno %08X\n", e->swap_filen);    /* detach from the underlying physical object */    if (e->swap_filen > -1) {	storeAufsDirReplRemove(e);	storeAufsDirMapBitReset(SD, e->swap_filen);	e->swap_filen = -1;	e->swap_dirn = -1;    }}/*  === STATIC =========================================================== */static intstoreAufsKickWriteQueue(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 intstoreAufsKickReadQueue(storeIOState * sio){    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;    struct _queued_read *q = linklistShift(&(aiostate->pending_reads));    if (NULL == q)	return 0;    debug(79, 3) ("storeAufsKickReadQueue: reading queued request of %ld bytes\n",	(long int) q->size);    if (cbdataValid(q->callback_data))	storeAufsRead(INDEXSD(sio->swap_dirn), sio, q->buf, q->size, q->offset, q->callback, q->callback_data);    cbdataUnlock(q->callback_data);    memPoolFree(aufs_qread_pool, q);    return 1;}static voidstoreAufsOpenDone(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;    }    if (aiostate->flags.close_request)	storeAufsIOCallback(sio, errflag);    debug(79, 3) ("storeAufsOpenDone: exiting\n");}#if ASYNC_READstatic voidstoreAufsReadDone(int fd, void *my_data, const char *buf, int len, int errflag)#elsestatic voidstoreAufsReadDone(int fd, const char *buf, int len, int errflag, void *my_data)#endif{    storeIOState *sio = my_data;    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;    STRCB *callback = sio->read.callback;    void *their_data = sio->read.callback_data;    ssize_t rlen;    int inreaddone = aiostate->flags.inreaddone;	/* Protect from callback loops */    debug(79, 3) ("storeAufsReadDone: dirno %d, fileno %08X, FD %d, len %d\n",	sio->swap_dirn, sio->swap_filen, fd, len);    aiostate->flags.inreaddone = 1;    aiostate->flags.reading = 0;    if (errflag) {	debug(79, 3) ("storeAufsReadDone: got failure (%d)\n", errflag);	rlen = -1;    } else {	rlen = len;	sio->offset += len;    }#if ASYNC_READ    /* translate errflag from errno to Squid disk error */    errno = errflag;    if (errflag)	errflag = DISK_ERROR;    else	errflag = DISK_OK;#else    if (errflag == DISK_EOF)	errflag = DISK_OK;	/* EOF is signalled by len == 0, not errors... */#endif    assert(callback);    assert(their_data);    sio->read.callback = NULL;    sio->read.callback_data = NULL;    if (!aiostate->flags.close_request && cbdataValid(their_data)) {#if ASYNC_READ	if (rlen > 0)	    memcpy(aiostate->read_buf, buf, rlen);#endif	callback(their_data, aiostate->read_buf, rlen);    }    cbdataUnlock(their_data);    aiostate->flags.inreaddone = 0;    if (aiostate->flags.close_request && !inreaddone)	storeAufsIOCallback(sio, errflag);}#if ASYNC_WRITEstatic voidstoreAufsWriteDone(int fd, void *my_data, const char *buf, int aio_return, int aio_errno)#elsestatic voidstoreAufsWriteDone(int fd, int errflag, size_t len, void *my_data)#endif{    static int loop_detect = 0;    storeIOState *sio = my_data;    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;#if ASYNC_WRITE    int errflag;    int len = aio_return;    /* Translate from errno to Squid disk error */    if (aio_errno)	errflag = aio_errno == ENOSPC ? DISK_NO_SPACE_LEFT : DISK_ERROR;    else	errflag = DISK_OK;#endif    debug(79, 3) ("storeAufsWriteDone: dirno %d, fileno %08X, FD %d, len %ld, err=%d\n",	sio->swap_dirn, sio->swap_filen, fd, (long int) len, errflag);    assert(++loop_detect < 10);    aiostate->flags.writing = 0;    if (errflag) {	debug(79, 0) ("storeAufsWriteDone: got failure (%d)\n", errflag);	storeAufsIOCallback(sio, errflag);	loop_detect--;	return;    }    sio->offset += len;#if ASYNC_WRITE    if (storeAufsKickWriteQueue(sio))	(void) 0;    else if (aiostate->flags.close_request)	storeAufsIOCallback(sio, errflag);#else    /* loop around storeAufsKickWriteQueue to break recursion stack     * overflow when large amounts of data has been queued for write.     * As writes are blocking here we immediately get called again     * without going via the I/O event loop..     */    if (!aiostate->flags.write_kicking) {	/* cbdataLock to protect us from the storeAufsIOCallback on error above */	cbdataLock(sio);	aiostate->flags.write_kicking = 1;	while (storeAufsKickWriteQueue(sio))	    if (!cbdataValid(sio))		break;	if (cbdataValid(sio)) {	    aiostate->flags.write_kicking = 0;	    if (aiostate->flags.close_request)		storeAufsIOCallback(sio, errflag);	}	cbdataUnlock(sio);    }#endif    loop_detect--;}static voidstoreAufsIOCallback(storeIOState * sio, int errflag){    STIOCB *callback = sio->callback;    void *their_data = sio->callback_data;    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;    int fd = aiostate->fd;    debug(79, 3) ("storeAufsIOCallback: errflag=%d\n", errflag);    sio->callback = NULL;    sio->callback_data = NULL;    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);    if (callback)	if (NULL == their_data || cbdataValid(their_data))	    callback(their_data, errflag, sio);    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);    cbdataUnlock(their_data);    aiostate->fd = -1;    if (aiostate->flags.opening)	Opening_FD--;    cbdataFree(sio);    if (fd < 0)	return;    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);#if ASYNC_CLOSE    fd_close(fd);    aioClose(fd);#else    aioCancel(fd);    file_close(fd);#endif    store_open_disk_fd--;    statCounter.syscalls.disk.closes++;    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);}static intstoreAufsNeedCompletetion(storeIOState * sio){    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;    if (aiostate->flags.writing)	return 1;    if (aiostate->flags.opening && FILE_MODE(sio->mode) == O_WRONLY)	return 1;    if (aiostate->flags.reading)	return 1;    if (aiostate->flags.inreaddone)	return 1;    return 0;}/*       * Clean up references from the SIO before it gets released. * The actuall SIO is managed by cbdata so we do not need * to bother with that. */static voidstoreAufsIOFreeEntry(void *siop){    storeIOState *sio = (storeIOState *) siop;    squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;    struct _queued_write *qw;    struct _queued_read *qr;    while ((qw = linklistShift(&aiostate->pending_writes))) {	if (qw->free_func)	    qw->free_func(qw->buf);	memPoolFree(aufs_qwrite_pool, qw);    }    while ((qr = linklistShift(&aiostate->pending_reads))) {	cbdataUnlock(qr->callback_data);	memPoolFree(aufs_qread_pool, qr);    }    if (sio->read.callback_data)	cbdataUnlock(sio->read.callback_data);    if (sio->callback_data)	cbdataUnlock(sio->callback_data);    memPoolFree(squidaio_state_pool, aiostate);}