]>
git.ipfire.org Git - thirdparty/squid.git/blob - src/comm/ModKqueue.cc
2 * DEBUG: section 05 Socket Functions
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.
33 * This code was originally written by Benno Rice and hacked on quite
34 * a bit by Adrian. Adrian then took it to the hybrid-ircd project to use
35 * in their new IO subsystem. After a year of modifications and some
36 * rather interesting changes (event aggregation) its back in squid.
37 * Thanks to the ircd-hybrid guys.
41 * XXX Currently not implemented / supported by this module XXX
45 * - flags.read_pending
47 * So, its not entirely useful in a production setup since if a read
48 * is meant to be deferred it isn't (we're not even throwing the event
49 * away here). Eventually the rest of the code will be rewritten
50 * so deferred reads aren't required.
56 #include "comm/Loops.h"
59 #include "SquidTime.h"
60 #include "StatCounters.h"
64 #include <sys/event.h>
72 /* jlemon goofed up and didn't add EV_SET until fbsd 4.3 */
75 #define EV_SET(kevp, a, b, c, d, e, f) do { \
76 (kevp)->ident = (a); \
77 (kevp)->filter = (b); \
78 (kevp)->flags = (c); \
79 (kevp)->fflags = (d); \
81 (kevp)->udata = (f); \
85 static void kq_update_events(int, short, PF
*);
88 static struct timespec zero_timespec
;
90 static struct kevent
*kqlst
; /* kevent buffer */
91 static int kqmax
; /* max structs to buffer */
92 static int kqoff
; /* offset into the buffer */
93 static int max_poll_time
= 1000;
95 static void commKQueueRegisterWithCacheManager(void);
97 /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
98 /* Private functions */
101 kq_update_events(int fd
, short filter
, PF
* handler
)
109 cur_handler
= fd_table
[fd
].read_handler
;
113 cur_handler
= fd_table
[fd
].write_handler
;
117 /* XXX bad! -- adrian */
122 if ((cur_handler
== NULL
&& handler
!= NULL
)
123 || (cur_handler
!= NULL
&& handler
== NULL
)) {
129 if (handler
!= NULL
) {
130 kep_flags
= (EV_ADD
| EV_ONESHOT
);
132 kep_flags
= EV_DELETE
;
135 EV_SET(kep
, (uintptr_t) fd
, filter
, kep_flags
, 0, 0, 0);
137 /* Check if we've used the last one. If we have then submit them all */
138 if (kqoff
== kqmax
- 1) {
141 ret
= kevent(kq
, kqlst
, kqmax
, NULL
, 0, &zero_timespec
);
142 /* jdc -- someone needs to do error checking... */
145 perror("kq_update_events(): kevent()");
156 /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
157 /* Public functions */
162 * This is a needed exported function which will be called to initialise
163 * the network loop code.
166 Comm::SelectLoopInit(void)
171 fatal("comm_select_init: Couldn't open kqueue fd!\n");
174 kqmax
= getdtablesize();
176 kqlst
= (struct kevent
*)xmalloc(sizeof(*kqlst
) * kqmax
);
177 zero_timespec
.tv_sec
= 0;
178 zero_timespec
.tv_nsec
= 0;
180 commKQueueRegisterWithCacheManager();
186 * This is a needed exported function which will be called to register
187 * and deregister interest in a pending IO state for a given FD.
190 Comm::SetSelect(int fd
, unsigned int type
, PF
* handler
, void *client_data
, time_t timeout
)
192 fde
*F
= &fd_table
[fd
];
194 assert(F
->flags
.open
);
195 debugs(5, 5, HERE
<< "FD " << fd
<< ", type=" << type
<<
196 ", handler=" << handler
<< ", client_data=" << client_data
<<
197 ", timeout=" << timeout
);
199 if (type
& COMM_SELECT_READ
) {
200 kq_update_events(fd
, EVFILT_READ
, handler
);
201 F
->read_handler
= handler
;
202 F
->read_data
= client_data
;
205 if (type
& COMM_SELECT_WRITE
) {
206 kq_update_events(fd
, EVFILT_WRITE
, handler
);
207 F
->write_handler
= handler
;
208 F
->write_data
= client_data
;
212 F
->timeout
= squid_curtime
+ timeout
;
217 Comm::ResetSelect(int fd
)
219 fde
*F
= &fd_table
[fd
];
220 if (F
->read_handler
) {
221 kq_update_events(fd
, EVFILT_READ
, (PF
*)1);
223 if (F
->write_handler
) {
224 kq_update_events(fd
, EVFILT_WRITE
, (PF
*)1);
229 * Check all connections for new connections and input data that is to be
230 * processed. Also check for connections with data queued and whether we can
237 * Called to do the new-style IO, courtesy of of squid (like most of this
238 * new IO code). This routine handles the stuff we've hidden in
239 * comm_setselect and fd_table[] and calls callbacks for IO ready
244 Comm::DoSelect(int msec
)
248 static struct kevent ke
[KE_LENGTH
];
250 struct timespec poll_time
;
252 if (msec
> max_poll_time
)
253 msec
= max_poll_time
;
255 poll_time
.tv_sec
= msec
/ 1000;
257 poll_time
.tv_nsec
= (msec
% 1000) * 1000000;
260 num
= kevent(kq
, kqlst
, kqoff
, ke
, KE_LENGTH
, &poll_time
);
261 ++statCounter
.select_loops
;
267 if (ignoreErrno(errno
))
280 return COMM_OK
; /* No error.. */
282 for (i
= 0; i
< num
; ++i
) {
283 int fd
= (int) ke
[i
].ident
;
285 fde
*F
= &fd_table
[fd
];
287 if (ke
[i
].flags
& EV_ERROR
) {
289 /* XXX error == bad! -- adrian */
293 switch (ke
[i
].filter
) {
297 if ((hdl
= F
->read_handler
) != NULL
) {
298 F
->read_handler
= NULL
;
299 F
->flags
.read_pending
= 0;
300 hdl(fd
, F
->read_data
);
307 if ((hdl
= F
->write_handler
) != NULL
) {
308 F
->write_handler
= NULL
;
309 hdl(fd
, F
->write_data
);
316 debugs(5, DBG_IMPORTANT
, "comm_select: kevent returned " << ke
[i
].filter
<< "!");
325 Comm::QuickPollRequired(void)
331 commKQueueRegisterWithCacheManager(void)
335 #endif /* USE_KQUEUE */