]>
git.ipfire.org Git - thirdparty/squid.git/blob - src/DiskIO/AIO/AIODiskFile.cc
99be575f2877186d5e06d04429c18c848899273d
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"
54 CBDATA_CLASS_INIT(AIODiskFile
);
56 AIODiskFile::operator new(size_t unused
)
58 CBDATA_INIT_TYPE(AIODiskFile
);
59 return cbdataAlloc(AIODiskFile
);
63 AIODiskFile::operator delete(void *address
)
68 AIODiskFile::AIODiskFile(char const *aPath
, AIODiskIOStrategy
*aStrategy
) : fd(-1), closed(true), error_(false)
73 debugs(79, 3, "AIODiskFile::AIODiskFile: " << aPath
);
76 AIODiskFile::~AIODiskFile()
80 AIODiskFile::error(bool const &aBool
)
86 AIODiskFile::open(int flags
, mode_t mode
, RefCount
<IORequestor
> callback
)
88 /* Simulate async calls */
90 fd
= aio_open(path
.termedBuf(), flags
);
92 fd
= file_open(path
.termedBuf() , flags
);
95 ioRequestor
= callback
;
98 debugs(79, 3, HERE
<< ": got failure (" << errno
<< ")");
102 store_open_disk_fd
++;
103 debugs(79, 3, HERE
<< ": opened FD " << fd
);
106 callback
->ioCompletedNotification();
110 AIODiskFile::create(int flags
, mode_t mode
, RefCount
<IORequestor
> callback
)
112 /* We use the same logic path for open */
113 open(flags
, mode
, callback
);
117 AIODiskFile::read(ReadRequest
*request
)
120 async_queue_entry_t
*qe
;
122 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
124 /* Find a free slot */
125 slot
= strategy
->findSlot();
128 /* No free slot? Callback error, and return */
129 fatal("Aiee! out of aiocb slots! - FIXME and wrap file_read\n");
130 debugs(79, 1, "WARNING: out of aiocb slots!");
131 /* fall back to blocking method */
132 // file_read(fd, request->buf, request->len, request->offset, callback, data);
136 /* Mark slot as ours */
137 qe
= &strategy
->aq
.aq_queue
[slot
];
139 qe
->aq_e_state
= AQ_ENTRY_USED
;
141 qe
->aq_e_callback_data
= cbdataReference(request
);
143 qe
->theFile
= cbdataReference(this);
145 qe
->aq_e_type
= AQ_ENTRY_READ
;
147 qe
->aq_e_free
= NULL
;
149 qe
->aq_e_buf
= request
->buf
;
151 qe
->aq_e_fd
= getFD();
153 qe
->aq_e_aiocb
.aio_fildes
= getFD();
155 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
157 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
159 qe
->aq_e_aiocb
.aio_buf
= request
->buf
;
162 strategy
->aq
.aq_numpending
++;
165 if (aio_read(&qe
->aq_e_aiocb
) < 0) {
166 fatalf("Aiee! aio_read() returned error (%d) FIXME and wrap file_read !\n", errno
);
167 debugs(79, 1, "WARNING: aio_read() returned error: " << xstrerror());
168 /* fall back to blocking method */
169 // file_read(fd, request->buf, request->len, request->offset, callback, data);
175 AIODiskFile::write(WriteRequest
*request
)
178 async_queue_entry_t
*qe
;
180 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
182 /* Find a free slot */
183 slot
= strategy
->findSlot();
186 /* No free slot? Callback error, and return */
187 fatal("Aiee! out of aiocb slots FIXME and wrap file_write !\n");
188 debugs(79, 1, "WARNING: out of aiocb slots!");
189 /* fall back to blocking method */
190 // file_write(fd, offset, buf, len, callback, data, freefunc);
194 /* Mark slot as ours */
195 qe
= &strategy
->aq
.aq_queue
[slot
];
197 qe
->aq_e_state
= AQ_ENTRY_USED
;
199 qe
->aq_e_callback_data
= cbdataReference(request
);
201 qe
->theFile
= cbdataReference(this);
203 qe
->aq_e_type
= AQ_ENTRY_WRITE
;
205 qe
->aq_e_free
= request
->free_func
;
207 qe
->aq_e_buf
= (void *)request
->buf
;
211 qe
->aq_e_aiocb
.aio_fildes
= fd
;
213 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
215 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
217 qe
->aq_e_aiocb
.aio_buf
= (void *)request
->buf
;
220 ++strategy
->aq
.aq_numpending
;
223 if (aio_write(&qe
->aq_e_aiocb
) < 0) {
224 fatalf("Aiee! aio_write() returned error (%d) FIXME and wrap file_write !\n", errno
);
225 debugs(79, 1, "WARNING: aio_write() returned error: " << xstrerror());
226 /* fall back to blocking method */
227 // file_write(fd, offset, buf, len, callback, data, freefunc);
232 AIODiskFile::close ()
243 assert (ioRequestor
!= NULL
);
244 ioRequestor
->closeCompleted();
248 AIODiskFile::canRead() const
254 AIODiskFile::canWrite() const
260 AIODiskFile::getFD() const
266 AIODiskFile::error() const
272 AIODiskFile::ioInProgress() const