← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/nginx/jaunty-updates

« back to all changes in this revision

Viewing changes to src/event/modules/ngx_devpoll_module.c

  • Committer: Bazaar Package Importer
  • Author(s): Jose Parrella
  • Date: 2007-12-08 11:27:54 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071208112754-23ohg2b1zshkdayw
Tags: 0.5.33-1
http://bugs.debian.org/451173
http://bugs.debian.org/439468
http://bugs.debian.org/452025
http://bugs.debian.org/432961
http://bugs.debian.org/445246
http://bugs.debian.org/452787
http://bugs.debian.org/435965
* New stable upstream release (Closes: #451173)
* nginx now provides httpd, httpd-cgi virtual packages
  (Closes: #439468, #452025)
* sites-enabled/default link is now provided only on fresh 
  installations (Closes: #432961)
* Updated code for online upgrading of nginx (Closes: #445246)
* Reviewed maintainer scripts for correct behaviour on updates
  (Closes: #452787, #435965)
* Removed debian/nginx.links and debian/preinst.
* Changing Maintainer address to bureado@debian.org.
* Welcoming Fabio Tranchitella <kobold@debian.org> as an nginx 
  uploader for Debian. Thanks for your patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/event/modules/ngx_devpoll_module.c
15
15
 
16
16
#define POLLREMOVE   0x0800
17
17
#define DP_POLL      0xD001
 
18
#define DP_ISPOLLED  0xD002
18
19
 
19
20
struct dvpoll {
20
21
    struct pollfd  *dp_fds;
26
27
 
27
28
 
28
29
typedef struct {
29
 
    u_int  changes;
30
 
    u_int  events;
 
30
    ngx_uint_t      changes;
 
31
    ngx_uint_t      events;
31
32
} ngx_devpoll_conf_t;
32
33
 
33
34
 
34
35
static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
35
36
static void ngx_devpoll_done(ngx_cycle_t *cycle);
36
 
static ngx_int_t ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags);
37
 
static ngx_int_t ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags);
38
 
static ngx_int_t ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags);
 
37
static ngx_int_t ngx_devpoll_add_event(ngx_event_t *ev, ngx_int_t event,
 
38
    ngx_uint_t flags);
 
39
static ngx_int_t ngx_devpoll_del_event(ngx_event_t *ev, ngx_int_t event,
 
40
    ngx_uint_t flags);
 
41
static ngx_int_t ngx_devpoll_set_event(ngx_event_t *ev, ngx_int_t event,
 
42
    ngx_uint_t flags);
39
43
static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle,
40
44
    ngx_msec_t timer, ngx_uint_t flags);
41
45
 
44
48
 
45
49
static int              dp = -1;
46
50
static struct pollfd   *change_list, *event_list;
47
 
static u_int            nchanges, max_changes, nevents;
 
51
static ngx_uint_t       nchanges, max_changes, nevents;
48
52
 
49
53
static ngx_event_t    **change_index;
50
54
 
208
212
 
209
213
 
210
214
static ngx_int_t
211
 
ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags)
 
215
ngx_devpoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
212
216
{
213
217
#if (NGX_DEBUG)
214
218
    ngx_connection_t *c;
221
225
#if (NGX_DEBUG)
222
226
    c = ev->data;
223
227
    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
224
 
                   "devpoll add event: fd:%d ev:%04Xd", c->fd, event);
 
228
                   "devpoll add event: fd:%d ev:%04Xi", c->fd, event);
225
229
#endif
226
230
 
227
231
    ev->active = 1;
231
235
 
232
236
 
233
237
static ngx_int_t
234
 
ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags)
 
238
ngx_devpoll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
235
239
{
236
240
    ngx_event_t       *e;
237
241
    ngx_connection_t  *c;
243
247
#endif
244
248
 
245
249
    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
246
 
                   "devpoll del event: fd:%d ev:%04Xd", c->fd, event);
 
250
                   "devpoll del event: fd:%d ev:%04Xi", c->fd, event);
247
251
 
248
252
    if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) {
249
253
        return NGX_ERROR;
252
256
    ev->active = 0;
253
257
 
254
258
    if (flags & NGX_CLOSE_EVENT) {
 
259
        e = (event == POLLIN) ? c->write : c->read;
 
260
 
 
261
        if (e) {
 
262
            e->active = 0;
 
263
        }
 
264
 
255
265
        return NGX_OK;
256
266
    }
257
267
 
258
 
    /* restore the paired event if it exists */
 
268
    /* restore the pair event if it exists */
259
269
 
260
270
    if (event == POLLIN) {
261
271
        e = c->write;
275
285
 
276
286
 
277
287
static ngx_int_t
278
 
ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags)
 
288
ngx_devpoll_set_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
279
289
{
280
290
    size_t             n;
281
291
    ngx_connection_t  *c;
283
293
    c = ev->data;
284
294
 
285
295
    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
286
 
                   "devpoll fd:%d ev:%04Xd fl:%04Xd", c->fd, event, flags);
 
296
                   "devpoll fd:%d ev:%04Xi fl:%04Xi", c->fd, event, flags);
