]>
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"
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
.unsafeBuf(), flags
);
93 fd
= file_open(path
.unsafeBuf() , flags
);
96 ioRequestor
= callback
;
99 debugs(79, 3, HERE
<< ": got failure (" << errno
<< ")");
103 store_open_disk_fd
++;
104 debugs(79, 3, HERE
<< ": opened FD " << fd
);
107 callback
->ioCompletedNotification();
111 AIODiskFile::create(int flags
, mode_t mode
, RefCount
<IORequestor
> callback
)
113 /* We use the same logic path for open */
114 open(flags
, mode
, callback
);
118 AIODiskFile::read(ReadRequest
*request
)
121 async_queue_entry_t
*qe
;
123 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
125 /* Find a free slot */
126 slot
= strategy
->findSlot();
129 /* No free slot? Callback error, and return */
130 fatal("Aiee! out of aiocb slots! - FIXME and wrap file_read\n");
131 debugs(79, 1, "WARNING: out of aiocb slots!");
132 /* fall back to blocking method */
133 // file_read(fd, request->unsafeBuf, request->len, request->offset, callback, data);
137 /* Mark slot as ours */
138 qe
= &strategy
->aq
.aq_queue
[slot
];
140 qe
->aq_e_state
= AQ_ENTRY_USED
;
142 qe
->aq_e_callback_data
= cbdataReference(request
);
144 qe
->theFile
= cbdataReference(this);
146 qe
->aq_e_type
= AQ_ENTRY_READ
;
148 qe
->aq_e_free
= NULL
;
150 qe
->aq_e_buf
= request
->buf
;
152 qe
->aq_e_fd
= getFD();
154 qe
->aq_e_aiocb
.aio_fildes
= getFD();
156 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
158 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
160 qe
->aq_e_aiocb
.aio_buf
= request
->buf
;
163 strategy
->aq
.aq_numpending
++;
166 if (aio_read(&qe
->aq_e_aiocb
) < 0) {
167 fatalf("Aiee! aio_read() returned error (%d) FIXME and wrap file_read !\n", errno
);
168 debugs(79, 1, "WARNING: aio_read() returned error: " << xstrerror());
169 /* fall back to blocking method */
170 // file_read(fd, request->unsafeBuf, request->len, request->offset, callback, data);
176 AIODiskFile::write(WriteRequest
*request
)
179 async_queue_entry_t
*qe
;
181 assert(strategy
->aq
.aq_state
== AQ_STATE_SETUP
);
183 /* Find a free slot */
184 slot
= strategy
->findSlot();
187 /* No free slot? Callback error, and return */
188 fatal("Aiee! out of aiocb slots FIXME and wrap file_write !\n");
189 debugs(79, 1, "WARNING: out of aiocb slots!");
190 /* fall back to blocking method */
191 // file_write(fd, offset, unsafeBuf, len, callback, data, freefunc);
195 /* Mark slot as ours */
196 qe
= &strategy
->aq
.aq_queue
[slot
];
198 qe
->aq_e_state
= AQ_ENTRY_USED
;
200 qe
->aq_e_callback_data
= cbdataReference(request
);
202 qe
->theFile
= cbdataReference(this);
204 qe
->aq_e_type
= AQ_ENTRY_WRITE
;
206 qe
->aq_e_free
= request
->free_func
;
208 qe
->aq_e_buf
= (void *)request
->buf
;
212 qe
->aq_e_aiocb
.aio_fildes
= fd
;
214 qe
->aq_e_aiocb
.aio_nbytes
= request
->len
;
216 qe
->aq_e_aiocb
.aio_offset
= request
->offset
;
218 qe
->aq_e_aiocb
.aio_buf
= (void *)request
->buf
;
221 ++strategy
->aq
.aq_numpending
;
224 if (aio_write(&qe
->aq_e_aiocb
) < 0) {
225 fatalf("Aiee! aio_write() returned error (%d) FIXME and wrap file_write !\n", errno
);
226 debugs(79, 1, "WARNING: aio_write() returned error: " << xstrerror());
227 /* fall back to blocking method */
228 // file_write(fd, offset, unsafeBuf, len, callback, data, freefunc);
233 AIODiskFile::close ()
246 assert (ioRequestor
!= NULL
);
247 ioRequestor
->closeCompleted();
251 AIODiskFile::canRead() const
257 AIODiskFile::canWrite() const
263 AIODiskFile::getFD() const
269 AIODiskFile::error() const
275 AIODiskFile::ioInProgress() const