]>
git.ipfire.org Git - thirdparty/squid.git/blob - src/DiskIO/AIO/AIODiskFile.cc
4 * SQUID Web Proxy Cache http://www.squid-cache.org/
5 * ----------------------------------------------------------
7 * Squid is the result of efforts by numerous individuals from
8 * the Internet community; see the CONTRIBUTORS file for full
9 * details. Many organizations have provided support for Squid's
10 * development; see the SPONSORS file for full details. Squid is
11 * Copyrighted (C) 2001 by the Regents of the University of
12 * California; see the COPYRIGHT file for full details. Squid
13 * incorporates software developed and/or copyrighted by other
14 * sources; see the CREDITS file for full details.
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
30 * Copyright (c) 2003, Robert Collins <robertc@squid-cache.org>
34 * Author: Adrian Chadd <adrian@squid-cache.org>
37 * These routines are simple plugin replacements for the file_* routines
38 * in disk.c . They back-end into the POSIX AIO routines to provide
39 * a nice and simple async IO framework for COSS.
42 * AIO is suitable for COSS - the only sync operations that the standard
43 * supports are read/write, and since COSS works on a single file
44 * per storedir it should work just fine.
48 #include "AIODiskFile.h"
49 #include "AIODiskIOStrategy.h"
50 #include "DiskIO/IORequestor.h"
51 #include "DiskIO/ReadRequest.h"
52 #include "DiskIO/WriteRequest.h"
60 CBDATA_CLASS_INIT(AIODiskFile
);
62 AIODiskFile::operator new(size_t unused
)
64 CBDATA_INIT_TYPE(AIODiskFile
);
65 return cbdataAlloc(AIODiskFile
);
69 AIODiskFile::operator delete(void *address
)
74 AIODiskFile::AIODiskFile(char const *aPath
, AIODiskIOStrategy
*aStrategy
) : fd(-1), closed(true), error_(false)
79 debugs(79, 3, "AIODiskFile::AIODiskFile: " << aPath
);
82 AIODiskFile::~AIODiskFile()
86 AIODiskFile::error(bool const &aBool
)
92 AIODiskFile::open(int flags
, mode_t mode
, RefCount
<IORequestor
> callback
)
94 /* Simulate async calls */
96 fd
= aio_open(path
.termedBuf(), flags
);
98 fd
= file_open(path
.termedBuf() , flags
);
101 ioRequestor
= callback
;
104 debugs(79, 3, HERE
<< ": got failure (" << errno
<< ")");
108 ++store_open_disk_fd
;
109 debugs(79, 3, HERE
<< ": opened FD " << fd
);
112 callback
->ioCompletedNotification();
116 AIODiskFile::create(int flags
, mode_t mode
, RefCount
<IORequestor
> callback
)
118 /* We use the same logic path for open */
119 open(flags
, mode
, callback
);
123 AIODiskFile::read(ReadRequest
*request
)
126 async_queue_entry_t
*qe
;
128 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
130 /* Find a free slot */
131 slot
= strategy
->findSlot();
134 /* No free slot? Callback error, and return */
135 fatal("Aiee! out of aiocb slots! - FIXME and wrap file_read\n");
136 debugs(79, DBG_IMPORTANT
, "WARNING: out of aiocb slots!");
137 /* fall back to blocking method */
138 // file_read(fd, request->buf, request->len, request->offset, callback, data);
142 /* Mark slot as ours */
143 qe
= &strategy
->aq
.aq_queue
[slot
];
145 qe
->aq_e_state
= AQ_ENTRY_USED
;
147 qe
->aq_e_callback_data
= cbdataReference(request
);
149 qe
->theFile
= cbdataReference(this);
151 qe
->aq_e_type
= AQ_ENTRY_READ
;
153 qe
->aq_e_free
= NULL
;
155 qe
->aq_e_buf
= request
->buf
;
157 qe
->aq_e_fd
= getFD();
159 qe
->aq_e_aiocb
.aio_fildes
= getFD();
161 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
163 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
165 qe
->aq_e_aiocb
.aio_buf
= request
->buf
;
168 ++ strategy
->aq
.aq_numpending
;
171 if (aio_read(&qe
->aq_e_aiocb
) < 0) {
172 fatalf("Aiee! aio_read() returned error (%d) FIXME and wrap file_read !\n", errno
);
173 debugs(79, DBG_IMPORTANT
, "WARNING: aio_read() returned error: " << xstrerror());
174 /* fall back to blocking method */
175 // file_read(fd, request->buf, request->len, request->offset, callback, data);
181 AIODiskFile::write(WriteRequest
*request
)
184 async_queue_entry_t
*qe
;
186 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
188 /* Find a free slot */
189 slot
= strategy
->findSlot();
192 /* No free slot? Callback error, and return */
193 fatal("Aiee! out of aiocb slots FIXME and wrap file_write !\n");
194 debugs(79, DBG_IMPORTANT
, "WARNING: out of aiocb slots!");
195 /* fall back to blocking method */
196 // file_write(fd, offset, buf, len, callback, data, freefunc);
200 /* Mark slot as ours */
201 qe
= &strategy
->aq
.aq_queue
[slot
];
203 qe
->aq_e_state
= AQ_ENTRY_USED
;
205 qe
->aq_e_callback_data
= cbdataReference(request
);
207 qe
->theFile
= cbdataReference(this);
209 qe
->aq_e_type
= AQ_ENTRY_WRITE
;
211 qe
->aq_e_free
= request
->free_func
;
213 qe
->aq_e_buf
= (void *)request
->buf
;
217 qe
->aq_e_aiocb
.aio_fildes
= fd
;
219 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
221 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
223 qe
->aq_e_aiocb
.aio_buf
= (void *)request
->buf
;
226 ++strategy
->aq
.aq_numpending
;
229 if (aio_write(&qe
->aq_e_aiocb
) < 0) {
230 fatalf("Aiee! aio_write() returned error (%d) FIXME and wrap file_write !\n", errno
);
231 debugs(79, DBG_IMPORTANT
, "WARNING: aio_write() returned error: " << xstrerror());
232 /* fall back to blocking method */
233 // file_write(fd, offset, buf, len, callback, data, freefunc);
238 AIODiskFile::close ()
249 assert (ioRequestor
!= NULL
);
250 ioRequestor
->closeCompleted();
254 AIODiskFile::canRead() const
260 AIODiskFile::canWrite() const
266 AIODiskFile::getFD() const
272 AIODiskFile::error() const
278 AIODiskFile::ioInProgress() const