287
297
 
288
298
    if (nchanges >= max_changes) {
289
299
        ngx_log_error(NGX_LOG_WARN, ev->log, 0,
300
310
    }
301
311
 
302
312
    change_list[nchanges].fd = c->fd;
303
 
    change_list[nchanges].events = event;
 
313
    change_list[nchanges].events = (short) event;
304
314
    change_list[nchanges].revents = 0;
305
315
 
306
316
    change_index[nchanges] = ev;
327
337
ngx_devpoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
328
338
    ngx_uint_t flags)
329
339
{
330
 
    int                 events, revents;
 
340
    int                 events, revents, rc;
331
341
    size_t              n;
 
342
    ngx_fd_t            fd;
332
343
    ngx_err_t           err;
333
344
    ngx_int_t           i;
334
345
    ngx_uint_t          level;
335
346
    ngx_event_t        *rev, *wev, **queue;
336
347
    ngx_connection_t   *c;
 
348
    struct pollfd       pfd;
337
349
    struct dvpoll       dvp;
338
350
 
339
351
    /* NGX_TIMER_INFINITE == INFTIM */
353
365
    }
354
366
 
355
367
    dvp.dp_fds = event_list;
356
 
    dvp.dp_nfds = nevents;
 
368
    dvp.dp_nfds = (int) nevents;
357
369
    dvp.dp_timeout = timer;
358
370
    events = ioctl(dp, DP_POLL, &dvp);
359
371
 
398
410
    ngx_mutex_lock(ngx_posted_events_mutex);
399
411
 
400
412
    for (i = 0; i < events; i++) {
401
 
        c = ngx_cycle->files[event_list[i].fd];
402
 
 
403
 
        if (c->fd == -1) {
404
 
            if (c->read->closed) {
405
 
                continue;
 
413
 
 
414
        fd = event_list[i].fd;
 
415
        revents = event_list[i].revents;
 
416
 
 
417
        c = ngx_cycle->files[fd];
 
418
 
 
419
        if (c == NULL || c->fd == -1) {
 
420
 
 
421
            pfd.fd = fd;
 
422
            pfd.events = 0;
 
423
            pfd.revents = 0;
 
424
 
 
425
            rc = ioctl(dp, DP_ISPOLLED, &pfd);
 
426
 
 
427
            switch (rc) {
 
428
 
 
429
            case -1:
 
430
                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 
431
                    "ioctl(DP_ISPOLLED) failed for socket %d, event",
 
432
                    fd, revents);
 
433
                break;
 
434
 
 
435
            case 0:
 
436
                ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 
437
                    "phantom event %04Xd for closed and removed socket %d",
 
438
                    revents, fd);
 
439
                break;
 
440
 
 
441
            default:
 
442
                ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 
443
                    "unexpected event %04Xd for closed and removed socket %d, ",
 
444
                    "ioctl(DP_ISPOLLED) returned rc:%d, fd:%d, event %04Xd",
 
445
                    revents, fd, rc, pfd.fd, pfd.revents);
 
446
 
 
447
                pfd.fd = fd;
 
448
                pfd.events = POLLREMOVE;
 
449
                pfd.revents = 0;
 
450
 
 
451
                if (write(dp, &pfd, sizeof(struct pollfd))
 
452
                    != (ssize_t) sizeof(struct pollfd))
 
453
                {
 
454
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 
455
                                  "write(/dev/poll) for %d failed, fd");
 
456
                }
 
457
 
 
458
                if (close(fd) == -1) {
 
459
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 
460
                                  "close(%d) failed", fd);
 
461
                }
 
462
 
 
463
                break;
406
464
            }
407
465
 
408
 
            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");
409
466
            continue;
410
467
        }
411
468
 
412
 
        revents = event_list[i].revents;
413
 
 
414
469
        ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
415
470
                       "devpoll: fd:%d, ev:%04Xd, rev:%04Xd",
416
 
                       event_list[i].fd, event_list[i].events, revents);
 
471
                       fd, event_list[i].events, revents);
417
472
 
418
473
        if (revents & (POLLERR|POLLHUP|POLLNVAL)) {
419
474
            ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
420
475
                          "ioctl(DP_POLL) error fd:%d ev:%04Xd rev:%04Xd",
421
 
                          event_list[i].fd, event_list[i].events, revents);
 
476
                          fd, event_list[i].events, revents);
422
477
        }
423
478
 
424
479
        if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
425
480
            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
426
481
                          "strange ioctl(DP_POLL) events "
427
482
                          "fd:%d ev:%04Xd rev:%04Xd",
428
 
                          event_list[i].fd, event_list[i].events, revents);
 
483
                          fd, event_list[i].events, revents);
429
484
        }
430
485
 
431
486
        if ((revents & (POLLERR|POLLHUP|POLLNVAL))