ModEpoll.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* DEBUG: section 05 Socket Functions */
10 
11 /*
12  * The idea for this came from these two websites:
13  * http://www.xmailserver.org/linux-patches/nio-improve.html
14  * http://www.kegel.com/c10k.html
15  *
16  * This is to support the epoll sysctl being added to the linux 2.5
17  * kernel tree. The new sys_epoll is an event based poller without
18  * most of the fuss of rtsignals.
19  *
20  * -- David Nicklay <dnicklay@web.turner.com>
21  */
22 
23 /*
24  * XXX Currently not implemented / supported by this module XXX
25  *
26  * - delay pools
27  * - deferred reads
28  *
29  */
30 
31 #include "squid.h"
32 
33 #if USE_EPOLL
34 
35 #include "base/CodeContext.h"
36 #include "comm/Loops.h"
37 #include "fde.h"
38 #include "globals.h"
39 #include "mgr/Registration.h"
40 #include "StatCounters.h"
41 #include "StatHist.h"
42 #include "Store.h"
43 
44 #define DEBUG_EPOLL 0
45 
46 #include <cerrno>
47 #if HAVE_SYS_EPOLL_H
48 #include <sys/epoll.h>
49 #endif
50 
51 static int kdpfd = -1;
52 static int max_poll_time = 1000;
53 
54 static struct epoll_event *pevents;
55 
56 static void commEPollRegisterWithCacheManager(void);
57 
58 /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
59 /* Public functions */
60 
61 /*
62  * This is a needed exported function which will be called to initialise
63  * the network loop code.
64  */
65 void
67 {
68  pevents = (struct epoll_event *) xmalloc(SQUID_MAXFD * sizeof(struct epoll_event));
69 
70  if (!pevents) {
71  int xerrno = errno;
72  fatalf("comm_select_init: xmalloc() failed: %s\n", xstrerr(xerrno));
73  }
74 
75  kdpfd = epoll_create(SQUID_MAXFD);
76 
77  if (kdpfd < 0) {
78  int xerrno = errno;
79  fatalf("comm_select_init: epoll_create(): %s\n", xstrerr(xerrno));
80  }
81 
83 }
84 
85 static const char* epolltype_atoi(int x)
86 {
87  switch (x) {
88 
89  case EPOLL_CTL_ADD:
90  return "EPOLL_CTL_ADD";
91 
92  case EPOLL_CTL_DEL:
93  return "EPOLL_CTL_DEL";
94 
95  case EPOLL_CTL_MOD:
96  return "EPOLL_CTL_MOD";
97 
98  default:
99  return "UNKNOWN_EPOLLCTL_OP";
100  }
101 }
102 
107 void
108 Comm::SetSelect(int fd, unsigned int type, PF * handler, void *client_data, time_t timeout)
109 {
110  fde *F = &fd_table[fd];
111  int epoll_ctl_type = 0;
112 
113  assert(fd >= 0);
114  debugs(5, 5, "FD " << fd << ", type=" << type <<
115  ", handler=" << handler << ", client_data=" << client_data <<
116  ", timeout=" << timeout);
117 
118  struct epoll_event ev;
119  memset(&ev, 0, sizeof(ev));
120  ev.data.fd = fd;
121 
122  if (!F->flags.open) {
123  epoll_ctl(kdpfd, EPOLL_CTL_DEL, fd, &ev);
124  return;
125  }
126 
127  // If read is an interest
128 
129  if (type & COMM_SELECT_READ) {
130  if (handler) {
131  // Hack to keep the events flowing if there is data immediately ready
132  if (F->flags.read_pending)
133  ev.events |= EPOLLOUT;
134  ev.events |= EPOLLIN;
135  }
136 
137  F->read_handler = handler;
138 
139  F->read_data = client_data;
140 
141  // Otherwise, use previously stored value
142  } else if (F->epoll_state & EPOLLIN) {
143  ev.events |= EPOLLIN;
144  }
145 
146  // If write is an interest
147  if (type & COMM_SELECT_WRITE) {
148  if (handler)
149  ev.events |= EPOLLOUT;
150 
151  F->write_handler = handler;
152 
153  F->write_data = client_data;
154 
155  // Otherwise, use previously stored value
156  } else if (F->epoll_state & EPOLLOUT) {
157  ev.events |= EPOLLOUT;
158  }
159 
160  if (ev.events)
161  ev.events |= EPOLLHUP | EPOLLERR;
162 
163  if (ev.events != F->epoll_state) {
164  if (F->epoll_state) // already monitoring something.
165  epoll_ctl_type = ev.events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL;
166  else
167  epoll_ctl_type = EPOLL_CTL_ADD;
168 
169  F->epoll_state = ev.events;
170 
171  if (epoll_ctl(kdpfd, epoll_ctl_type, fd, &ev) < 0) {
172  int xerrno = errno;
173  debugs(5, DEBUG_EPOLL ? 0 : 8, "ERROR: epoll_ctl(," << epolltype_atoi(epoll_ctl_type) <<
174  ",,): failed on FD " << fd << ": " << xstrerr(xerrno));
175  }
176  }
177 
178  if (timeout)
179  F->timeout = squid_curtime + timeout;
180 
181  if (timeout || handler) // all non-cleanup requests
182  F->codeContext = CodeContext::Current(); // TODO: Avoid clearing if set?
183  else if (!ev.events) // full cleanup: no more FD-associated work expected
184  F->codeContext = nullptr;
185  // else: direction-specific/timeout cleanup requests preserve F->codeContext
186 }
187 
188 static void commIncomingStats(StoreEntry * sentry);
189 
190 static void
192 {
193  Mgr::RegisterAction("comm_epoll_incoming",
194  "comm_incoming() stats",
195  commIncomingStats, 0, 1);
196 }
197 
198 static void
200 {
202  storeAppendPrintf(sentry, "Total number of epoll(2) loops: %ld\n", statCounter.select_loops);
203  storeAppendPrintf(sentry, "Histogram of returned filedescriptors\n");
205 }
206 
218 Comm::DoSelect(int msec)
219 {
220  int num, i,fd;
221  fde *F;
222  PF *hdl;
223 
224  struct epoll_event *cevents;
225 
226  if (msec > max_poll_time)
227  msec = max_poll_time;
228 
229  for (;;) {
230  num = epoll_wait(kdpfd, pevents, SQUID_MAXFD, msec);
232 
233  if (num >= 0)
234  break;
235 
236  if (ignoreErrno(errno))
237  break;
238 
239  getCurrentTime();
240 
241  return Comm::COMM_ERROR;
242  }
243 
244  getCurrentTime();
245 
247 
248  if (num == 0)
249  return Comm::TIMEOUT; /* No error.. */
250 
251  for (i = 0, cevents = pevents; i < num; ++i, ++cevents) {
252  fd = cevents->data.fd;
253  F = &fd_table[fd];
254  CodeContext::Reset(F->codeContext);
255  debugs(5, DEBUG_EPOLL ? 0 : 8, "got FD " << fd << " events=" <<
256  std::hex << cevents->events << " monitoring=" << F->epoll_state <<
257  " F->read_handler=" << F->read_handler << " F->write_handler=" << F->write_handler);
258 
259  // TODO: add EPOLLPRI??
260 
261  if (cevents->events & (EPOLLIN|EPOLLHUP|EPOLLERR) || F->flags.read_pending) {
262  if ((hdl = F->read_handler) != nullptr) {
263  debugs(5, DEBUG_EPOLL ? 0 : 8, "Calling read handler on FD " << fd);
264  F->read_handler = nullptr;
265  hdl(fd, F->read_data);
267  } else {
268  debugs(5, DEBUG_EPOLL ? 0 : 8, "no read handler for FD " << fd);
269  // remove interest since no handler exist for this event.
270  SetSelect(fd, COMM_SELECT_READ, nullptr, nullptr, 0);
271  }
272  }
273 
274  if (cevents->events & (EPOLLOUT|EPOLLHUP|EPOLLERR)) {
275  if ((hdl = F->write_handler) != nullptr) {
276  debugs(5, DEBUG_EPOLL ? 0 : 8, "Calling write handler on FD " << fd);
277  F->write_handler = nullptr;
278  hdl(fd, F->write_data);
280  } else {
281  debugs(5, DEBUG_EPOLL ? 0 : 8, "no write handler for FD " << fd);
282  // remove interest since no handler exist for this event.
283  SetSelect(fd, COMM_SELECT_WRITE, nullptr, nullptr, 0);
284  }
285  }
286  }
287 
289 
290  return Comm::OK;
291 }
292 
293 void
295 {
296  max_poll_time = 10;
297 }
298 
299 #endif /* USE_EPOLL */
300 
static int max_poll_time
Definition: ModEpoll.cc:52
static int kdpfd
Definition: ModEpoll.cc:51
static struct epoll_event * pevents
Definition: ModEpoll.cc:54
static void commIncomingStats(StoreEntry *sentry)
Definition: ModEpoll.cc:199
static void commEPollRegisterWithCacheManager(void)
Definition: ModEpoll.cc:191
#define DEBUG_EPOLL
Definition: ModEpoll.cc:44
static const char * epolltype_atoi(int x)
Definition: ModEpoll.cc:85
time_t squid_curtime
Definition: stub_libtime.cc:20
StatCounters statCounter
Definition: StatCounters.cc:12
StatHistBinDumper statHistIntDumper
Definition: StatHist.h:119
#define assert(EX)
Definition: assert.h:19
static const Pointer & Current()
Definition: CodeContext.cc:33
static void Reset()
forgets the current context, setting it to nil/unknown
Definition: CodeContext.cc:75
StatHist select_fds_hist
Definition: StatCounters.h:127
unsigned long int select_loops
Definition: StatCounters.h:118
void count(double val)
Definition: StatHist.cc:55
void dump(StoreEntry *sentry, StatHistBinDumper *bd) const
Definition: StatHist.cc:171
Definition: fde.h:52
void PF(int, void *)
Definition: forward.h:18
int ignoreErrno(int ierrno)
Definition: comm.cc:1412
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Stream.h:196
#define COMM_SELECT_READ
Definition: defines.h:24
#define COMM_SELECT_WRITE
Definition: defines.h:25
int type
Definition: errorpage.cc:152
void fatalf(const char *fmt,...)
Definition: fatal.cc:68
#define fd_table
Definition: fde.h:189
static uint32 F(uint32 X, uint32 Y, uint32 Z)
Definition: md4.c:46
void QuickPollRequired(void)
Definition: ModDevPoll.cc:417
Flag
Definition: Flag.h:15
@ OK
Definition: Flag.h:16
@ TIMEOUT
Definition: Flag.h:19
@ COMM_ERROR
Definition: Flag.h:17
Comm::Flag DoSelect(int)
Do poll and trigger callback functions as appropriate.
Definition: ModDevPoll.cc:311
void SelectLoopInit(void)
Initialize the module on Squid startup.
Definition: ModDevPoll.cc:176
void SetSelect(int, unsigned int, PF *, void *, time_t)
Mark an FD to be watched for its IO status.
Definition: ModDevPoll.cc:223
void RegisterAction(char const *action, char const *desc, OBJH *handler, int pw_req_flag, int atomic)
Definition: Registration.cc:16
#define xmalloc
static void handler(int signo)
Definition: purge.cc:854
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
Definition: store.cc:830
time_t getCurrentTime() STUB_RETVAL(0) int tvSubUsec(struct timeval
const char * xstrerr(int error)
Definition: xstrerror.cc:83

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors