store_io_aufs.c

一个功能非常全面的代理服务器源代码程序,

void
storeAufsRecycle(SwapDir * SD, StoreEntry * e)
{
    debug(79, 3) ("storeAufsUnlink: fileno %08X\n", e->swap_filen);

    /* Release the object without releasing the underlying physical object */
    storeExpireNow(e);
    storeReleaseRequest(e);
    if (e->swap_filen > -1) {
	storeAufsDirReplRemove(e);
	storeAufsDirMapBitReset(SD, e->swap_filen);
	e->swap_filen = -1;
	e->swap_dirn = -1;
    }
    storeRelease(e);
}

/*  === STATIC =========================================================== */

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
storeAufsKickReadQueue(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 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;
    }
    if (aiostate->flags.close_request)
	storeAufsIOCallback(sio, errflag);
    debug(79, 3) ("storeAufsOpenDone: exiting\n");
}

#if ASYNC_READ
static void
storeAufsReadDone(int fd, void *my_data, const char *buf, int len, int errflag)
#else
static void
storeAufsReadDone(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_WRITE
static void
storeAufsWriteDone(int fd, void *my_data, const char *buf, int aio_return, int aio_errno)
#else
static void
storeAufsWriteDone(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 void
storeAufsIOCallback(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 int
storeAufsNeedCompletetion(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 void
storeAufsIOFreeEntry(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);
}