? src/fs/aufs/q
Index: src/fs/aufs/aiops.c
===================================================================
RCS file: /server/cvs-server/squid/squid/src/fs/aufs/aiops.c,v
retrieving revision 1.12.2.1
diff -u -w -p -r1.12.2.1 aiops.c
--- src/fs/aufs/aiops.c	21 Jul 2002 00:30:03 -0000	1.12.2.1
+++ src/fs/aufs/aiops.c	5 Nov 2002 11:16:55 -0000
@@ -185,7 +185,7 @@ squidaio_get_pool(int size)
     return p;
 }
 
-static void *
+void *
 squidaio_xmalloc(int size)
 {
     void *p;
@@ -211,7 +211,7 @@ squidaio_xstrdup(const char *str)
     return p;
 }
 
-static void
+void
 squidaio_xfree(void *p, int size)
 {
     MemPool *pool;
@@ -523,9 +523,6 @@ squidaio_cleanup_request(squidaio_reques
 	squidaio_xstrfree(requestp->path);
 	break;
     case _AIO_OP_READ:
-	if (!cancelled && requestp->ret > 0)
-	    xmemcpy(requestp->bufferp, requestp->tmpbufp, requestp->ret);
-	squidaio_xfree(requestp->tmpbufp, requestp->buflen);
 	break;
     case _AIO_OP_WRITE:
 	squidaio_xfree(requestp->tmpbufp, requestp->buflen);
@@ -596,7 +593,6 @@ squidaio_read(int fd, char *bufp, int bu
     requestp = memPoolAlloc(squidaio_request_pool);
     requestp->fd = fd;
     requestp->bufferp = bufp;
-    requestp->tmpbufp = (char *) squidaio_xmalloc(bufs);
     requestp->buflen = bufs;
     requestp->offset = offset;
     requestp->whence = whence;
@@ -613,7 +609,7 @@ static void
 squidaio_do_read(squidaio_request_t * requestp)
 {
     lseek(requestp->fd, requestp->offset, requestp->whence);
-    requestp->ret = read(requestp->fd, requestp->tmpbufp, requestp->buflen);
+    requestp->ret = read(requestp->fd, requestp->bufferp, requestp->buflen);
     requestp->err = errno;
 }
 
Index: src/fs/aufs/async_io.c
===================================================================
RCS file: /server/cvs-server/squid/squid/src/fs/aufs/async_io.c,v
retrieving revision 1.10.2.2
diff -u -w -p -r1.10.2.2 async_io.c
--- src/fs/aufs/async_io.c	23 Aug 2002 22:31:53 -0000	1.10.2.2
+++ src/fs/aufs/async_io.c	5 Nov 2002 11:16:55 -0000
@@ -53,6 +53,7 @@ typedef struct squidaio_ctrl_t {
     AIOCB *done_handler;
     void *done_handler_data;
     squidaio_result_t result;
+    int len;
     char *bufp;
     FREE *free_func;
     dlink_node node;
@@ -147,7 +148,7 @@ aioClose(int fd)
 void
 aioCancel(int fd)
 {
-    squidaio_ctrl_t *curr;
+    squidaio_ctrl_t *ctrlp;
     AIOCB *done_handler;
     void *their_data;
     dlink_node *m, *next;
@@ -156,23 +157,29 @@ aioCancel(int fd)
     squidaio_counts.cancel++;
     for (m = used_list.head; m; m = next) {
 	next = m->next;
-	curr = m->data;
-	if (curr->fd != fd)
+	ctrlp = m->data;
+	if (ctrlp->fd != fd)
 	    continue;
 
-	squidaio_cancel(&curr->result);
+	squidaio_cancel(&ctrlp->result);
 
-	if ((done_handler = curr->done_handler)) {
-	    their_data = curr->done_handler_data;
-	    curr->done_handler = NULL;
-	    curr->done_handler_data = NULL;
+	if ((done_handler = ctrlp->done_handler)) {
+	    their_data = ctrlp->done_handler_data;
+	    ctrlp->done_handler = NULL;
+	    ctrlp->done_handler_data = NULL;
 	    debug(32, 2) ("this be aioCancel\n");
 	    if (cbdataValid(their_data))
-		done_handler(fd, their_data, -2, -2);
+		done_handler(fd, their_data, NULL, -2, -2);
 	    cbdataUnlock(their_data);
+	    /* free data if requested to aioWrite() */
+	    if (ctrlp->free_func)
+		ctrlp->free_func(ctrlp->bufp);
+	    /* free temporary read buffer */
+	    if (ctrlp->operation == _AIO_READ)
+		squidaio_xfree(ctrlp->bufp, ctrlp->len);
 	}
 	dlinkDelete(m, &used_list);
-	memPoolFree(squidaio_ctrl_pool, curr);
+	memPoolFree(squidaio_ctrl_pool, ctrlp);
     }
 }
 
@@ -206,7 +213,7 @@ aioWrite(int fd, int offset, char *bufp,
 
 
 void
-aioRead(int fd, int offset, char *bufp, int len, AIOCB * callback, void *callback_data)
+aioRead(int fd, int offset, int len, AIOCB * callback, void *callback_data)
 {
     squidaio_ctrl_t *ctrlp;
     int seekmode;
@@ -218,6 +225,8 @@ aioRead(int fd, int offset, char *bufp, 
     ctrlp->done_handler = callback;
     ctrlp->done_handler_data = callback_data;
     ctrlp->operation = _AIO_READ;
+    ctrlp->len = len;
+    ctrlp->bufp = squidaio_xmalloc(len);
     if (offset >= 0)
 	seekmode = SEEK_SET;
     else {
@@ -226,7 +235,7 @@ aioRead(int fd, int offset, char *bufp, 
     }
     cbdataLock(callback_data);
     ctrlp->result.data = ctrlp;
-    squidaio_read(fd, bufp, len, offset, seekmode, &ctrlp->result);
+    squidaio_read(fd, ctrlp->bufp, len, offset, seekmode, &ctrlp->result);
     dlinkAdd(ctrlp, &ctrlp->node, &used_list);
     return;
 }				/* aioRead */
@@ -309,14 +318,24 @@ aioCheckCallbacks(SwapDir * SD)
 	    ctrlp->done_handler_data = NULL;
 	    if (cbdataValid(their_data)) {
 		retval = 1;	/* Return that we've actually done some work */
-		done_handler(ctrlp->fd, their_data,
+		done_handler(ctrlp->fd, their_data, ctrlp->bufp,
 		    ctrlp->result.aio_return, ctrlp->result.aio_errno);
+	    } else {
+		if (ctrlp->operation == _AIO_OPEN) {
+		    /* The open operation was aborted.. */
+		    int fd = ctrlp->result.aio_return;
+		    if (fd >= 0)
+			aioClose(fd);
+		}
 	    }
 	    cbdataUnlock(their_data);
 	}
 	/* free data if requested to aioWrite() */
 	if (ctrlp->free_func)
 	    ctrlp->free_func(ctrlp->bufp);
+	/* free temporary read buffer */
+	if (ctrlp->operation == _AIO_READ)
+	    squidaio_xfree(ctrlp->bufp, ctrlp->len);
 	if (ctrlp->operation == _AIO_CLOSE)
 	    aioFDWasClosed(ctrlp->fd);
 	memPoolFree(squidaio_ctrl_pool, ctrlp);
Index: src/fs/aufs/store_asyncufs.h
===================================================================
RCS file: /server/cvs-server/squid/squid/src/fs/aufs/store_asyncufs.h,v
retrieving revision 1.9
diff -u -w -p -r1.9 store_asyncufs.h
--- src/fs/aufs/store_asyncufs.h	24 Aug 2001 14:29:35 -0000	1.9
+++ src/fs/aufs/store_asyncufs.h	5 Nov 2002 11:16:55 -0000
@@ -34,7 +34,7 @@ struct _squidaio_result_t {
 
 typedef struct _squidaio_result_t squidaio_result_t;
 
-typedef void AIOCB(int fd, void *, int aio_return, int aio_errno);
+typedef void AIOCB(int fd, void *cbdata, const char *buf, int aio_return, int aio_errno);
 
 int squidaio_cancel(squidaio_result_t *);
 int squidaio_open(const char *, int, mode_t, squidaio_result_t *);
@@ -49,6 +49,8 @@ squidaio_result_t *squidaio_poll_done(vo
 int squidaio_operations_pending(void);
 int squidaio_sync(void);
 int squidaio_get_queue_len(void);
+void *squidaio_xmalloc(int size);
+void squidaio_xfree(void *p, int size);
 
 void aioInit(void);
 void aioDone(void);
@@ -56,7 +58,7 @@ void aioCancel(int);
 void aioOpen(const char *, int, mode_t, AIOCB *, void *);
 void aioClose(int);
 void aioWrite(int, int offset, char *, int size, AIOCB *, void *, FREE *);
-void aioRead(int, int offset, char *, int size, AIOCB *, void *);
+void aioRead(int, int offset, int size, AIOCB *, void *);
 void aioStat(char *, struct stat *, AIOCB *, void *);
 void aioUnlink(const char *, AIOCB *, void *);
 void aioTruncate(const char *, off_t length, AIOCB *, void *);
@@ -83,7 +85,7 @@ struct _squidaiostate_t {
 	unsigned int read_kicking:1;
 	unsigned int inreaddone:1;
     } flags;
-    const char *read_buf;
+    char *read_buf;
     link_list *pending_writes;
     link_list *pending_reads;
 };
Index: src/fs/aufs/store_io_aufs.c
===================================================================
RCS file: /server/cvs-server/squid/squid/src/fs/aufs/store_io_aufs.c,v
retrieving revision 1.15.2.5
diff -u -w -p -r1.15.2.5 store_io_aufs.c
--- src/fs/aufs/store_io_aufs.c	11 Aug 2002 23:14:35 -0000	1.15.2.5
+++ src/fs/aufs/store_io_aufs.c	5 Nov 2002 11:16:55 -0000
@@ -18,7 +18,7 @@ static DWCB storeAufsWriteDone;
 #endif
 static void storeAufsIOCallback(storeIOState * sio, int errflag);
 static AIOCB storeAufsOpenDone;
-static int storeAufsSomethingPending(storeIOState *);
+static int storeAufsNeedCompletetion(storeIOState *);
 static int storeAufsKickWriteQueue(storeIOState * sio);
 static CBDUNL storeAufsIOFreeEntry;
 
@@ -141,7 +141,7 @@ storeAufsClose(SwapDir * SD, storeIOStat
     squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
     debug(79, 3) ("storeAufsClose: dirno %d, fileno %08X, FD %d\n",
 	sio->swap_dirn, sio->swap_filen, aiostate->fd);
-    if (storeAufsSomethingPending(sio)) {
+    if (storeAufsNeedCompletetion(sio)) {
 	aiostate->flags.close_request = 1;
 	return;
     }
@@ -168,6 +168,7 @@ storeAufsRead(SwapDir * SD, storeIOState
 	q->offset = offset;
 	q->callback = callback;
 	q->callback_data = callback_data;
+	cbdataLock(q->callback_data);
 	linklistPush(&(aiostate->pending_reads), q);
 	return;
     }
@@ -180,7 +181,7 @@ storeAufsRead(SwapDir * SD, storeIOState
     sio->offset = offset;
     aiostate->flags.reading = 1;
 #if ASYNC_READ
-    aioRead(aiostate->fd, offset, buf, size, storeAufsReadDone, sio);
+    aioRead(aiostate->fd, offset, size, storeAufsReadDone, sio);
 #else
     file_read(aiostate->fd, buf, size, offset, storeAufsReadDone, sio);
 #endif
@@ -262,13 +263,15 @@ storeAufsKickReadQueue(storeIOState * si
 	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, int fd, int errflag)
+storeAufsOpenDone(int unused, void *my_data, const char *unused2, int fd, int errflag)
 {
     storeIOState *sio = my_data;
     squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
@@ -289,7 +292,7 @@ storeAufsOpenDone(int unused, void *my_d
     if (FILE_MODE(sio->mode) == O_WRONLY) {
 	if (storeAufsKickWriteQueue(sio))
 	    return;
-    } else if (FILE_MODE(sio->mode) == O_RDONLY) {
+    } else if ((FILE_MODE(sio->mode) == O_RDONLY) && !aiostate->flags.close_request) {
 	if (storeAufsKickReadQueue(sio))
 	    return;
     }
@@ -300,7 +303,7 @@ storeAufsOpenDone(int unused, void *my_d
 
 #if ASYNC_READ
 static void
-storeAufsReadDone(int fd, void *my_data, int len, int errflag)
+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)
@@ -311,6 +314,7 @@ storeAufsReadDone(int fd, const char *bu
     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;
@@ -337,11 +341,16 @@ storeAufsReadDone(int fd, const char *bu
     assert(their_data);
     sio->read.callback = NULL;
     sio->read.callback_data = NULL;
-    if (cbdataValid(their_data))
+    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)
+    if (aiostate->flags.close_request && !inreaddone)
 	storeAufsIOCallback(sio, errflag);
 }
 
@@ -403,36 +412,37 @@ storeAufsIOCallback(storeIOState * sio, 
     debug(79, 3) ("storeAufsIOCallback: errflag=%d\n", errflag);
     sio->callback = NULL;
     sio->callback_data = NULL;
-    debug(79, 3) ("%s:%d\n", __FILE__, __LINE__);
+    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);
     if (callback)
 	if (NULL == their_data || cbdataValid(their_data))
 	    callback(their_data, errflag, sio);
-    debug(79, 3) ("%s:%d\n", __FILE__, __LINE__);
+    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);
     cbdataUnlock(their_data);
     aiostate->fd = -1;
     cbdataFree(sio);
     if (fd < 0)
 	return;
-    debug(79, 3) ("%s:%d\n", __FILE__, __LINE__);
+    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);
     aioClose(fd);
     fd_close(fd);
     store_open_disk_fd--;
-    debug(79, 3) ("%s:%d\n", __FILE__, __LINE__);
+    debug(79, 9) ("%s:%d\n", __FILE__, __LINE__);
 }
 
 
 static int
-storeAufsSomethingPending(storeIOState * sio)
+storeAufsNeedCompletetion(storeIOState * sio)
 {
     squidaiostate_t *aiostate = (squidaiostate_t *) sio->fsstate;
-    if (aiostate->flags.reading)
-	return 1;
+
     if (aiostate->flags.writing)
 	return 1;
-    if (aiostate->flags.opening)
+    if (aiostate->flags.opening && FILE_MODE(sio->mode) == O_WRONLY)
 	return 1;
     if (aiostate->flags.inreaddone)
 	return 1;
+
+    /* Note: Pending read operations are silently cancelled on close */
     return 0;
 }
 
@@ -443,7 +453,24 @@ storeAufsSomethingPending(storeIOState *
  * to bother with that.
  */
 static void
-storeAufsIOFreeEntry(void *sio)
+storeAufsIOFreeEntry(void *siop)
 {
-    memPoolFree(squidaio_state_pool, ((storeIOState *) sio)->fsstate);
+    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);
 }