2 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "poll-loop.h"
25 #include "dynamic-string.h"
26 #include "fatal-signal.h"
28 #include "ovs-thread.h"
30 #include "socket-util.h"
36 VLOG_DEFINE_THIS_MODULE(poll_loop
);
38 COVERAGE_DEFINE(poll_fd_wait
);
39 COVERAGE_DEFINE(poll_zero_timeout
);
42 struct hmap_node hmap_node
;
43 struct pollfd pollfd
; /* Events to pass to time_poll(). */
44 HANDLE wevent
; /* Events for WaitForMultipleObjects(). */
45 const char *where
; /* Where poll_node was created. */
49 /* All active poll waiters. */
50 struct hmap poll_nodes
;
52 /* Time at which to wake up the next call to poll_block(), LLONG_MIN to
53 * wake up immediately, or LLONG_MAX to wait forever. */
54 long long int timeout_when
; /* In msecs as returned by time_msec(). */
55 const char *timeout_where
; /* Where 'timeout_when' was set. */
58 static struct poll_loop
*poll_loop(void);
60 /* Look up the node with same fd and wevent. */
61 static struct poll_node
*
62 find_poll_node(struct poll_loop
*loop
, int fd
, uint32_t wevent
)
64 struct poll_node
*node
;
66 HMAP_FOR_EACH_WITH_HASH (node
, hmap_node
, hash_2words(fd
, wevent
),
68 if (node
->pollfd
.fd
== fd
&& node
->wevent
== wevent
) {
75 /* On Unix based systems:
77 * Registers 'fd' as waiting for the specified 'events' (which should be
78 * POLLIN or POLLOUT or POLLIN | POLLOUT). The following call to
79 * poll_block() will wake up when 'fd' becomes ready for one or more of the
80 * requested events. the 'fd's are given to poll() function later.
84 * If both 'wevent' handle and 'fd' is specified, associate the 'fd' with
85 * with that 'wevent' for 'events' (implemented in poll_block()).
86 * In case of no 'fd' specified, wake up on any event on that 'wevent'.
87 * These wevents are given to the WaitForMultipleObjects() to be polled.
88 * The event registration is one-shot: only the following call to
89 * poll_block() is affected. The event will need to be re-registered after
90 * poll_block() is called if it is to persist.
92 * ('where' is used in debug logging. Commonly one would use poll_fd_wait() to
93 * automatically provide the caller's source file and line number for
96 poll_fd_wait_at(int fd
, HANDLE wevent
, short int events
, const char *where
)
98 struct poll_loop
*loop
= poll_loop();
99 struct poll_node
*node
;
101 COVERAGE_INC(poll_fd_wait
);
104 /* Null event cannot be polled. */
106 VLOG_ERR("No event to wait fd %d", fd
);
113 /* Check for duplicate. If found, "or" the event. */
114 node
= find_poll_node(loop
, fd
, wevent
);
116 node
->pollfd
.events
|= events
;
118 node
= xzalloc(sizeof *node
);
119 hmap_insert(&loop
->poll_nodes
, &node
->hmap_node
,
120 hash_2words(fd
, wevent
));
121 node
->pollfd
.fd
= fd
;
122 node
->pollfd
.events
= events
;
123 node
->wevent
= wevent
;
128 /* Causes the following call to poll_block() to block for no more than 'msec'
129 * milliseconds. If 'msec' is nonpositive, the following call to poll_block()
130 * will not block at all.
132 * The timer registration is one-shot: only the following call to poll_block()
133 * is affected. The timer will need to be re-registered after poll_block() is
134 * called if it is to persist.
136 * ('where' is used in debug logging. Commonly one would use poll_timer_wait()
137 * to automatically provide the caller's source file and line number for
140 poll_timer_wait_at(long long int msec
, const char *where
)
142 long long int now
= time_msec();
146 /* Wake up immediately. */
148 } else if ((unsigned long long int) now
+ msec
<= LLONG_MAX
) {
152 /* now + msec would overflow. */
156 poll_timer_wait_until_at(when
, where
);
159 /* Causes the following call to poll_block() to wake up when the current time,
160 * as returned by time_msec(), reaches 'when' or later. If 'when' is earlier
161 * than the current time, the following call to poll_block() will not block at
164 * The timer registration is one-shot: only the following call to poll_block()
165 * is affected. The timer will need to be re-registered after poll_block() is
166 * called if it is to persist.
168 * ('where' is used in debug logging. Commonly one would use
169 * poll_timer_wait_until() to automatically provide the caller's source file
170 * and line number for 'where'.) */
172 poll_timer_wait_until_at(long long int when
, const char *where
)
174 struct poll_loop
*loop
= poll_loop();
175 if (when
< loop
->timeout_when
) {
176 loop
->timeout_when
= when
;
177 loop
->timeout_where
= where
;
181 /* Causes the following call to poll_block() to wake up immediately, without
184 * ('where' is used in debug logging. Commonly one would use
185 * poll_immediate_wake() to automatically provide the caller's source file and
186 * line number for 'where'.) */
188 poll_immediate_wake_at(const char *where
)
190 poll_timer_wait_at(0, where
);
193 /* Logs, if appropriate, that the poll loop was awakened by an event
194 * registered at 'where' (typically a source file and line number). The other
195 * arguments have two possible interpretations:
197 * - If 'pollfd' is nonnull then it should be the "struct pollfd" that caused
198 * the wakeup. 'timeout' is ignored.
200 * - If 'pollfd' is NULL then 'timeout' is the number of milliseconds after
201 * which the poll loop woke up.
204 log_wakeup(const char *where
, const struct pollfd
*pollfd
, int timeout
)
206 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(10, 10);
207 enum vlog_level level
;
211 cpu_usage
= get_cpu_usage();
212 if (VLOG_IS_DBG_ENABLED()) {
214 } else if (cpu_usage
> 50 && !VLOG_DROP_INFO(&rl
)) {
221 ds_put_cstr(&s
, "wakeup due to ");
223 char *description
= describe_fd(pollfd
->fd
);
224 if (pollfd
->revents
& POLLIN
) {
225 ds_put_cstr(&s
, "[POLLIN]");
227 if (pollfd
->revents
& POLLOUT
) {
228 ds_put_cstr(&s
, "[POLLOUT]");
230 if (pollfd
->revents
& POLLERR
) {
231 ds_put_cstr(&s
, "[POLLERR]");
233 if (pollfd
->revents
& POLLHUP
) {
234 ds_put_cstr(&s
, "[POLLHUP]");
236 if (pollfd
->revents
& POLLNVAL
) {
237 ds_put_cstr(&s
, "[POLLNVAL]");
239 ds_put_format(&s
, " on fd %d (%s)", pollfd
->fd
, description
);
242 ds_put_format(&s
, "%d-ms timeout", timeout
);
245 ds_put_format(&s
, " at %s", where
);
247 if (cpu_usage
>= 0) {
248 ds_put_format(&s
, " (%d%% CPU usage)", cpu_usage
);
250 VLOG(level
, "%s", ds_cstr(&s
));
255 free_poll_nodes(struct poll_loop
*loop
)
257 struct poll_node
*node
, *next
;
259 HMAP_FOR_EACH_SAFE (node
, next
, hmap_node
, &loop
->poll_nodes
) {
260 hmap_remove(&loop
->poll_nodes
, &node
->hmap_node
);
265 /* Blocks until one or more of the events registered with poll_fd_wait()
266 * occurs, or until the minimum duration registered with poll_timer_wait()
267 * elapses, or not at all if poll_immediate_wake() has been called. */
271 struct poll_loop
*loop
= poll_loop();
272 struct poll_node
*node
;
273 struct pollfd
*pollfds
;
274 HANDLE
*wevents
= NULL
;
279 /* Register fatal signal events before actually doing any real work for
283 if (loop
->timeout_when
== LLONG_MIN
) {
284 COVERAGE_INC(poll_zero_timeout
);
288 pollfds
= xmalloc(hmap_count(&loop
->poll_nodes
) * sizeof *pollfds
);
291 wevents
= xmalloc(hmap_count(&loop
->poll_nodes
) * sizeof *wevents
);
294 /* Populate with all the fds and events. */
296 HMAP_FOR_EACH (node
, hmap_node
, &loop
->poll_nodes
) {
297 pollfds
[i
] = node
->pollfd
;
299 wevents
[i
] = node
->wevent
;
300 if (node
->pollfd
.fd
&& node
->wevent
) {
301 short int wsa_events
= 0;
302 if (node
->pollfd
.events
& POLLIN
) {
303 wsa_events
|= FD_READ
| FD_ACCEPT
| FD_CLOSE
;
305 if (node
->pollfd
.events
& POLLOUT
) {
306 wsa_events
|= FD_WRITE
| FD_CONNECT
| FD_CLOSE
;
308 WSAEventSelect(node
->pollfd
.fd
, node
->wevent
, wsa_events
);
314 retval
= time_poll(pollfds
, hmap_count(&loop
->poll_nodes
), wevents
,
315 loop
->timeout_when
, &elapsed
);
317 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
318 VLOG_ERR_RL(&rl
, "poll: %s", ovs_strerror(-retval
));
319 } else if (!retval
) {
320 log_wakeup(loop
->timeout_where
, NULL
, elapsed
);
321 } else if (get_cpu_usage() > 50 || VLOG_IS_DBG_ENABLED()) {
323 HMAP_FOR_EACH (node
, hmap_node
, &loop
->poll_nodes
) {
324 if (pollfds
[i
].revents
) {
325 log_wakeup(node
->where
, &pollfds
[i
], 0);
331 free_poll_nodes(loop
);
332 loop
->timeout_when
= LLONG_MAX
;
333 loop
->timeout_where
= NULL
;
337 /* Handle any pending signals before doing anything else. */
344 free_poll_loop(void *loop_
)
346 struct poll_loop
*loop
= loop_
;
348 free_poll_nodes(loop
);
349 hmap_destroy(&loop
->poll_nodes
);
353 static struct poll_loop
*
356 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
357 static pthread_key_t key
;
358 struct poll_loop
*loop
;
360 if (ovsthread_once_start(&once
)) {
361 xpthread_key_create(&key
, free_poll_loop
);
362 ovsthread_once_done(&once
);
365 loop
= pthread_getspecific(key
);
367 loop
= xzalloc(sizeof *loop
);
368 hmap_init(&loop
->poll_nodes
);
369 xpthread_setspecific(key
, loop
);