diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/util/scheduler.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/util/scheduler.c')
-rw-r--r-- | src/util/scheduler.c | 1887 |
1 files changed, 956 insertions, 931 deletions
diff --git a/src/util/scheduler.c b/src/util/scheduler.c index f379bce42..89dba3799 100644 --- a/src/util/scheduler.c +++ b/src/util/scheduler.c | |||
@@ -28,9 +28,11 @@ | |||
28 | // DEBUG | 28 | // DEBUG |
29 | #include <inttypes.h> | 29 | #include <inttypes.h> |
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from(kind, "util-scheduler", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__) |
32 | 32 | ||
33 | #define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror(kind, "util-scheduler", syscall) | 33 | #define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror (kind, \ |
34 | "util-scheduler", \ | ||
35 | syscall) | ||
34 | 36 | ||
35 | 37 | ||
36 | #if HAVE_EXECINFO_H | 38 | #if HAVE_EXECINFO_H |
@@ -76,7 +78,8 @@ | |||
76 | * #GNUNET_SCHEDULER_do_work(). Contains the | 78 | * #GNUNET_SCHEDULER_do_work(). Contains the |
77 | * scheduler's internal state. | 79 | * scheduler's internal state. |
78 | */ | 80 | */ |
79 | struct GNUNET_SCHEDULER_Handle { | 81 | struct GNUNET_SCHEDULER_Handle |
82 | { | ||
80 | /** | 83 | /** |
81 | * Passed here to avoid constantly allocating/deallocating | 84 | * Passed here to avoid constantly allocating/deallocating |
82 | * this element, but generally we want to get rid of this. | 85 | * this element, but generally we want to get rid of this. |
@@ -128,7 +131,8 @@ struct GNUNET_SCHEDULER_Handle { | |||
128 | /** | 131 | /** |
129 | * Entry in list of pending tasks. | 132 | * Entry in list of pending tasks. |
130 | */ | 133 | */ |
131 | struct GNUNET_SCHEDULER_Task { | 134 | struct GNUNET_SCHEDULER_Task |
135 | { | ||
132 | /** | 136 | /** |
133 | * This is a linked list. | 137 | * This is a linked list. |
134 | */ | 138 | */ |
@@ -247,7 +251,8 @@ struct GNUNET_SCHEDULER_Task { | |||
247 | /** | 251 | /** |
248 | * A struct representing an event the select driver is waiting for | 252 | * A struct representing an event the select driver is waiting for |
249 | */ | 253 | */ |
250 | struct Scheduled { | 254 | struct Scheduled |
255 | { | ||
251 | struct Scheduled *prev; | 256 | struct Scheduled *prev; |
252 | 257 | ||
253 | struct Scheduled *next; | 258 | struct Scheduled *next; |
@@ -274,7 +279,8 @@ struct Scheduled { | |||
274 | /** | 279 | /** |
275 | * Driver context used by GNUNET_SCHEDULER_run | 280 | * Driver context used by GNUNET_SCHEDULER_run |
276 | */ | 281 | */ |
277 | struct DriverContext { | 282 | struct DriverContext |
283 | { | ||
278 | /** | 284 | /** |
279 | * the head of a DLL containing information about the events the | 285 | * the head of a DLL containing information about the events the |
280 | * select driver is waiting for | 286 | * select driver is waiting for |
@@ -356,12 +362,14 @@ static struct GNUNET_SCHEDULER_Task *active_task; | |||
356 | /** | 362 | /** |
357 | * Head of list of tasks ready to run right now, grouped by importance. | 363 | * Head of list of tasks ready to run right now, grouped by importance. |
358 | */ | 364 | */ |
359 | static struct GNUNET_SCHEDULER_Task *ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT]; | 365 | static struct |
366 | GNUNET_SCHEDULER_Task *ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT]; | ||
360 | 367 | ||
361 | /** | 368 | /** |
362 | * Tail of list of tasks ready to run right now, grouped by importance. | 369 | * Tail of list of tasks ready to run right now, grouped by importance. |
363 | */ | 370 | */ |
364 | static struct GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT]; | 371 | static struct |
372 | GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT]; | ||
365 | 373 | ||
366 | /** | 374 | /** |
367 | * Task for installing parent control handlers (it might happen that the | 375 | * Task for installing parent control handlers (it might happen that the |
@@ -423,8 +431,8 @@ static void *scheduler_select_cls; | |||
423 | * @return previously used select function, NULL for default | 431 | * @return previously used select function, NULL for default |
424 | */ | 432 | */ |
425 | void | 433 | void |
426 | GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, | 434 | GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select, |
427 | void *new_select_cls) | 435 | void *new_select_cls) |
428 | { | 436 | { |
429 | scheduler_select = new_select; | 437 | scheduler_select = new_select; |
430 | scheduler_select_cls = new_select_cls; | 438 | scheduler_select_cls = new_select_cls; |
@@ -438,11 +446,11 @@ GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, | |||
438 | * @return p on success, 0 on error | 446 | * @return p on success, 0 on error |
439 | */ | 447 | */ |
440 | static enum GNUNET_SCHEDULER_Priority | 448 | static enum GNUNET_SCHEDULER_Priority |
441 | check_priority(enum GNUNET_SCHEDULER_Priority p) | 449 | check_priority (enum GNUNET_SCHEDULER_Priority p) |
442 | { | 450 | { |
443 | if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT)) | 451 | if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT)) |
444 | return p; | 452 | return p; |
445 | GNUNET_assert(0); | 453 | GNUNET_assert (0); |
446 | return 0; /* make compiler happy */ | 454 | return 0; /* make compiler happy */ |
447 | } | 455 | } |
448 | 456 | ||
@@ -453,38 +461,39 @@ check_priority(enum GNUNET_SCHEDULER_Priority p) | |||
453 | * callback) | 461 | * callback) |
454 | */ | 462 | */ |
455 | struct GNUNET_TIME_Absolute | 463 | struct GNUNET_TIME_Absolute |
456 | get_timeout() | 464 | get_timeout () |
457 | { | 465 | { |
458 | struct GNUNET_SCHEDULER_Task *pos; | 466 | struct GNUNET_SCHEDULER_Task *pos; |
459 | struct GNUNET_TIME_Absolute now; | 467 | struct GNUNET_TIME_Absolute now; |
460 | struct GNUNET_TIME_Absolute timeout; | 468 | struct GNUNET_TIME_Absolute timeout; |
461 | 469 | ||
462 | pos = pending_timeout_head; | 470 | pos = pending_timeout_head; |
463 | now = GNUNET_TIME_absolute_get(); | 471 | now = GNUNET_TIME_absolute_get (); |
464 | timeout = GNUNET_TIME_UNIT_FOREVER_ABS; | 472 | timeout = GNUNET_TIME_UNIT_FOREVER_ABS; |
465 | if (NULL != pos) | 473 | if (NULL != pos) |
474 | { | ||
475 | if (0 != pos->reason) | ||
466 | { | 476 | { |
467 | if (0 != pos->reason) | 477 | return now; |
468 | { | 478 | } |
469 | return now; | 479 | else |
470 | } | 480 | { |
471 | else | 481 | timeout = pos->timeout; |
472 | { | ||
473 | timeout = pos->timeout; | ||
474 | } | ||
475 | } | 482 | } |
483 | } | ||
476 | for (pos = pending_head; NULL != pos; pos = pos->next) | 484 | for (pos = pending_head; NULL != pos; pos = pos->next) |
485 | { | ||
486 | if (0 != pos->reason) | ||
477 | { | 487 | { |
478 | if (0 != pos->reason) | 488 | return now; |
479 | { | 489 | } |
480 | return now; | 490 | else if ((pos->timeout.abs_value_us != |
481 | } | 491 | GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) && |
482 | else if ((pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) && | 492 | (timeout.abs_value_us > pos->timeout.abs_value_us)) |
483 | (timeout.abs_value_us > pos->timeout.abs_value_us)) | 493 | { |
484 | { | 494 | timeout = pos->timeout; |
485 | timeout = pos->timeout; | ||
486 | } | ||
487 | } | 495 | } |
496 | } | ||
488 | return timeout; | 497 | return timeout; |
489 | } | 498 | } |
490 | 499 | ||
@@ -495,13 +504,13 @@ get_timeout() | |||
495 | * @param task task ready for execution | 504 | * @param task task ready for execution |
496 | */ | 505 | */ |
497 | static void | 506 | static void |
498 | queue_ready_task(struct GNUNET_SCHEDULER_Task *task) | 507 | queue_ready_task (struct GNUNET_SCHEDULER_Task *task) |
499 | { | 508 | { |
500 | enum GNUNET_SCHEDULER_Priority p = check_priority(task->priority); | 509 | enum GNUNET_SCHEDULER_Priority p = check_priority (task->priority); |
501 | 510 | ||
502 | GNUNET_CONTAINER_DLL_insert(ready_head[p], | 511 | GNUNET_CONTAINER_DLL_insert (ready_head[p], |
503 | ready_tail[p], | 512 | ready_tail[p], |
504 | task); | 513 | task); |
505 | task->in_ready_list = GNUNET_YES; | 514 | task->in_ready_list = GNUNET_YES; |
506 | ready_count++; | 515 | ready_count++; |
507 | } | 516 | } |
@@ -514,30 +523,30 @@ queue_ready_task(struct GNUNET_SCHEDULER_Task *task) | |||
514 | * will be delayed until the next shutdown signal. | 523 | * will be delayed until the next shutdown signal. |
515 | */ | 524 | */ |
516 | void | 525 | void |
517 | GNUNET_SCHEDULER_shutdown() | 526 | GNUNET_SCHEDULER_shutdown () |
518 | { | 527 | { |
519 | struct GNUNET_SCHEDULER_Task *pos; | 528 | struct GNUNET_SCHEDULER_Task *pos; |
520 | 529 | ||
521 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 530 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
522 | "GNUNET_SCHEDULER_shutdown\n"); | 531 | "GNUNET_SCHEDULER_shutdown\n"); |
523 | if (NULL != install_parent_control_task) | 532 | if (NULL != install_parent_control_task) |
524 | { | 533 | { |
525 | GNUNET_SCHEDULER_cancel(install_parent_control_task); | 534 | GNUNET_SCHEDULER_cancel (install_parent_control_task); |
526 | install_parent_control_task = NULL; | 535 | install_parent_control_task = NULL; |
527 | } | 536 | } |
528 | if (NULL != shutdown_pipe_task) | 537 | if (NULL != shutdown_pipe_task) |
529 | { | 538 | { |
530 | GNUNET_SCHEDULER_cancel(shutdown_pipe_task); | 539 | GNUNET_SCHEDULER_cancel (shutdown_pipe_task); |
531 | shutdown_pipe_task = NULL; | 540 | shutdown_pipe_task = NULL; |
532 | } | 541 | } |
533 | while (NULL != (pos = shutdown_head)) | 542 | while (NULL != (pos = shutdown_head)) |
534 | { | 543 | { |
535 | GNUNET_CONTAINER_DLL_remove(shutdown_head, | 544 | GNUNET_CONTAINER_DLL_remove (shutdown_head, |
536 | shutdown_tail, | 545 | shutdown_tail, |
537 | pos); | 546 | pos); |
538 | pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; | 547 | pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; |
539 | queue_ready_task(pos); | 548 | queue_ready_task (pos); |
540 | } | 549 | } |
541 | } | 550 | } |
542 | 551 | ||
543 | 552 | ||
@@ -547,17 +556,17 @@ GNUNET_SCHEDULER_shutdown() | |||
547 | * @param t task to dump stack trace of | 556 | * @param t task to dump stack trace of |
548 | */ | 557 | */ |
549 | static void | 558 | static void |
550 | dump_backtrace(struct GNUNET_SCHEDULER_Task *t) | 559 | dump_backtrace (struct GNUNET_SCHEDULER_Task *t) |
551 | { | 560 | { |
552 | #if EXECINFO | 561 | #if EXECINFO |
553 | for (unsigned int i = 0; i < t->num_backtrace_strings; i++) | 562 | for (unsigned int i = 0; i < t->num_backtrace_strings; i++) |
554 | LOG(GNUNET_ERROR_TYPE_WARNING, | 563 | LOG (GNUNET_ERROR_TYPE_WARNING, |
555 | "Task %p trace %u: %s\n", | 564 | "Task %p trace %u: %s\n", |
556 | t, | 565 | t, |
557 | i, | 566 | i, |
558 | t->backtrace_strings[i]); | 567 | t->backtrace_strings[i]); |
559 | #else | 568 | #else |
560 | (void)t; | 569 | (void) t; |
561 | #endif | 570 | #endif |
562 | } | 571 | } |
563 | 572 | ||
@@ -568,40 +577,41 @@ dump_backtrace(struct GNUNET_SCHEDULER_Task *t) | |||
568 | * @param t task to destroy | 577 | * @param t task to destroy |
569 | */ | 578 | */ |
570 | static void | 579 | static void |
571 | destroy_task(struct GNUNET_SCHEDULER_Task *t) | 580 | destroy_task (struct GNUNET_SCHEDULER_Task *t) |
572 | { | 581 | { |
573 | unsigned int i; | 582 | unsigned int i; |
574 | 583 | ||
575 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 584 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
576 | "destroying task %p\n", | 585 | "destroying task %p\n", |
577 | t); | 586 | t); |
578 | 587 | ||
579 | if (GNUNET_YES == t->own_handles) | 588 | if (GNUNET_YES == t->own_handles) |
589 | { | ||
590 | for (i = 0; i != t->fds_len; ++i) | ||
580 | { | 591 | { |
581 | for (i = 0; i != t->fds_len; ++i) | 592 | const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd; |
582 | { | 593 | const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh; |
583 | const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd; | 594 | if (fd) |
584 | const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh; | 595 | { |
585 | if (fd) | 596 | GNUNET_NETWORK_socket_free_memory_only_ ((struct |
586 | { | 597 | GNUNET_NETWORK_Handle *) fd); |
587 | GNUNET_NETWORK_socket_free_memory_only_((struct GNUNET_NETWORK_Handle *)fd); | 598 | } |
588 | } | 599 | if (fh) |
589 | if (fh) | 600 | { |
590 | { | 601 | // FIXME: on WIN32 this is not enough! A function |
591 | // FIXME: on WIN32 this is not enough! A function | 602 | // GNUNET_DISK_file_free_memory_only would be nice |
592 | // GNUNET_DISK_file_free_memory_only would be nice | 603 | GNUNET_free ((void *) fh); |
593 | GNUNET_free((void *)fh); | 604 | } |
594 | } | ||
595 | } | ||
596 | } | 605 | } |
606 | } | ||
597 | if (t->fds_len > 1) | 607 | if (t->fds_len > 1) |
598 | { | 608 | { |
599 | GNUNET_array_grow(t->fds, t->fds_len, 0); | 609 | GNUNET_array_grow (t->fds, t->fds_len, 0); |
600 | } | 610 | } |
601 | #if EXECINFO | 611 | #if EXECINFO |
602 | GNUNET_free(t->backtrace_strings); | 612 | GNUNET_free (t->backtrace_strings); |
603 | #endif | 613 | #endif |
604 | GNUNET_free(t); | 614 | GNUNET_free (t); |
605 | } | 615 | } |
606 | 616 | ||
607 | 617 | ||
@@ -620,7 +630,7 @@ static pid_t my_pid; | |||
620 | * Signal handler called for SIGPIPE. | 630 | * Signal handler called for SIGPIPE. |
621 | */ | 631 | */ |
622 | static void | 632 | static void |
623 | sighandler_pipe() | 633 | sighandler_pipe () |
624 | { | 634 | { |
625 | return; | 635 | return; |
626 | } | 636 | } |
@@ -634,37 +644,37 @@ sighandler_pipe() | |||
634 | // * | 644 | // * |
635 | // * @param ms how many ms to wait | 645 | // * @param ms how many ms to wait |
636 | // */ | 646 | // */ |
637 | //static void | 647 | // static void |
638 | //short_wait (unsigned int ms) | 648 | // short_wait (unsigned int ms) |
639 | //{ | 649 | // { |
640 | // struct GNUNET_TIME_Relative timeout; | 650 | // struct GNUNET_TIME_Relative timeout; |
641 | // | 651 | // |
642 | // timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms); | 652 | // timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms); |
643 | // (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout); | 653 | // (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout); |
644 | //} | 654 | // } |
645 | 655 | ||
646 | 656 | ||
647 | /** | 657 | /** |
648 | * Signal handler called for signals that should cause us to shutdown. | 658 | * Signal handler called for signals that should cause us to shutdown. |
649 | */ | 659 | */ |
650 | static void | 660 | static void |
651 | sighandler_shutdown() | 661 | sighandler_shutdown () |
652 | { | 662 | { |
653 | static char c; | 663 | static char c; |
654 | int old_errno = errno; /* backup errno */ | 664 | int old_errno = errno; /* backup errno */ |
655 | 665 | ||
656 | if (getpid() != my_pid) | 666 | if (getpid () != my_pid) |
657 | _exit(1); /* we have fork'ed since the signal handler was created, | 667 | _exit (1); /* we have fork'ed since the signal handler was created, |
658 | * ignore the signal, see https://gnunet.org/vfork discussion */ | 668 | * ignore the signal, see https://gnunet.org/vfork discussion */ |
659 | GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle | 669 | GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle |
660 | (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE), | 670 | (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE), |
661 | &c, sizeof(c)); | 671 | &c, sizeof(c)); |
662 | errno = old_errno; | 672 | errno = old_errno; |
663 | } | 673 | } |
664 | 674 | ||
665 | 675 | ||
666 | static void | 676 | static void |
667 | shutdown_if_no_lifeness() | 677 | shutdown_if_no_lifeness () |
668 | { | 678 | { |
669 | struct GNUNET_SCHEDULER_Task *t; | 679 | struct GNUNET_SCHEDULER_Task *t; |
670 | 680 | ||
@@ -680,13 +690,13 @@ shutdown_if_no_lifeness() | |||
680 | if (GNUNET_YES == t->lifeness) | 690 | if (GNUNET_YES == t->lifeness) |
681 | return; | 691 | return; |
682 | /* No lifeness! */ | 692 | /* No lifeness! */ |
683 | GNUNET_SCHEDULER_shutdown(); | 693 | GNUNET_SCHEDULER_shutdown (); |
684 | } | 694 | } |
685 | 695 | ||
686 | 696 | ||
687 | static int | 697 | static int |
688 | select_loop(struct GNUNET_SCHEDULER_Handle *sh, | 698 | select_loop (struct GNUNET_SCHEDULER_Handle *sh, |
689 | struct DriverContext *context); | 699 | struct DriverContext *context); |
690 | 700 | ||
691 | 701 | ||
692 | /** | 702 | /** |
@@ -704,26 +714,26 @@ select_loop(struct GNUNET_SCHEDULER_Handle *sh, | |||
704 | * @param task_cls closure of @a task | 714 | * @param task_cls closure of @a task |
705 | */ | 715 | */ |
706 | void | 716 | void |
707 | GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, | 717 | GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task, |
708 | void *task_cls) | 718 | void *task_cls) |
709 | { | 719 | { |
710 | struct GNUNET_SCHEDULER_Handle *sh; | 720 | struct GNUNET_SCHEDULER_Handle *sh; |
711 | struct GNUNET_SCHEDULER_Driver *driver; | 721 | struct GNUNET_SCHEDULER_Driver *driver; |
712 | struct DriverContext context = { .scheduled_head = NULL, | 722 | struct DriverContext context = { .scheduled_head = NULL, |
713 | .scheduled_tail = NULL, | 723 | .scheduled_tail = NULL, |
714 | .timeout = GNUNET_TIME_absolute_get() }; | 724 | .timeout = GNUNET_TIME_absolute_get () }; |
715 | 725 | ||
716 | driver = GNUNET_SCHEDULER_driver_select(); | 726 | driver = GNUNET_SCHEDULER_driver_select (); |
717 | driver->cls = &context; | 727 | driver->cls = &context; |
718 | sh = GNUNET_SCHEDULER_driver_init(driver); | 728 | sh = GNUNET_SCHEDULER_driver_init (driver); |
719 | GNUNET_SCHEDULER_add_with_reason_and_priority(task, | 729 | GNUNET_SCHEDULER_add_with_reason_and_priority (task, |
720 | task_cls, | 730 | task_cls, |
721 | GNUNET_SCHEDULER_REASON_STARTUP, | 731 | GNUNET_SCHEDULER_REASON_STARTUP, |
722 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 732 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); |
723 | select_loop(sh, | 733 | select_loop (sh, |
724 | &context); | 734 | &context); |
725 | GNUNET_SCHEDULER_driver_done(sh); | 735 | GNUNET_SCHEDULER_driver_done (sh); |
726 | GNUNET_free(driver); | 736 | GNUNET_free (driver); |
727 | } | 737 | } |
728 | 738 | ||
729 | 739 | ||
@@ -734,9 +744,9 @@ GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, | |||
734 | * @return current tasks' scheduler context | 744 | * @return current tasks' scheduler context |
735 | */ | 745 | */ |
736 | const struct GNUNET_SCHEDULER_TaskContext * | 746 | const struct GNUNET_SCHEDULER_TaskContext * |
737 | GNUNET_SCHEDULER_get_task_context() | 747 | GNUNET_SCHEDULER_get_task_context () |
738 | { | 748 | { |
739 | GNUNET_assert(NULL != active_task); | 749 | GNUNET_assert (NULL != active_task); |
740 | return &tc; | 750 | return &tc; |
741 | } | 751 | } |
742 | 752 | ||
@@ -751,33 +761,33 @@ GNUNET_SCHEDULER_get_task_context() | |||
751 | * @return number of tasks pending right now | 761 | * @return number of tasks pending right now |
752 | */ | 762 | */ |
753 | unsigned int | 763 | unsigned int |
754 | GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p) | 764 | GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p) |
755 | { | 765 | { |
756 | struct GNUNET_SCHEDULER_Task *pos; | 766 | struct GNUNET_SCHEDULER_Task *pos; |
757 | unsigned int ret; | 767 | unsigned int ret; |
758 | 768 | ||
759 | GNUNET_assert(NULL != active_task); | 769 | GNUNET_assert (NULL != active_task); |
760 | if (p == GNUNET_SCHEDULER_PRIORITY_COUNT) | 770 | if (p == GNUNET_SCHEDULER_PRIORITY_COUNT) |
761 | return ready_count; | 771 | return ready_count; |
762 | if (p == GNUNET_SCHEDULER_PRIORITY_KEEP) | 772 | if (p == GNUNET_SCHEDULER_PRIORITY_KEEP) |
763 | p = current_priority; | 773 | p = current_priority; |
764 | ret = 0; | 774 | ret = 0; |
765 | for (pos = ready_head[check_priority(p)]; NULL != pos; pos = pos->next) | 775 | for (pos = ready_head[check_priority (p)]; NULL != pos; pos = pos->next) |
766 | ret++; | 776 | ret++; |
767 | return ret; | 777 | return ret; |
768 | } | 778 | } |
769 | 779 | ||
770 | 780 | ||
771 | void | 781 | void |
772 | init_fd_info(struct GNUNET_SCHEDULER_Task *t, | 782 | init_fd_info (struct GNUNET_SCHEDULER_Task *t, |
773 | const struct GNUNET_NETWORK_Handle *const *read_nh, | 783 | const struct GNUNET_NETWORK_Handle *const *read_nh, |
774 | unsigned int read_nh_len, | 784 | unsigned int read_nh_len, |
775 | const struct GNUNET_NETWORK_Handle *const *write_nh, | 785 | const struct GNUNET_NETWORK_Handle *const *write_nh, |
776 | unsigned int write_nh_len, | 786 | unsigned int write_nh_len, |
777 | const struct GNUNET_DISK_FileHandle *const *read_fh, | 787 | const struct GNUNET_DISK_FileHandle *const *read_fh, |
778 | unsigned int read_fh_len, | 788 | unsigned int read_fh_len, |
779 | const struct GNUNET_DISK_FileHandle *const *write_fh, | 789 | const struct GNUNET_DISK_FileHandle *const *write_fh, |
780 | unsigned int write_fh_len) | 790 | unsigned int write_fh_len) |
781 | { | 791 | { |
782 | // FIXME: if we have exactly two network handles / exactly two file handles | 792 | // FIXME: if we have exactly two network handles / exactly two file handles |
783 | // and they are equal, we can make one FdInfo with both | 793 | // and they are equal, we can make one FdInfo with both |
@@ -786,90 +796,90 @@ init_fd_info(struct GNUNET_SCHEDULER_Task *t, | |||
786 | 796 | ||
787 | t->fds_len = read_nh_len + write_nh_len + read_fh_len + write_fh_len; | 797 | t->fds_len = read_nh_len + write_nh_len + read_fh_len + write_fh_len; |
788 | if (1 == t->fds_len) | 798 | if (1 == t->fds_len) |
799 | { | ||
800 | fdi = &t->fdx; | ||
801 | t->fds = fdi; | ||
802 | if (1 == read_nh_len) | ||
789 | { | 803 | { |
790 | fdi = &t->fdx; | 804 | GNUNET_assert (NULL != read_nh); |
791 | t->fds = fdi; | 805 | GNUNET_assert (NULL != *read_nh); |
792 | if (1 == read_nh_len) | 806 | fdi->fd = *read_nh; |
793 | { | 807 | fdi->et = GNUNET_SCHEDULER_ET_IN; |
794 | GNUNET_assert(NULL != read_nh); | 808 | fdi->sock = GNUNET_NETWORK_get_fd (*read_nh); |
795 | GNUNET_assert(NULL != *read_nh); | 809 | t->read_fd = fdi->sock; |
796 | fdi->fd = *read_nh; | 810 | t->write_fd = -1; |
797 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
798 | fdi->sock = GNUNET_NETWORK_get_fd(*read_nh); | ||
799 | t->read_fd = fdi->sock; | ||
800 | t->write_fd = -1; | ||
801 | } | ||
802 | else if (1 == write_nh_len) | ||
803 | { | ||
804 | GNUNET_assert(NULL != write_nh); | ||
805 | GNUNET_assert(NULL != *write_nh); | ||
806 | fdi->fd = *write_nh; | ||
807 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
808 | fdi->sock = GNUNET_NETWORK_get_fd(*write_nh); | ||
809 | t->read_fd = -1; | ||
810 | t->write_fd = fdi->sock; | ||
811 | } | ||
812 | else if (1 == read_fh_len) | ||
813 | { | ||
814 | GNUNET_assert(NULL != read_fh); | ||
815 | GNUNET_assert(NULL != *read_fh); | ||
816 | fdi->fh = *read_fh; | ||
817 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
818 | fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32 | ||
819 | t->read_fd = fdi->sock; | ||
820 | t->write_fd = -1; | ||
821 | } | ||
822 | else | ||
823 | { | ||
824 | GNUNET_assert(NULL != write_fh); | ||
825 | GNUNET_assert(NULL != *write_fh); | ||
826 | fdi->fh = *write_fh; | ||
827 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
828 | fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32 | ||
829 | t->read_fd = -1; | ||
830 | t->write_fd = fdi->sock; | ||
831 | } | ||
832 | } | 811 | } |
833 | else | 812 | else if (1 == write_nh_len) |
834 | { | 813 | { |
835 | fdi = GNUNET_new_array(t->fds_len, struct GNUNET_SCHEDULER_FdInfo); | 814 | GNUNET_assert (NULL != write_nh); |
836 | t->fds = fdi; | 815 | GNUNET_assert (NULL != *write_nh); |
816 | fdi->fd = *write_nh; | ||
817 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
818 | fdi->sock = GNUNET_NETWORK_get_fd (*write_nh); | ||
837 | t->read_fd = -1; | 819 | t->read_fd = -1; |
820 | t->write_fd = fdi->sock; | ||
821 | } | ||
822 | else if (1 == read_fh_len) | ||
823 | { | ||
824 | GNUNET_assert (NULL != read_fh); | ||
825 | GNUNET_assert (NULL != *read_fh); | ||
826 | fdi->fh = *read_fh; | ||
827 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
828 | fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32 | ||
829 | t->read_fd = fdi->sock; | ||
838 | t->write_fd = -1; | 830 | t->write_fd = -1; |
839 | unsigned int i; | ||
840 | for (i = 0; i != read_nh_len; ++i) | ||
841 | { | ||
842 | fdi->fd = read_nh[i]; | ||
843 | GNUNET_assert(NULL != fdi->fd); | ||
844 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
845 | fdi->sock = GNUNET_NETWORK_get_fd(read_nh[i]); | ||
846 | ++fdi; | ||
847 | } | ||
848 | for (i = 0; i != write_nh_len; ++i) | ||
849 | { | ||
850 | fdi->fd = write_nh[i]; | ||
851 | GNUNET_assert(NULL != fdi->fd); | ||
852 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
853 | fdi->sock = GNUNET_NETWORK_get_fd(write_nh[i]); | ||
854 | ++fdi; | ||
855 | } | ||
856 | for (i = 0; i != read_fh_len; ++i) | ||
857 | { | ||
858 | fdi->fh = read_fh[i]; | ||
859 | GNUNET_assert(NULL != fdi->fh); | ||
860 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
861 | fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32 | ||
862 | ++fdi; | ||
863 | } | ||
864 | for (i = 0; i != write_fh_len; ++i) | ||
865 | { | ||
866 | fdi->fh = write_fh[i]; | ||
867 | GNUNET_assert(NULL != fdi->fh); | ||
868 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
869 | fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32 | ||
870 | ++fdi; | ||
871 | } | ||
872 | } | 831 | } |
832 | else | ||
833 | { | ||
834 | GNUNET_assert (NULL != write_fh); | ||
835 | GNUNET_assert (NULL != *write_fh); | ||
836 | fdi->fh = *write_fh; | ||
837 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
838 | fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32 | ||
839 | t->read_fd = -1; | ||
840 | t->write_fd = fdi->sock; | ||
841 | } | ||
842 | } | ||
843 | else | ||
844 | { | ||
845 | fdi = GNUNET_new_array (t->fds_len, struct GNUNET_SCHEDULER_FdInfo); | ||
846 | t->fds = fdi; | ||
847 | t->read_fd = -1; | ||
848 | t->write_fd = -1; | ||
849 | unsigned int i; | ||
850 | for (i = 0; i != read_nh_len; ++i) | ||
851 | { | ||
852 | fdi->fd = read_nh[i]; | ||
853 | GNUNET_assert (NULL != fdi->fd); | ||
854 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
855 | fdi->sock = GNUNET_NETWORK_get_fd (read_nh[i]); | ||
856 | ++fdi; | ||
857 | } | ||
858 | for (i = 0; i != write_nh_len; ++i) | ||
859 | { | ||
860 | fdi->fd = write_nh[i]; | ||
861 | GNUNET_assert (NULL != fdi->fd); | ||
862 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
863 | fdi->sock = GNUNET_NETWORK_get_fd (write_nh[i]); | ||
864 | ++fdi; | ||
865 | } | ||
866 | for (i = 0; i != read_fh_len; ++i) | ||
867 | { | ||
868 | fdi->fh = read_fh[i]; | ||
869 | GNUNET_assert (NULL != fdi->fh); | ||
870 | fdi->et = GNUNET_SCHEDULER_ET_IN; | ||
871 | fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32 | ||
872 | ++fdi; | ||
873 | } | ||
874 | for (i = 0; i != write_fh_len; ++i) | ||
875 | { | ||
876 | fdi->fh = write_fh[i]; | ||
877 | GNUNET_assert (NULL != fdi->fh); | ||
878 | fdi->et = GNUNET_SCHEDULER_ET_OUT; | ||
879 | fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32 | ||
880 | ++fdi; | ||
881 | } | ||
882 | } | ||
873 | } | 883 | } |
874 | 884 | ||
875 | 885 | ||
@@ -887,56 +897,56 @@ init_fd_info(struct GNUNET_SCHEDULER_Task *t, | |||
887 | * @a driver_func on it, or -1 if no updating not desired. | 897 | * @a driver_func on it, or -1 if no updating not desired. |
888 | */ | 898 | */ |
889 | static void | 899 | static void |
890 | driver_add_multiple(struct GNUNET_SCHEDULER_Task *t) | 900 | driver_add_multiple (struct GNUNET_SCHEDULER_Task *t) |
891 | { | 901 | { |
892 | struct GNUNET_SCHEDULER_FdInfo *fdi; | 902 | struct GNUNET_SCHEDULER_FdInfo *fdi; |
893 | int success = GNUNET_YES; | 903 | int success = GNUNET_YES; |
894 | 904 | ||
895 | for (unsigned int i = 0; i != t->fds_len; ++i) | 905 | for (unsigned int i = 0; i != t->fds_len; ++i) |
896 | { | 906 | { |
897 | fdi = &t->fds[i]; | 907 | fdi = &t->fds[i]; |
898 | success = scheduler_driver->add(scheduler_driver->cls, | 908 | success = scheduler_driver->add (scheduler_driver->cls, |
899 | t, | 909 | t, |
900 | fdi) && success; | 910 | fdi) && success; |
901 | fdi->et = GNUNET_SCHEDULER_ET_NONE; | 911 | fdi->et = GNUNET_SCHEDULER_ET_NONE; |
902 | } | 912 | } |
903 | if (GNUNET_YES != success) | 913 | if (GNUNET_YES != success) |
904 | { | 914 | { |
905 | LOG(GNUNET_ERROR_TYPE_ERROR, | 915 | LOG (GNUNET_ERROR_TYPE_ERROR, |
906 | "driver could not add task\n"); | 916 | "driver could not add task\n"); |
907 | } | 917 | } |
908 | } | 918 | } |
909 | 919 | ||
910 | 920 | ||
911 | static void | 921 | static void |
912 | install_parent_control_handler(void *cls) | 922 | install_parent_control_handler (void *cls) |
913 | { | 923 | { |
914 | (void)cls; | 924 | (void) cls; |
915 | install_parent_control_task = NULL; | 925 | install_parent_control_task = NULL; |
916 | GNUNET_OS_install_parent_control_handler(NULL); | 926 | GNUNET_OS_install_parent_control_handler (NULL); |
917 | } | 927 | } |
918 | 928 | ||
919 | 929 | ||
920 | static void | 930 | static void |
921 | shutdown_pipe_cb(void *cls) | 931 | shutdown_pipe_cb (void *cls) |
922 | { | 932 | { |
923 | char c; | 933 | char c; |
924 | const struct GNUNET_DISK_FileHandle *pr; | 934 | const struct GNUNET_DISK_FileHandle *pr; |
925 | 935 | ||
926 | (void)cls; | 936 | (void) cls; |
927 | shutdown_pipe_task = NULL; | 937 | shutdown_pipe_task = NULL; |
928 | pr = GNUNET_DISK_pipe_handle(shutdown_pipe_handle, | 938 | pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle, |
929 | GNUNET_DISK_PIPE_END_READ); | 939 | GNUNET_DISK_PIPE_END_READ); |
930 | GNUNET_assert(!GNUNET_DISK_handle_invalid(pr)); | 940 | GNUNET_assert (! GNUNET_DISK_handle_invalid (pr)); |
931 | /* consume the signal */ | 941 | /* consume the signal */ |
932 | GNUNET_DISK_file_read(pr, &c, sizeof(c)); | 942 | GNUNET_DISK_file_read (pr, &c, sizeof(c)); |
933 | /* mark all active tasks as ready due to shutdown */ | 943 | /* mark all active tasks as ready due to shutdown */ |
934 | GNUNET_SCHEDULER_shutdown(); | 944 | GNUNET_SCHEDULER_shutdown (); |
935 | shutdown_pipe_task = | 945 | shutdown_pipe_task = |
936 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 946 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
937 | pr, | 947 | pr, |
938 | &shutdown_pipe_cb, | 948 | &shutdown_pipe_cb, |
939 | NULL); | 949 | NULL); |
940 | } | 950 | } |
941 | 951 | ||
942 | 952 | ||
@@ -953,62 +963,62 @@ shutdown_pipe_cb(void *cls) | |||
953 | * @return original closure of the task | 963 | * @return original closure of the task |
954 | */ | 964 | */ |
955 | void * | 965 | void * |
956 | GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task) | 966 | GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task) |
957 | { | 967 | { |
958 | enum GNUNET_SCHEDULER_Priority p; | 968 | enum GNUNET_SCHEDULER_Priority p; |
959 | int is_fd_task; | 969 | int is_fd_task; |
960 | void *ret; | 970 | void *ret; |
961 | 971 | ||
962 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 972 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
963 | "canceling task %p\n", | 973 | "canceling task %p\n", |
964 | task); | 974 | task); |
965 | 975 | ||
966 | /* scheduler must be running */ | 976 | /* scheduler must be running */ |
967 | GNUNET_assert(NULL != scheduler_driver); | 977 | GNUNET_assert (NULL != scheduler_driver); |
968 | is_fd_task = (NULL != task->fds); | 978 | is_fd_task = (NULL != task->fds); |
969 | if (is_fd_task) | 979 | if (is_fd_task) |
980 | { | ||
981 | int del_result = scheduler_driver->del (scheduler_driver->cls, task); | ||
982 | if (GNUNET_OK != del_result) | ||
970 | { | 983 | { |
971 | int del_result = scheduler_driver->del(scheduler_driver->cls, task); | 984 | LOG (GNUNET_ERROR_TYPE_ERROR, |
972 | if (GNUNET_OK != del_result) | 985 | "driver could not delete task\n"); |
973 | { | 986 | GNUNET_assert (0); |
974 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
975 | "driver could not delete task\n"); | ||
976 | GNUNET_assert(0); | ||
977 | } | ||
978 | } | 987 | } |
979 | if (!task->in_ready_list) | 988 | } |
989 | if (! task->in_ready_list) | ||
990 | { | ||
991 | if (is_fd_task) | ||
980 | { | 992 | { |
981 | if (is_fd_task) | 993 | GNUNET_CONTAINER_DLL_remove (pending_head, |
982 | { | 994 | pending_tail, |
983 | GNUNET_CONTAINER_DLL_remove(pending_head, | 995 | task); |
984 | pending_tail, | ||
985 | task); | ||
986 | } | ||
987 | else if (GNUNET_YES == task->on_shutdown) | ||
988 | { | ||
989 | GNUNET_CONTAINER_DLL_remove(shutdown_head, | ||
990 | shutdown_tail, | ||
991 | task); | ||
992 | } | ||
993 | else | ||
994 | { | ||
995 | GNUNET_CONTAINER_DLL_remove(pending_timeout_head, | ||
996 | pending_timeout_tail, | ||
997 | task); | ||
998 | if (pending_timeout_last == task) | ||
999 | pending_timeout_last = NULL; | ||
1000 | } | ||
1001 | } | 996 | } |
1002 | else | 997 | else if (GNUNET_YES == task->on_shutdown) |
1003 | { | 998 | { |
1004 | p = check_priority(task->priority); | 999 | GNUNET_CONTAINER_DLL_remove (shutdown_head, |
1005 | GNUNET_CONTAINER_DLL_remove(ready_head[p], | 1000 | shutdown_tail, |
1006 | ready_tail[p], | 1001 | task); |
1007 | task); | 1002 | } |
1008 | ready_count--; | 1003 | else |
1004 | { | ||
1005 | GNUNET_CONTAINER_DLL_remove (pending_timeout_head, | ||
1006 | pending_timeout_tail, | ||
1007 | task); | ||
1008 | if (pending_timeout_last == task) | ||
1009 | pending_timeout_last = NULL; | ||
1009 | } | 1010 | } |
1011 | } | ||
1012 | else | ||
1013 | { | ||
1014 | p = check_priority (task->priority); | ||
1015 | GNUNET_CONTAINER_DLL_remove (ready_head[p], | ||
1016 | ready_tail[p], | ||
1017 | task); | ||
1018 | ready_count--; | ||
1019 | } | ||
1010 | ret = task->callback_cls; | 1020 | ret = task->callback_cls; |
1011 | destroy_task(task); | 1021 | destroy_task (task); |
1012 | return ret; | 1022 | return ret; |
1013 | } | 1023 | } |
1014 | 1024 | ||
@@ -1019,19 +1029,19 @@ GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task) | |||
1019 | * @param t task to initialize | 1029 | * @param t task to initialize |
1020 | */ | 1030 | */ |
1021 | static void | 1031 | static void |
1022 | init_backtrace(struct GNUNET_SCHEDULER_Task *t) | 1032 | init_backtrace (struct GNUNET_SCHEDULER_Task *t) |
1023 | { | 1033 | { |
1024 | #if EXECINFO | 1034 | #if EXECINFO |
1025 | void *backtrace_array[MAX_TRACE_DEPTH]; | 1035 | void *backtrace_array[MAX_TRACE_DEPTH]; |
1026 | 1036 | ||
1027 | t->num_backtrace_strings | 1037 | t->num_backtrace_strings |
1028 | = backtrace(backtrace_array, MAX_TRACE_DEPTH); | 1038 | = backtrace (backtrace_array, MAX_TRACE_DEPTH); |
1029 | t->backtrace_strings = | 1039 | t->backtrace_strings = |
1030 | backtrace_symbols(backtrace_array, | 1040 | backtrace_symbols (backtrace_array, |
1031 | t->num_backtrace_strings); | 1041 | t->num_backtrace_strings); |
1032 | dump_backtrace(t); | 1042 | dump_backtrace (t); |
1033 | #else | 1043 | #else |
1034 | (void)t; | 1044 | (void) t; |
1035 | #endif | 1045 | #endif |
1036 | } | 1046 | } |
1037 | 1047 | ||
@@ -1047,32 +1057,35 @@ init_backtrace(struct GNUNET_SCHEDULER_Task *t) | |||
1047 | * @param priority priority to use for the task | 1057 | * @param priority priority to use for the task |
1048 | */ | 1058 | */ |
1049 | void | 1059 | void |
1050 | GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task, | 1060 | GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback |
1051 | void *task_cls, | 1061 | task, |
1052 | enum GNUNET_SCHEDULER_Reason reason, | 1062 | void *task_cls, |
1053 | enum GNUNET_SCHEDULER_Priority priority) | 1063 | enum GNUNET_SCHEDULER_Reason |
1064 | reason, | ||
1065 | enum GNUNET_SCHEDULER_Priority | ||
1066 | priority) | ||
1054 | { | 1067 | { |
1055 | struct GNUNET_SCHEDULER_Task *t; | 1068 | struct GNUNET_SCHEDULER_Task *t; |
1056 | 1069 | ||
1057 | /* scheduler must be running */ | 1070 | /* scheduler must be running */ |
1058 | GNUNET_assert(NULL != scheduler_driver); | 1071 | GNUNET_assert (NULL != scheduler_driver); |
1059 | GNUNET_assert(NULL != task); | 1072 | GNUNET_assert (NULL != task); |
1060 | t = GNUNET_new(struct GNUNET_SCHEDULER_Task); | 1073 | t = GNUNET_new (struct GNUNET_SCHEDULER_Task); |
1061 | t->read_fd = -1; | 1074 | t->read_fd = -1; |
1062 | t->write_fd = -1; | 1075 | t->write_fd = -1; |
1063 | t->callback = task; | 1076 | t->callback = task; |
1064 | t->callback_cls = task_cls; | 1077 | t->callback_cls = task_cls; |
1065 | #if PROFILE_DELAYS | 1078 | #if PROFILE_DELAYS |
1066 | t->start_time = GNUNET_TIME_absolute_get(); | 1079 | t->start_time = GNUNET_TIME_absolute_get (); |
1067 | #endif | 1080 | #endif |
1068 | t->reason = reason; | 1081 | t->reason = reason; |
1069 | t->priority = check_priority(priority); | 1082 | t->priority = check_priority (priority); |
1070 | t->lifeness = current_lifeness; | 1083 | t->lifeness = current_lifeness; |
1071 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1084 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1072 | "Adding continuation task %p\n", | 1085 | "Adding continuation task %p\n", |
1073 | t); | 1086 | t); |
1074 | init_backtrace(t); | 1087 | init_backtrace (t); |
1075 | queue_ready_task(t); | 1088 | queue_ready_task (t); |
1076 | } | 1089 | } |
1077 | 1090 | ||
1078 | 1091 | ||
@@ -1088,68 +1101,69 @@ GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task | |||
1088 | * only valid until @a task is started! | 1101 | * only valid until @a task is started! |
1089 | */ | 1102 | */ |
1090 | struct GNUNET_SCHEDULER_Task * | 1103 | struct GNUNET_SCHEDULER_Task * |
1091 | GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, | 1104 | GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at, |
1092 | enum GNUNET_SCHEDULER_Priority priority, | 1105 | enum GNUNET_SCHEDULER_Priority priority, |
1093 | GNUNET_SCHEDULER_TaskCallback task, | 1106 | GNUNET_SCHEDULER_TaskCallback task, |
1094 | void *task_cls) | 1107 | void *task_cls) |
1095 | { | 1108 | { |
1096 | struct GNUNET_SCHEDULER_Task *t; | 1109 | struct GNUNET_SCHEDULER_Task *t; |
1097 | struct GNUNET_SCHEDULER_Task *pos; | 1110 | struct GNUNET_SCHEDULER_Task *pos; |
1098 | struct GNUNET_SCHEDULER_Task *prev; | 1111 | struct GNUNET_SCHEDULER_Task *prev; |
1099 | 1112 | ||
1100 | /* scheduler must be running */ | 1113 | /* scheduler must be running */ |
1101 | GNUNET_assert(NULL != scheduler_driver); | 1114 | GNUNET_assert (NULL != scheduler_driver); |
1102 | GNUNET_assert(NULL != task); | 1115 | GNUNET_assert (NULL != task); |
1103 | t = GNUNET_new(struct GNUNET_SCHEDULER_Task); | 1116 | t = GNUNET_new (struct GNUNET_SCHEDULER_Task); |
1104 | GNUNET_async_scope_get(&t->scope); | 1117 | GNUNET_async_scope_get (&t->scope); |
1105 | t->callback = task; | 1118 | t->callback = task; |
1106 | t->callback_cls = task_cls; | 1119 | t->callback_cls = task_cls; |
1107 | t->read_fd = -1; | 1120 | t->read_fd = -1; |
1108 | t->write_fd = -1; | 1121 | t->write_fd = -1; |
1109 | #if PROFILE_DELAYS | 1122 | #if PROFILE_DELAYS |
1110 | t->start_time = GNUNET_TIME_absolute_get(); | 1123 | t->start_time = GNUNET_TIME_absolute_get (); |
1111 | #endif | 1124 | #endif |
1112 | t->timeout = at; | 1125 | t->timeout = at; |
1113 | t->priority = check_priority(priority); | 1126 | t->priority = check_priority (priority); |
1114 | t->lifeness = current_lifeness; | 1127 | t->lifeness = current_lifeness; |
1115 | /* try tail first (optimization in case we are | 1128 | /* try tail first (optimization in case we are |
1116 | * appending to a long list of tasks with timeouts) */ | 1129 | * appending to a long list of tasks with timeouts) */ |
1117 | if ((NULL == pending_timeout_head) || | 1130 | if ((NULL == pending_timeout_head) || |
1118 | (at.abs_value_us < pending_timeout_head->timeout.abs_value_us)) | 1131 | (at.abs_value_us < pending_timeout_head->timeout.abs_value_us)) |
1119 | { | 1132 | { |
1120 | GNUNET_CONTAINER_DLL_insert(pending_timeout_head, | 1133 | GNUNET_CONTAINER_DLL_insert (pending_timeout_head, |
1121 | pending_timeout_tail, | 1134 | pending_timeout_tail, |
1122 | t); | 1135 | t); |
1123 | } | 1136 | } |
1124 | else | 1137 | else |
1138 | { | ||
1139 | /* first move from heuristic start backwards to before start time */ | ||
1140 | prev = pending_timeout_last; | ||
1141 | while ((NULL != prev) && | ||
1142 | (prev->timeout.abs_value_us > t->timeout.abs_value_us)) | ||
1143 | prev = prev->prev; | ||
1144 | /* now, move from heuristic start (or head of list) forward to insertion point */ | ||
1145 | if (NULL == prev) | ||
1146 | pos = pending_timeout_head; | ||
1147 | else | ||
1148 | pos = prev->next; | ||
1149 | while ((NULL != pos) && (pos->timeout.abs_value_us <= | ||
1150 | t->timeout.abs_value_us)) | ||
1125 | { | 1151 | { |
1126 | /* first move from heuristic start backwards to before start time */ | 1152 | prev = pos; |
1127 | prev = pending_timeout_last; | 1153 | pos = pos->next; |
1128 | while ((NULL != prev) && | ||
1129 | (prev->timeout.abs_value_us > t->timeout.abs_value_us)) | ||
1130 | prev = prev->prev; | ||
1131 | /* now, move from heuristic start (or head of list) forward to insertion point */ | ||
1132 | if (NULL == prev) | ||
1133 | pos = pending_timeout_head; | ||
1134 | else | ||
1135 | pos = prev->next; | ||
1136 | while ((NULL != pos) && (pos->timeout.abs_value_us <= t->timeout.abs_value_us)) | ||
1137 | { | ||
1138 | prev = pos; | ||
1139 | pos = pos->next; | ||
1140 | } | ||
1141 | GNUNET_CONTAINER_DLL_insert_after(pending_timeout_head, | ||
1142 | pending_timeout_tail, | ||
1143 | prev, | ||
1144 | t); | ||
1145 | } | 1154 | } |
1155 | GNUNET_CONTAINER_DLL_insert_after (pending_timeout_head, | ||
1156 | pending_timeout_tail, | ||
1157 | prev, | ||
1158 | t); | ||
1159 | } | ||
1146 | /* finally, update heuristic insertion point to last insertion... */ | 1160 | /* finally, update heuristic insertion point to last insertion... */ |
1147 | pending_timeout_last = t; | 1161 | pending_timeout_last = t; |
1148 | 1162 | ||
1149 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1163 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1150 | "Adding task %p\n", | 1164 | "Adding task %p\n", |
1151 | t); | 1165 | t); |
1152 | init_backtrace(t); | 1166 | init_backtrace (t); |
1153 | return t; | 1167 | return t; |
1154 | } | 1168 | } |
1155 | 1169 | ||
@@ -1166,15 +1180,17 @@ GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, | |||
1166 | * only valid until @a task is started! | 1180 | * only valid until @a task is started! |
1167 | */ | 1181 | */ |
1168 | struct GNUNET_SCHEDULER_Task * | 1182 | struct GNUNET_SCHEDULER_Task * |
1169 | GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, | 1183 | GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, |
1170 | enum GNUNET_SCHEDULER_Priority priority, | 1184 | enum GNUNET_SCHEDULER_Priority |
1171 | GNUNET_SCHEDULER_TaskCallback task, | 1185 | priority, |
1172 | void *task_cls) | 1186 | GNUNET_SCHEDULER_TaskCallback task, |
1187 | void *task_cls) | ||
1173 | { | 1188 | { |
1174 | return GNUNET_SCHEDULER_add_at_with_priority(GNUNET_TIME_relative_to_absolute(delay), | 1189 | return GNUNET_SCHEDULER_add_at_with_priority ( |
1175 | priority, | 1190 | GNUNET_TIME_relative_to_absolute (delay), |
1176 | task, | 1191 | priority, |
1177 | task_cls); | 1192 | task, |
1193 | task_cls); | ||
1178 | } | 1194 | } |
1179 | 1195 | ||
1180 | 1196 | ||
@@ -1188,14 +1204,14 @@ GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, | |||
1188 | * only valid until @a task is started! | 1204 | * only valid until @a task is started! |
1189 | */ | 1205 | */ |
1190 | struct GNUNET_SCHEDULER_Task * | 1206 | struct GNUNET_SCHEDULER_Task * |
1191 | GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, | 1207 | GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, |
1192 | GNUNET_SCHEDULER_TaskCallback task, | 1208 | GNUNET_SCHEDULER_TaskCallback task, |
1193 | void *task_cls) | 1209 | void *task_cls) |
1194 | { | 1210 | { |
1195 | return GNUNET_SCHEDULER_add_delayed_with_priority(GNUNET_TIME_UNIT_ZERO, | 1211 | return GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_ZERO, |
1196 | prio, | 1212 | prio, |
1197 | task, | 1213 | task, |
1198 | task_cls); | 1214 | task_cls); |
1199 | } | 1215 | } |
1200 | 1216 | ||
1201 | 1217 | ||
@@ -1211,14 +1227,14 @@ GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, | |||
1211 | * only valid until @a task is started! | 1227 | * only valid until @a task is started! |
1212 | */ | 1228 | */ |
1213 | struct GNUNET_SCHEDULER_Task * | 1229 | struct GNUNET_SCHEDULER_Task * |
1214 | GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, | 1230 | GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at, |
1215 | GNUNET_SCHEDULER_TaskCallback task, | 1231 | GNUNET_SCHEDULER_TaskCallback task, |
1216 | void *task_cls) | 1232 | void *task_cls) |
1217 | { | 1233 | { |
1218 | return GNUNET_SCHEDULER_add_at_with_priority(at, | 1234 | return GNUNET_SCHEDULER_add_at_with_priority (at, |
1219 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1235 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1220 | task, | 1236 | task, |
1221 | task_cls); | 1237 | task_cls); |
1222 | } | 1238 | } |
1223 | 1239 | ||
1224 | 1240 | ||
@@ -1234,14 +1250,14 @@ GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, | |||
1234 | * only valid until @a task is started! | 1250 | * only valid until @a task is started! |
1235 | */ | 1251 | */ |
1236 | struct GNUNET_SCHEDULER_Task * | 1252 | struct GNUNET_SCHEDULER_Task * |
1237 | GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, | 1253 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, |
1238 | GNUNET_SCHEDULER_TaskCallback task, | 1254 | GNUNET_SCHEDULER_TaskCallback task, |
1239 | void *task_cls) | 1255 | void *task_cls) |
1240 | { | 1256 | { |
1241 | return GNUNET_SCHEDULER_add_delayed_with_priority(delay, | 1257 | return GNUNET_SCHEDULER_add_delayed_with_priority (delay, |
1242 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1258 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1243 | task, | 1259 | task, |
1244 | task_cls); | 1260 | task_cls); |
1245 | } | 1261 | } |
1246 | 1262 | ||
1247 | 1263 | ||
@@ -1261,12 +1277,12 @@ GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, | |||
1261 | * only valid until @a task is started! | 1277 | * only valid until @a task is started! |
1262 | */ | 1278 | */ |
1263 | struct GNUNET_SCHEDULER_Task * | 1279 | struct GNUNET_SCHEDULER_Task * |
1264 | GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, | 1280 | GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task, |
1265 | void *task_cls) | 1281 | void *task_cls) |
1266 | { | 1282 | { |
1267 | return GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_ZERO, | 1283 | return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO, |
1268 | task, | 1284 | task, |
1269 | task_cls); | 1285 | task_cls); |
1270 | } | 1286 | } |
1271 | 1287 | ||
1272 | 1288 | ||
@@ -1281,34 +1297,34 @@ GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, | |||
1281 | * only valid until @a task is started! | 1297 | * only valid until @a task is started! |
1282 | */ | 1298 | */ |
1283 | struct GNUNET_SCHEDULER_Task * | 1299 | struct GNUNET_SCHEDULER_Task * |
1284 | GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, | 1300 | GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task, |
1285 | void *task_cls) | 1301 | void *task_cls) |
1286 | { | 1302 | { |
1287 | struct GNUNET_SCHEDULER_Task *t; | 1303 | struct GNUNET_SCHEDULER_Task *t; |
1288 | 1304 | ||
1289 | /* scheduler must be running */ | 1305 | /* scheduler must be running */ |
1290 | GNUNET_assert(NULL != scheduler_driver); | 1306 | GNUNET_assert (NULL != scheduler_driver); |
1291 | GNUNET_assert(NULL != task); | 1307 | GNUNET_assert (NULL != task); |
1292 | t = GNUNET_new(struct GNUNET_SCHEDULER_Task); | 1308 | t = GNUNET_new (struct GNUNET_SCHEDULER_Task); |
1293 | GNUNET_async_scope_get(&t->scope); | 1309 | GNUNET_async_scope_get (&t->scope); |
1294 | t->callback = task; | 1310 | t->callback = task; |
1295 | t->callback_cls = task_cls; | 1311 | t->callback_cls = task_cls; |
1296 | t->read_fd = -1; | 1312 | t->read_fd = -1; |
1297 | t->write_fd = -1; | 1313 | t->write_fd = -1; |
1298 | #if PROFILE_DELAYS | 1314 | #if PROFILE_DELAYS |
1299 | t->start_time = GNUNET_TIME_absolute_get(); | 1315 | t->start_time = GNUNET_TIME_absolute_get (); |
1300 | #endif | 1316 | #endif |
1301 | t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; | 1317 | t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; |
1302 | t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN; | 1318 | t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN; |
1303 | t->on_shutdown = GNUNET_YES; | 1319 | t->on_shutdown = GNUNET_YES; |
1304 | t->lifeness = GNUNET_NO; | 1320 | t->lifeness = GNUNET_NO; |
1305 | GNUNET_CONTAINER_DLL_insert(shutdown_head, | 1321 | GNUNET_CONTAINER_DLL_insert (shutdown_head, |
1306 | shutdown_tail, | 1322 | shutdown_tail, |
1307 | t); | 1323 | t); |
1308 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1324 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1309 | "Adding shutdown task %p\n", | 1325 | "Adding shutdown task %p\n", |
1310 | t); | 1326 | t); |
1311 | init_backtrace(t); | 1327 | init_backtrace (t); |
1312 | return t; | 1328 | return t; |
1313 | } | 1329 | } |
1314 | 1330 | ||
@@ -1328,13 +1344,13 @@ GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, | |||
1328 | * only valid until @a task is started! | 1344 | * only valid until @a task is started! |
1329 | */ | 1345 | */ |
1330 | struct GNUNET_SCHEDULER_Task * | 1346 | struct GNUNET_SCHEDULER_Task * |
1331 | GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, | 1347 | GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, |
1332 | GNUNET_SCHEDULER_TaskCallback task, | 1348 | GNUNET_SCHEDULER_TaskCallback task, |
1333 | void *task_cls) | 1349 | void *task_cls) |
1334 | { | 1350 | { |
1335 | struct GNUNET_SCHEDULER_Task *ret; | 1351 | struct GNUNET_SCHEDULER_Task *ret; |
1336 | 1352 | ||
1337 | ret = GNUNET_SCHEDULER_add_now(task, task_cls); | 1353 | ret = GNUNET_SCHEDULER_add_now (task, task_cls); |
1338 | ret->lifeness = lifeness; | 1354 | ret->lifeness = lifeness; |
1339 | return ret; | 1355 | return ret; |
1340 | } | 1356 | } |
@@ -1348,21 +1364,21 @@ GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, | |||
1348 | * @param raw_fd the raw file descriptor to check | 1364 | * @param raw_fd the raw file descriptor to check |
1349 | */ | 1365 | */ |
1350 | void | 1366 | void |
1351 | check_fd(struct GNUNET_SCHEDULER_Task *t, int raw_fd) | 1367 | check_fd (struct GNUNET_SCHEDULER_Task *t, int raw_fd) |
1352 | { | 1368 | { |
1353 | if (-1 != raw_fd) | 1369 | if (-1 != raw_fd) |
1354 | { | 1370 | { |
1355 | int flags = fcntl(raw_fd, F_GETFD); | 1371 | int flags = fcntl (raw_fd, F_GETFD); |
1356 | 1372 | ||
1357 | if ((flags == -1) && (errno == EBADF)) | 1373 | if ((flags == -1) && (errno == EBADF)) |
1358 | { | 1374 | { |
1359 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1375 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1360 | "Got invalid file descriptor %d!\n", | 1376 | "Got invalid file descriptor %d!\n", |
1361 | raw_fd); | 1377 | raw_fd); |
1362 | init_backtrace(t); | 1378 | init_backtrace (t); |
1363 | GNUNET_assert(0); | 1379 | GNUNET_assert (0); |
1364 | } | ||
1365 | } | 1380 | } |
1381 | } | ||
1366 | } | 1382 | } |
1367 | #endif | 1383 | #endif |
1368 | 1384 | ||
@@ -1393,52 +1409,53 @@ check_fd(struct GNUNET_SCHEDULER_Task *t, int raw_fd) | |||
1393 | * only valid until @a task is started! | 1409 | * only valid until @a task is started! |
1394 | */ | 1410 | */ |
1395 | static struct GNUNET_SCHEDULER_Task * | 1411 | static struct GNUNET_SCHEDULER_Task * |
1396 | add_without_sets(struct GNUNET_TIME_Relative delay, | 1412 | add_without_sets (struct GNUNET_TIME_Relative delay, |
1397 | enum GNUNET_SCHEDULER_Priority priority, | 1413 | enum GNUNET_SCHEDULER_Priority priority, |
1398 | const struct GNUNET_NETWORK_Handle *read_nh, | 1414 | const struct GNUNET_NETWORK_Handle *read_nh, |
1399 | const struct GNUNET_NETWORK_Handle *write_nh, | 1415 | const struct GNUNET_NETWORK_Handle *write_nh, |
1400 | const struct GNUNET_DISK_FileHandle *read_fh, | 1416 | const struct GNUNET_DISK_FileHandle *read_fh, |
1401 | const struct GNUNET_DISK_FileHandle *write_fh, | 1417 | const struct GNUNET_DISK_FileHandle *write_fh, |
1402 | GNUNET_SCHEDULER_TaskCallback task, | 1418 | GNUNET_SCHEDULER_TaskCallback task, |
1403 | void *task_cls) | 1419 | void *task_cls) |
1404 | { | 1420 | { |
1405 | struct GNUNET_SCHEDULER_Task *t; | 1421 | struct GNUNET_SCHEDULER_Task *t; |
1406 | 1422 | ||
1407 | /* scheduler must be running */ | 1423 | /* scheduler must be running */ |
1408 | GNUNET_assert(NULL != scheduler_driver); | 1424 | GNUNET_assert (NULL != scheduler_driver); |
1409 | GNUNET_assert(NULL != task); | 1425 | GNUNET_assert (NULL != task); |
1410 | t = GNUNET_new(struct GNUNET_SCHEDULER_Task); | 1426 | t = GNUNET_new (struct GNUNET_SCHEDULER_Task); |
1411 | GNUNET_async_scope_get(&t->scope); | 1427 | GNUNET_async_scope_get (&t->scope); |
1412 | init_fd_info(t, | 1428 | init_fd_info (t, |
1413 | &read_nh, | 1429 | &read_nh, |
1414 | read_nh ? 1 : 0, | 1430 | read_nh ? 1 : 0, |
1415 | &write_nh, | 1431 | &write_nh, |
1416 | write_nh ? 1 : 0, | 1432 | write_nh ? 1 : 0, |
1417 | &read_fh, | 1433 | &read_fh, |
1418 | read_fh ? 1 : 0, | 1434 | read_fh ? 1 : 0, |
1419 | &write_fh, | 1435 | &write_fh, |
1420 | write_fh ? 1 : 0); | 1436 | write_fh ? 1 : 0); |
1421 | t->callback = task; | 1437 | t->callback = task; |
1422 | t->callback_cls = task_cls; | 1438 | t->callback_cls = task_cls; |
1423 | #if DEBUG_FDS | 1439 | #if DEBUG_FDS |
1424 | check_fd(t, NULL != read_nh ? GNUNET_NETWORK_get_fd(read_nh) : -1); | 1440 | check_fd (t, NULL != read_nh ? GNUNET_NETWORK_get_fd (read_nh) : -1); |
1425 | check_fd(t, NULL != write_nh ? GNUNET_NETWORK_get_fd(write_nh) : -1); | 1441 | check_fd (t, NULL != write_nh ? GNUNET_NETWORK_get_fd (write_nh) : -1); |
1426 | check_fd(t, NULL != read_fh ? read_fh->fd : -1); | 1442 | check_fd (t, NULL != read_fh ? read_fh->fd : -1); |
1427 | check_fd(t, NULL != write_fh ? write_fh->fd : -1); | 1443 | check_fd (t, NULL != write_fh ? write_fh->fd : -1); |
1428 | #endif | 1444 | #endif |
1429 | #if PROFILE_DELAYS | 1445 | #if PROFILE_DELAYS |
1430 | t->start_time = GNUNET_TIME_absolute_get(); | 1446 | t->start_time = GNUNET_TIME_absolute_get (); |
1431 | #endif | 1447 | #endif |
1432 | t->timeout = GNUNET_TIME_relative_to_absolute(delay); | 1448 | t->timeout = GNUNET_TIME_relative_to_absolute (delay); |
1433 | t->priority = check_priority((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority); | 1449 | t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? |
1450 | current_priority : priority); | ||
1434 | t->lifeness = current_lifeness; | 1451 | t->lifeness = current_lifeness; |
1435 | GNUNET_CONTAINER_DLL_insert(pending_head, | 1452 | GNUNET_CONTAINER_DLL_insert (pending_head, |
1436 | pending_tail, | 1453 | pending_tail, |
1437 | t); | 1454 | t); |
1438 | driver_add_multiple(t); | 1455 | driver_add_multiple (t); |
1439 | max_priority_added = GNUNET_MAX(max_priority_added, | 1456 | max_priority_added = GNUNET_MAX (max_priority_added, |
1440 | t->priority); | 1457 | t->priority); |
1441 | init_backtrace(t); | 1458 | init_backtrace (t); |
1442 | return t; | 1459 | return t; |
1443 | } | 1460 | } |
1444 | 1461 | ||
@@ -1464,14 +1481,14 @@ add_without_sets(struct GNUNET_TIME_Relative delay, | |||
1464 | * only valid until @a task is started! | 1481 | * only valid until @a task is started! |
1465 | */ | 1482 | */ |
1466 | struct GNUNET_SCHEDULER_Task * | 1483 | struct GNUNET_SCHEDULER_Task * |
1467 | GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, | 1484 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, |
1468 | struct GNUNET_NETWORK_Handle *rfd, | 1485 | struct GNUNET_NETWORK_Handle *rfd, |
1469 | GNUNET_SCHEDULER_TaskCallback task, | 1486 | GNUNET_SCHEDULER_TaskCallback task, |
1470 | void *task_cls) | 1487 | void *task_cls) |
1471 | { | 1488 | { |
1472 | return GNUNET_SCHEDULER_add_read_net_with_priority(delay, | 1489 | return GNUNET_SCHEDULER_add_read_net_with_priority (delay, |
1473 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1490 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1474 | rfd, task, task_cls); | 1491 | rfd, task, task_cls); |
1475 | } | 1492 | } |
1476 | 1493 | ||
1477 | 1494 | ||
@@ -1498,17 +1515,18 @@ GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, | |||
1498 | * only valid until @a task is started! | 1515 | * only valid until @a task is started! |
1499 | */ | 1516 | */ |
1500 | struct GNUNET_SCHEDULER_Task * | 1517 | struct GNUNET_SCHEDULER_Task * |
1501 | GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, | 1518 | GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay, |
1502 | enum GNUNET_SCHEDULER_Priority priority, | 1519 | enum GNUNET_SCHEDULER_Priority |
1503 | struct GNUNET_NETWORK_Handle *rfd, | 1520 | priority, |
1504 | GNUNET_SCHEDULER_TaskCallback task, | 1521 | struct GNUNET_NETWORK_Handle *rfd, |
1505 | void *task_cls) | 1522 | GNUNET_SCHEDULER_TaskCallback task, |
1523 | void *task_cls) | ||
1506 | { | 1524 | { |
1507 | return GNUNET_SCHEDULER_add_net_with_priority(delay, priority, | 1525 | return GNUNET_SCHEDULER_add_net_with_priority (delay, priority, |
1508 | rfd, | 1526 | rfd, |
1509 | GNUNET_YES, | 1527 | GNUNET_YES, |
1510 | GNUNET_NO, | 1528 | GNUNET_NO, |
1511 | task, task_cls); | 1529 | task, task_cls); |
1512 | } | 1530 | } |
1513 | 1531 | ||
1514 | 1532 | ||
@@ -1534,16 +1552,16 @@ GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, | |||
1534 | * only valid until @a task is started! | 1552 | * only valid until @a task is started! |
1535 | */ | 1553 | */ |
1536 | struct GNUNET_SCHEDULER_Task * | 1554 | struct GNUNET_SCHEDULER_Task * |
1537 | GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, | 1555 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, |
1538 | struct GNUNET_NETWORK_Handle *wfd, | 1556 | struct GNUNET_NETWORK_Handle *wfd, |
1539 | GNUNET_SCHEDULER_TaskCallback task, | 1557 | GNUNET_SCHEDULER_TaskCallback task, |
1540 | void *task_cls) | 1558 | void *task_cls) |
1541 | { | 1559 | { |
1542 | return GNUNET_SCHEDULER_add_net_with_priority(delay, | 1560 | return GNUNET_SCHEDULER_add_net_with_priority (delay, |
1543 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1561 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1544 | wfd, | 1562 | wfd, |
1545 | GNUNET_NO, GNUNET_YES, | 1563 | GNUNET_NO, GNUNET_YES, |
1546 | task, task_cls); | 1564 | task, task_cls); |
1547 | } | 1565 | } |
1548 | 1566 | ||
1549 | /** | 1567 | /** |
@@ -1570,24 +1588,24 @@ GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, | |||
1570 | * only valid until "task" is started! | 1588 | * only valid until "task" is started! |
1571 | */ | 1589 | */ |
1572 | struct GNUNET_SCHEDULER_Task * | 1590 | struct GNUNET_SCHEDULER_Task * |
1573 | GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, | 1591 | GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay, |
1574 | enum GNUNET_SCHEDULER_Priority priority, | 1592 | enum GNUNET_SCHEDULER_Priority priority, |
1575 | struct GNUNET_NETWORK_Handle *fd, | 1593 | struct GNUNET_NETWORK_Handle *fd, |
1576 | int on_read, | 1594 | int on_read, |
1577 | int on_write, | 1595 | int on_write, |
1578 | GNUNET_SCHEDULER_TaskCallback task, | 1596 | GNUNET_SCHEDULER_TaskCallback task, |
1579 | void *task_cls) | 1597 | void *task_cls) |
1580 | { | 1598 | { |
1581 | /* scheduler must be running */ | 1599 | /* scheduler must be running */ |
1582 | GNUNET_assert(NULL != scheduler_driver); | 1600 | GNUNET_assert (NULL != scheduler_driver); |
1583 | GNUNET_assert(on_read || on_write); | 1601 | GNUNET_assert (on_read || on_write); |
1584 | GNUNET_assert(GNUNET_NETWORK_get_fd(fd) >= 0); | 1602 | GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0); |
1585 | return add_without_sets(delay, priority, | 1603 | return add_without_sets (delay, priority, |
1586 | on_read ? fd : NULL, | 1604 | on_read ? fd : NULL, |
1587 | on_write ? fd : NULL, | 1605 | on_write ? fd : NULL, |
1588 | NULL, | 1606 | NULL, |
1589 | NULL, | 1607 | NULL, |
1590 | task, task_cls); | 1608 | task, task_cls); |
1591 | } | 1609 | } |
1592 | 1610 | ||
1593 | 1611 | ||
@@ -1612,11 +1630,12 @@ GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, | |||
1612 | * only valid until @a task is started! | 1630 | * only valid until @a task is started! |
1613 | */ | 1631 | */ |
1614 | struct GNUNET_SCHEDULER_Task * | 1632 | struct GNUNET_SCHEDULER_Task * |
1615 | GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, | 1633 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, |
1616 | const struct GNUNET_DISK_FileHandle *rfd, | 1634 | const struct GNUNET_DISK_FileHandle *rfd, |
1617 | GNUNET_SCHEDULER_TaskCallback task, void *task_cls) | 1635 | GNUNET_SCHEDULER_TaskCallback task, |
1636 | void *task_cls) | ||
1618 | { | 1637 | { |
1619 | return GNUNET_SCHEDULER_add_file_with_priority( | 1638 | return GNUNET_SCHEDULER_add_file_with_priority ( |
1620 | delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1639 | delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1621 | rfd, GNUNET_YES, GNUNET_NO, | 1640 | rfd, GNUNET_YES, GNUNET_NO, |
1622 | task, task_cls); | 1641 | task, task_cls); |
@@ -1644,11 +1663,12 @@ GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, | |||
1644 | * only valid until @a task is started! | 1663 | * only valid until @a task is started! |
1645 | */ | 1664 | */ |
1646 | struct GNUNET_SCHEDULER_Task * | 1665 | struct GNUNET_SCHEDULER_Task * |
1647 | GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, | 1666 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, |
1648 | const struct GNUNET_DISK_FileHandle *wfd, | 1667 | const struct GNUNET_DISK_FileHandle *wfd, |
1649 | GNUNET_SCHEDULER_TaskCallback task, void *task_cls) | 1668 | GNUNET_SCHEDULER_TaskCallback task, |
1669 | void *task_cls) | ||
1650 | { | 1670 | { |
1651 | return GNUNET_SCHEDULER_add_file_with_priority( | 1671 | return GNUNET_SCHEDULER_add_file_with_priority ( |
1652 | delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 1672 | delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
1653 | wfd, GNUNET_NO, GNUNET_YES, | 1673 | wfd, GNUNET_NO, GNUNET_YES, |
1654 | task, task_cls); | 1674 | task, task_cls); |
@@ -1679,31 +1699,34 @@ GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, | |||
1679 | * only valid until @a task is started! | 1699 | * only valid until @a task is started! |
1680 | */ | 1700 | */ |
1681 | struct GNUNET_SCHEDULER_Task * | 1701 | struct GNUNET_SCHEDULER_Task * |
1682 | GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay, | 1702 | GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay, |
1683 | enum GNUNET_SCHEDULER_Priority priority, | 1703 | enum GNUNET_SCHEDULER_Priority |
1684 | const struct GNUNET_DISK_FileHandle *fd, | 1704 | priority, |
1685 | int on_read, int on_write, | 1705 | const struct |
1686 | GNUNET_SCHEDULER_TaskCallback task, void *task_cls) | 1706 | GNUNET_DISK_FileHandle *fd, |
1707 | int on_read, int on_write, | ||
1708 | GNUNET_SCHEDULER_TaskCallback task, | ||
1709 | void *task_cls) | ||
1687 | { | 1710 | { |
1688 | /* scheduler must be running */ | 1711 | /* scheduler must be running */ |
1689 | GNUNET_assert(NULL != scheduler_driver); | 1712 | GNUNET_assert (NULL != scheduler_driver); |
1690 | GNUNET_assert(on_read || on_write); | 1713 | GNUNET_assert (on_read || on_write); |
1691 | GNUNET_assert(fd->fd >= 0); | 1714 | GNUNET_assert (fd->fd >= 0); |
1692 | return add_without_sets(delay, priority, | 1715 | return add_without_sets (delay, priority, |
1693 | NULL, | 1716 | NULL, |
1694 | NULL, | 1717 | NULL, |
1695 | on_read ? fd : NULL, | 1718 | on_read ? fd : NULL, |
1696 | on_write ? fd : NULL, | 1719 | on_write ? fd : NULL, |
1697 | task, task_cls); | 1720 | task, task_cls); |
1698 | } | 1721 | } |
1699 | 1722 | ||
1700 | 1723 | ||
1701 | void | 1724 | void |
1702 | extract_handles(const struct GNUNET_NETWORK_FDSet *fdset, | 1725 | extract_handles (const struct GNUNET_NETWORK_FDSet *fdset, |
1703 | const struct GNUNET_NETWORK_Handle ***ntarget, | 1726 | const struct GNUNET_NETWORK_Handle ***ntarget, |
1704 | unsigned int *extracted_nhandles, | 1727 | unsigned int *extracted_nhandles, |
1705 | const struct GNUNET_DISK_FileHandle ***ftarget, | 1728 | const struct GNUNET_DISK_FileHandle ***ftarget, |
1706 | unsigned int *extracted_fhandles) | 1729 | unsigned int *extracted_fhandles) |
1707 | { | 1730 | { |
1708 | // FIXME: this implementation only works for unix, for WIN32 the file handles | 1731 | // FIXME: this implementation only works for unix, for WIN32 the file handles |
1709 | // in fdset must be handled separately | 1732 | // in fdset must be handled separately |
@@ -1717,31 +1740,31 @@ extract_handles(const struct GNUNET_NETWORK_FDSet *fdset, | |||
1717 | nhandles_len = 0; | 1740 | nhandles_len = 0; |
1718 | fhandles_len = 0; | 1741 | fhandles_len = 0; |
1719 | for (int sock = 0; sock != fdset->nsds; ++sock) | 1742 | for (int sock = 0; sock != fdset->nsds; ++sock) |
1743 | { | ||
1744 | if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (fdset, sock)) | ||
1720 | { | 1745 | { |
1721 | if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native(fdset, sock)) | 1746 | struct GNUNET_NETWORK_Handle *nhandle; |
1747 | struct GNUNET_DISK_FileHandle *fhandle; | ||
1748 | |||
1749 | nhandle = GNUNET_NETWORK_socket_box_native (sock); | ||
1750 | if (NULL != nhandle) | ||
1751 | { | ||
1752 | GNUNET_array_append (nhandles, nhandles_len, nhandle); | ||
1753 | } | ||
1754 | else | ||
1755 | { | ||
1756 | fhandle = GNUNET_DISK_get_handle_from_int_fd (sock); | ||
1757 | if (NULL != fhandle) | ||
1758 | { | ||
1759 | GNUNET_array_append (fhandles, fhandles_len, fhandle); | ||
1760 | } | ||
1761 | else | ||
1722 | { | 1762 | { |
1723 | struct GNUNET_NETWORK_Handle *nhandle; | 1763 | GNUNET_assert (0); |
1724 | struct GNUNET_DISK_FileHandle *fhandle; | ||
1725 | |||
1726 | nhandle = GNUNET_NETWORK_socket_box_native(sock); | ||
1727 | if (NULL != nhandle) | ||
1728 | { | ||
1729 | GNUNET_array_append(nhandles, nhandles_len, nhandle); | ||
1730 | } | ||
1731 | else | ||
1732 | { | ||
1733 | fhandle = GNUNET_DISK_get_handle_from_int_fd(sock); | ||
1734 | if (NULL != fhandle) | ||
1735 | { | ||
1736 | GNUNET_array_append(fhandles, fhandles_len, fhandle); | ||
1737 | } | ||
1738 | else | ||
1739 | { | ||
1740 | GNUNET_assert(0); | ||
1741 | } | ||
1742 | } | ||
1743 | } | 1764 | } |
1765 | } | ||
1744 | } | 1766 | } |
1767 | } | ||
1745 | *ntarget = nhandles_len > 0 ? nhandles : NULL; | 1768 | *ntarget = nhandles_len > 0 ? nhandles : NULL; |
1746 | *ftarget = fhandles_len > 0 ? fhandles : NULL; | 1769 | *ftarget = fhandles_len > 0 ? fhandles : NULL; |
1747 | *extracted_nhandles = nhandles_len; | 1770 | *extracted_nhandles = nhandles_len; |
@@ -1781,12 +1804,12 @@ extract_handles(const struct GNUNET_NETWORK_FDSet *fdset, | |||
1781 | * only valid until @a task is started! | 1804 | * only valid until @a task is started! |
1782 | */ | 1805 | */ |
1783 | struct GNUNET_SCHEDULER_Task * | 1806 | struct GNUNET_SCHEDULER_Task * |
1784 | GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | 1807 | GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, |
1785 | struct GNUNET_TIME_Relative delay, | 1808 | struct GNUNET_TIME_Relative delay, |
1786 | const struct GNUNET_NETWORK_FDSet *rs, | 1809 | const struct GNUNET_NETWORK_FDSet *rs, |
1787 | const struct GNUNET_NETWORK_FDSet *ws, | 1810 | const struct GNUNET_NETWORK_FDSet *ws, |
1788 | GNUNET_SCHEDULER_TaskCallback task, | 1811 | GNUNET_SCHEDULER_TaskCallback task, |
1789 | void *task_cls) | 1812 | void *task_cls) |
1790 | { | 1813 | { |
1791 | struct GNUNET_SCHEDULER_Task *t; | 1814 | struct GNUNET_SCHEDULER_Task *t; |
1792 | const struct GNUNET_NETWORK_Handle **read_nhandles = NULL; | 1815 | const struct GNUNET_NETWORK_Handle **read_nhandles = NULL; |
@@ -1799,8 +1822,8 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | |||
1799 | unsigned int write_fhandles_len = 0; | 1822 | unsigned int write_fhandles_len = 0; |
1800 | 1823 | ||
1801 | /* scheduler must be running */ | 1824 | /* scheduler must be running */ |
1802 | GNUNET_assert(NULL != scheduler_driver); | 1825 | GNUNET_assert (NULL != scheduler_driver); |
1803 | GNUNET_assert(NULL != task); | 1826 | GNUNET_assert (NULL != task); |
1804 | int no_rs = (NULL == rs); | 1827 | int no_rs = (NULL == rs); |
1805 | int no_ws = (NULL == ws); | 1828 | int no_ws = (NULL == ws); |
1806 | int empty_rs = (NULL != rs) && (0 == rs->nsds); | 1829 | int empty_rs = (NULL != rs) && (0 == rs->nsds); |
@@ -1809,25 +1832,25 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | |||
1809 | (empty_rs && empty_ws) || | 1832 | (empty_rs && empty_ws) || |
1810 | (no_rs && empty_ws) || | 1833 | (no_rs && empty_ws) || |
1811 | (no_ws && empty_rs); | 1834 | (no_ws && empty_rs); |
1812 | if (!no_fds) | 1835 | if (! no_fds) |
1836 | { | ||
1837 | if (NULL != rs) | ||
1813 | { | 1838 | { |
1814 | if (NULL != rs) | 1839 | extract_handles (rs, |
1815 | { | 1840 | &read_nhandles, |
1816 | extract_handles(rs, | 1841 | &read_nhandles_len, |
1817 | &read_nhandles, | 1842 | &read_fhandles, |
1818 | &read_nhandles_len, | 1843 | &read_fhandles_len); |
1819 | &read_fhandles, | ||
1820 | &read_fhandles_len); | ||
1821 | } | ||
1822 | if (NULL != ws) | ||
1823 | { | ||
1824 | extract_handles(ws, | ||
1825 | &write_nhandles, | ||
1826 | &write_nhandles_len, | ||
1827 | &write_fhandles, | ||
1828 | &write_fhandles_len); | ||
1829 | } | ||
1830 | } | 1844 | } |
1845 | if (NULL != ws) | ||
1846 | { | ||
1847 | extract_handles (ws, | ||
1848 | &write_nhandles, | ||
1849 | &write_nhandles_len, | ||
1850 | &write_fhandles, | ||
1851 | &write_fhandles_len); | ||
1852 | } | ||
1853 | } | ||
1831 | /** | 1854 | /** |
1832 | * here we consider the case that a GNUNET_NETWORK_FDSet might be empty | 1855 | * here we consider the case that a GNUNET_NETWORK_FDSet might be empty |
1833 | * although its maximum FD number (nsds) is greater than 0. We handle | 1856 | * although its maximum FD number (nsds) is greater than 0. We handle |
@@ -1840,49 +1863,49 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | |||
1840 | (0 == write_nhandles_len) && | 1863 | (0 == write_nhandles_len) && |
1841 | (0 == write_fhandles_len); | 1864 | (0 == write_fhandles_len); |
1842 | if (no_fds || no_fds_extracted) | 1865 | if (no_fds || no_fds_extracted) |
1843 | return GNUNET_SCHEDULER_add_delayed_with_priority(delay, | 1866 | return GNUNET_SCHEDULER_add_delayed_with_priority (delay, |
1844 | prio, | 1867 | prio, |
1845 | task, | 1868 | task, |
1846 | task_cls); | 1869 | task_cls); |
1847 | t = GNUNET_new(struct GNUNET_SCHEDULER_Task); | 1870 | t = GNUNET_new (struct GNUNET_SCHEDULER_Task); |
1848 | GNUNET_async_scope_get(&t->scope); | 1871 | GNUNET_async_scope_get (&t->scope); |
1849 | init_fd_info(t, | 1872 | init_fd_info (t, |
1850 | read_nhandles, | 1873 | read_nhandles, |
1851 | read_nhandles_len, | 1874 | read_nhandles_len, |
1852 | write_nhandles, | 1875 | write_nhandles, |
1853 | write_nhandles_len, | 1876 | write_nhandles_len, |
1854 | read_fhandles, | 1877 | read_fhandles, |
1855 | read_fhandles_len, | 1878 | read_fhandles_len, |
1856 | write_fhandles, | 1879 | write_fhandles, |
1857 | write_fhandles_len); | 1880 | write_fhandles_len); |
1858 | t->callback = task; | 1881 | t->callback = task; |
1859 | t->callback_cls = task_cls; | 1882 | t->callback_cls = task_cls; |
1860 | t->own_handles = GNUNET_YES; | 1883 | t->own_handles = GNUNET_YES; |
1861 | /* free the arrays of pointers to network / file handles, the actual | 1884 | /* free the arrays of pointers to network / file handles, the actual |
1862 | * handles will be freed in destroy_task */ | 1885 | * handles will be freed in destroy_task */ |
1863 | GNUNET_array_grow(read_nhandles, read_nhandles_len, 0); | 1886 | GNUNET_array_grow (read_nhandles, read_nhandles_len, 0); |
1864 | GNUNET_array_grow(write_nhandles, write_nhandles_len, 0); | 1887 | GNUNET_array_grow (write_nhandles, write_nhandles_len, 0); |
1865 | GNUNET_array_grow(read_fhandles, read_fhandles_len, 0); | 1888 | GNUNET_array_grow (read_fhandles, read_fhandles_len, 0); |
1866 | GNUNET_array_grow(write_fhandles, write_fhandles_len, 0); | 1889 | GNUNET_array_grow (write_fhandles, write_fhandles_len, 0); |
1867 | #if PROFILE_DELAYS | 1890 | #if PROFILE_DELAYS |
1868 | t->start_time = GNUNET_TIME_absolute_get(); | 1891 | t->start_time = GNUNET_TIME_absolute_get (); |
1869 | #endif | 1892 | #endif |
1870 | t->timeout = GNUNET_TIME_relative_to_absolute(delay); | 1893 | t->timeout = GNUNET_TIME_relative_to_absolute (delay); |
1871 | t->priority = | 1894 | t->priority = |
1872 | check_priority((prio == | 1895 | check_priority ((prio == |
1873 | GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : | 1896 | GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : |
1874 | prio); | 1897 | prio); |
1875 | t->lifeness = current_lifeness; | 1898 | t->lifeness = current_lifeness; |
1876 | GNUNET_CONTAINER_DLL_insert(pending_head, | 1899 | GNUNET_CONTAINER_DLL_insert (pending_head, |
1877 | pending_tail, | 1900 | pending_tail, |
1878 | t); | 1901 | t); |
1879 | driver_add_multiple(t); | 1902 | driver_add_multiple (t); |
1880 | max_priority_added = GNUNET_MAX(max_priority_added, | 1903 | max_priority_added = GNUNET_MAX (max_priority_added, |
1881 | t->priority); | 1904 | t->priority); |
1882 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1905 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1883 | "Adding task %p\n", | 1906 | "Adding task %p\n", |
1884 | t); | 1907 | t); |
1885 | init_backtrace(t); | 1908 | init_backtrace (t); |
1886 | return t; | 1909 | return t; |
1887 | } | 1910 | } |
1888 | 1911 | ||
@@ -1899,8 +1922,8 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | |||
1899 | * @param fdi information about the related FD | 1922 | * @param fdi information about the related FD |
1900 | */ | 1923 | */ |
1901 | void | 1924 | void |
1902 | GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task, | 1925 | GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task, |
1903 | struct GNUNET_SCHEDULER_FdInfo *fdi) | 1926 | struct GNUNET_SCHEDULER_FdInfo *fdi) |
1904 | { | 1927 | { |
1905 | enum GNUNET_SCHEDULER_Reason reason; | 1928 | enum GNUNET_SCHEDULER_Reason reason; |
1906 | 1929 | ||
@@ -1914,12 +1937,12 @@ GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task, | |||
1914 | reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE; | 1937 | reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE; |
1915 | task->reason = reason; | 1938 | task->reason = reason; |
1916 | if (GNUNET_NO == task->in_ready_list) | 1939 | if (GNUNET_NO == task->in_ready_list) |
1917 | { | 1940 | { |
1918 | GNUNET_CONTAINER_DLL_remove(pending_head, | 1941 | GNUNET_CONTAINER_DLL_remove (pending_head, |
1919 | pending_tail, | 1942 | pending_tail, |
1920 | task); | 1943 | task); |
1921 | queue_ready_task(task); | 1944 | queue_ready_task (task); |
1922 | } | 1945 | } |
1923 | } | 1946 | } |
1924 | 1947 | ||
1925 | 1948 | ||
@@ -1944,173 +1967,174 @@ GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task, | |||
1944 | * if we are done running tasks (yield to block) | 1967 | * if we are done running tasks (yield to block) |
1945 | */ | 1968 | */ |
1946 | int | 1969 | int |
1947 | GNUNET_SCHEDULER_do_work(struct GNUNET_SCHEDULER_Handle *sh) | 1970 | GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh) |
1948 | { | 1971 | { |
1949 | enum GNUNET_SCHEDULER_Priority p; | 1972 | enum GNUNET_SCHEDULER_Priority p; |
1950 | struct GNUNET_SCHEDULER_Task *pos; | 1973 | struct GNUNET_SCHEDULER_Task *pos; |
1951 | struct GNUNET_TIME_Absolute now; | 1974 | struct GNUNET_TIME_Absolute now; |
1952 | 1975 | ||
1953 | /* check for tasks that reached the timeout! */ | 1976 | /* check for tasks that reached the timeout! */ |
1954 | now = GNUNET_TIME_absolute_get(); | 1977 | now = GNUNET_TIME_absolute_get (); |
1955 | pos = pending_timeout_head; | 1978 | pos = pending_timeout_head; |
1956 | while (NULL != pos) | 1979 | while (NULL != pos) |
1957 | { | 1980 | { |
1958 | struct GNUNET_SCHEDULER_Task *next = pos->next; | 1981 | struct GNUNET_SCHEDULER_Task *next = pos->next; |
1959 | if (now.abs_value_us >= pos->timeout.abs_value_us) | 1982 | if (now.abs_value_us >= pos->timeout.abs_value_us) |
1960 | pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; | 1983 | pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; |
1961 | if (0 == pos->reason) | 1984 | if (0 == pos->reason) |
1962 | break; | 1985 | break; |
1963 | GNUNET_CONTAINER_DLL_remove(pending_timeout_head, | 1986 | GNUNET_CONTAINER_DLL_remove (pending_timeout_head, |
1964 | pending_timeout_tail, | 1987 | pending_timeout_tail, |
1965 | pos); | 1988 | pos); |
1966 | if (pending_timeout_last == pos) | 1989 | if (pending_timeout_last == pos) |
1967 | pending_timeout_last = NULL; | 1990 | pending_timeout_last = NULL; |
1968 | queue_ready_task(pos); | 1991 | queue_ready_task (pos); |
1969 | pos = next; | 1992 | pos = next; |
1970 | } | 1993 | } |
1971 | pos = pending_head; | 1994 | pos = pending_head; |
1972 | while (NULL != pos) | 1995 | while (NULL != pos) |
1996 | { | ||
1997 | struct GNUNET_SCHEDULER_Task *next = pos->next; | ||
1998 | if (now.abs_value_us >= pos->timeout.abs_value_us) | ||
1973 | { | 1999 | { |
1974 | struct GNUNET_SCHEDULER_Task *next = pos->next; | 2000 | pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; |
1975 | if (now.abs_value_us >= pos->timeout.abs_value_us) | 2001 | GNUNET_CONTAINER_DLL_remove (pending_head, |
1976 | { | 2002 | pending_tail, |
1977 | pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; | 2003 | pos); |
1978 | GNUNET_CONTAINER_DLL_remove(pending_head, | 2004 | queue_ready_task (pos); |
1979 | pending_tail, | ||
1980 | pos); | ||
1981 | queue_ready_task(pos); | ||
1982 | } | ||
1983 | pos = next; | ||
1984 | } | 2005 | } |
2006 | pos = next; | ||
2007 | } | ||
1985 | 2008 | ||
1986 | if (0 == ready_count) | 2009 | if (0 == ready_count) |
1987 | { | 2010 | { |
1988 | struct GNUNET_TIME_Absolute timeout = get_timeout(); | 2011 | struct GNUNET_TIME_Absolute timeout = get_timeout (); |
1989 | 2012 | ||
1990 | if (timeout.abs_value_us > now.abs_value_us) | 2013 | if (timeout.abs_value_us > now.abs_value_us) |
1991 | { | 2014 | { |
1992 | /** | 2015 | /** |
1993 | * The event loop called this function before the current timeout was | 2016 | * The event loop called this function before the current timeout was |
1994 | * reached (and no FD tasks are ready). This is acceptable if | 2017 | * reached (and no FD tasks are ready). This is acceptable if |
1995 | * | 2018 | * |
1996 | * - the system time was changed while the driver was waiting for | 2019 | * - the system time was changed while the driver was waiting for |
1997 | * the timeout | 2020 | * the timeout |
1998 | * - an external event loop called GNUnet API functions outside of | 2021 | * - an external event loop called GNUnet API functions outside of |
1999 | * the callbacks called in GNUNET_SCHEDULER_do_work and thus | 2022 | * the callbacks called in GNUNET_SCHEDULER_do_work and thus |
2000 | * wasn't notified about the new timeout | 2023 | * wasn't notified about the new timeout |
2001 | * | 2024 | * |
2002 | * It might also mean we are busy-waiting because of a programming | 2025 | * It might also mean we are busy-waiting because of a programming |
2003 | * error in the external event loop. | 2026 | * error in the external event loop. |
2004 | */ | 2027 | */ |
2005 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2028 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2006 | "GNUNET_SCHEDULER_do_work did not find any ready " | 2029 | "GNUNET_SCHEDULER_do_work did not find any ready " |
2007 | "tasks and timeout has not been reached yet.\n"); | 2030 | "tasks and timeout has not been reached yet.\n"); |
2008 | } | ||
2009 | else | ||
2010 | { | ||
2011 | /** | ||
2012 | * the current timeout was reached but no ready tasks were found, | ||
2013 | * internal scheduler error! | ||
2014 | */ | ||
2015 | GNUNET_assert(0); | ||
2016 | } | ||
2017 | } | 2031 | } |
2032 | else | ||
2033 | { | ||
2034 | /** | ||
2035 | * the current timeout was reached but no ready tasks were found, | ||
2036 | * internal scheduler error! | ||
2037 | */ | ||
2038 | GNUNET_assert (0); | ||
2039 | } | ||
2040 | } | ||
2018 | else | 2041 | else |
2042 | { | ||
2043 | /* find out which task priority level we are going to | ||
2044 | process this time */ | ||
2045 | max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP; | ||
2046 | GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]); | ||
2047 | /* yes, p>0 is correct, 0 is "KEEP" which should | ||
2048 | * always be an empty queue (see assertion)! */ | ||
2049 | for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--) | ||
2019 | { | 2050 | { |
2020 | /* find out which task priority level we are going to | 2051 | pos = ready_head[p]; |
2021 | process this time */ | 2052 | if (NULL != pos) |
2022 | max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP; | 2053 | break; |
2023 | GNUNET_assert(NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]); | 2054 | } |
2024 | /* yes, p>0 is correct, 0 is "KEEP" which should | 2055 | GNUNET_assert (NULL != pos); /* ready_count wrong? */ |
2025 | * always be an empty queue (see assertion)! */ | ||
2026 | for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--) | ||
2027 | { | ||
2028 | pos = ready_head[p]; | ||
2029 | if (NULL != pos) | ||
2030 | break; | ||
2031 | } | ||
2032 | GNUNET_assert(NULL != pos); /* ready_count wrong? */ | ||
2033 | 2056 | ||
2034 | /* process all tasks at this priority level, then yield */ | 2057 | /* process all tasks at this priority level, then yield */ |
2035 | while (NULL != (pos = ready_head[p])) | 2058 | while (NULL != (pos = ready_head[p])) |
2036 | { | 2059 | { |
2037 | GNUNET_CONTAINER_DLL_remove(ready_head[p], | 2060 | GNUNET_CONTAINER_DLL_remove (ready_head[p], |
2038 | ready_tail[p], | 2061 | ready_tail[p], |
2039 | pos); | 2062 | pos); |
2040 | ready_count--; | 2063 | ready_count--; |
2041 | current_priority = pos->priority; | 2064 | current_priority = pos->priority; |
2042 | current_lifeness = pos->lifeness; | 2065 | current_lifeness = pos->lifeness; |
2043 | active_task = pos; | 2066 | active_task = pos; |
2044 | #if PROFILE_DELAYS | 2067 | #if PROFILE_DELAYS |
2045 | if (GNUNET_TIME_absolute_get_duration(pos->start_time).rel_value_us > | 2068 | if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us > |
2046 | DELAY_THRESHOLD.rel_value_us) | 2069 | DELAY_THRESHOLD.rel_value_us) |
2047 | { | 2070 | { |
2048 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2071 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2049 | "Task %p took %s to be scheduled\n", | 2072 | "Task %p took %s to be scheduled\n", |
2050 | pos, | 2073 | pos, |
2051 | GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(pos->start_time), | 2074 | GNUNET_STRINGS_relative_time_to_string ( |
2052 | GNUNET_YES)); | 2075 | GNUNET_TIME_absolute_get_duration (pos->start_time), |
2053 | } | 2076 | GNUNET_YES)); |
2077 | } | ||
2054 | #endif | 2078 | #endif |
2055 | tc.reason = pos->reason; | 2079 | tc.reason = pos->reason; |
2056 | GNUNET_NETWORK_fdset_zero(sh->rs); | 2080 | GNUNET_NETWORK_fdset_zero (sh->rs); |
2057 | GNUNET_NETWORK_fdset_zero(sh->ws); | 2081 | GNUNET_NETWORK_fdset_zero (sh->ws); |
2058 | // FIXME: do we have to remove FdInfos from fds if they are not ready? | 2082 | // FIXME: do we have to remove FdInfos from fds if they are not ready? |
2059 | tc.fds_len = pos->fds_len; | 2083 | tc.fds_len = pos->fds_len; |
2060 | tc.fds = pos->fds; | 2084 | tc.fds = pos->fds; |
2061 | for (unsigned int i = 0; i != pos->fds_len; ++i) | 2085 | for (unsigned int i = 0; i != pos->fds_len; ++i) |
2062 | { | 2086 | { |
2063 | struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i]; | 2087 | struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i]; |
2064 | if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)) | 2088 | if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)) |
2065 | { | 2089 | { |
2066 | GNUNET_NETWORK_fdset_set_native(sh->rs, | 2090 | GNUNET_NETWORK_fdset_set_native (sh->rs, |
2067 | fdi->sock); | 2091 | fdi->sock); |
2068 | } | ||
2069 | if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)) | ||
2070 | { | ||
2071 | GNUNET_NETWORK_fdset_set_native(sh->ws, | ||
2072 | fdi->sock); | ||
2073 | } | ||
2074 | } | ||
2075 | tc.read_ready = sh->rs; | ||
2076 | tc.write_ready = sh->ws; | ||
2077 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
2078 | "Running task %p\n", | ||
2079 | pos); | ||
2080 | GNUNET_assert(NULL != pos->callback); | ||
2081 | { | ||
2082 | struct GNUNET_AsyncScopeSave old_scope; | ||
2083 | if (pos->scope.have_scope) | ||
2084 | GNUNET_async_scope_enter(&pos->scope.scope_id, &old_scope); | ||
2085 | else | ||
2086 | GNUNET_async_scope_get(&old_scope); | ||
2087 | pos->callback(pos->callback_cls); | ||
2088 | GNUNET_async_scope_restore(&old_scope); | ||
2089 | } | ||
2090 | if (NULL != pos->fds) | ||
2091 | { | ||
2092 | int del_result = scheduler_driver->del(scheduler_driver->cls, pos); | ||
2093 | if (GNUNET_OK != del_result) | ||
2094 | { | ||
2095 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
2096 | "driver could not delete task %p\n", pos); | ||
2097 | GNUNET_assert(0); | ||
2098 | } | ||
2099 | } | ||
2100 | active_task = NULL; | ||
2101 | dump_backtrace(pos); | ||
2102 | destroy_task(pos); | ||
2103 | } | 2092 | } |
2093 | if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)) | ||
2094 | { | ||
2095 | GNUNET_NETWORK_fdset_set_native (sh->ws, | ||
2096 | fdi->sock); | ||
2097 | } | ||
2098 | } | ||
2099 | tc.read_ready = sh->rs; | ||
2100 | tc.write_ready = sh->ws; | ||
2101 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2102 | "Running task %p\n", | ||
2103 | pos); | ||
2104 | GNUNET_assert (NULL != pos->callback); | ||
2105 | { | ||
2106 | struct GNUNET_AsyncScopeSave old_scope; | ||
2107 | if (pos->scope.have_scope) | ||
2108 | GNUNET_async_scope_enter (&pos->scope.scope_id, &old_scope); | ||
2109 | else | ||
2110 | GNUNET_async_scope_get (&old_scope); | ||
2111 | pos->callback (pos->callback_cls); | ||
2112 | GNUNET_async_scope_restore (&old_scope); | ||
2113 | } | ||
2114 | if (NULL != pos->fds) | ||
2115 | { | ||
2116 | int del_result = scheduler_driver->del (scheduler_driver->cls, pos); | ||
2117 | if (GNUNET_OK != del_result) | ||
2118 | { | ||
2119 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2120 | "driver could not delete task %p\n", pos); | ||
2121 | GNUNET_assert (0); | ||
2122 | } | ||
2123 | } | ||
2124 | active_task = NULL; | ||
2125 | dump_backtrace (pos); | ||
2126 | destroy_task (pos); | ||
2104 | } | 2127 | } |
2105 | shutdown_if_no_lifeness(); | 2128 | } |
2129 | shutdown_if_no_lifeness (); | ||
2106 | if (0 == ready_count) | 2130 | if (0 == ready_count) |
2107 | { | 2131 | { |
2108 | scheduler_driver->set_wakeup(scheduler_driver->cls, | 2132 | scheduler_driver->set_wakeup (scheduler_driver->cls, |
2109 | get_timeout()); | 2133 | get_timeout ()); |
2110 | return GNUNET_NO; | 2134 | return GNUNET_NO; |
2111 | } | 2135 | } |
2112 | scheduler_driver->set_wakeup(scheduler_driver->cls, | 2136 | scheduler_driver->set_wakeup (scheduler_driver->cls, |
2113 | GNUNET_TIME_absolute_get()); | 2137 | GNUNET_TIME_absolute_get ()); |
2114 | return GNUNET_YES; | 2138 | return GNUNET_YES; |
2115 | } | 2139 | } |
2116 | 2140 | ||
@@ -2147,62 +2171,62 @@ GNUNET_SCHEDULER_do_work(struct GNUNET_SCHEDULER_Handle *sh) | |||
2147 | * #GNUNET_SCHEDULER_driver_done | 2171 | * #GNUNET_SCHEDULER_driver_done |
2148 | */ | 2172 | */ |
2149 | struct GNUNET_SCHEDULER_Handle * | 2173 | struct GNUNET_SCHEDULER_Handle * |
2150 | GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver) | 2174 | GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver) |
2151 | { | 2175 | { |
2152 | struct GNUNET_SCHEDULER_Handle *sh; | 2176 | struct GNUNET_SCHEDULER_Handle *sh; |
2153 | const struct GNUNET_DISK_FileHandle *pr; | 2177 | const struct GNUNET_DISK_FileHandle *pr; |
2154 | 2178 | ||
2155 | /* scheduler must not be running */ | 2179 | /* scheduler must not be running */ |
2156 | GNUNET_assert(NULL == scheduler_driver); | 2180 | GNUNET_assert (NULL == scheduler_driver); |
2157 | GNUNET_assert(NULL == shutdown_pipe_handle); | 2181 | GNUNET_assert (NULL == shutdown_pipe_handle); |
2158 | /* general set-up */ | 2182 | /* general set-up */ |
2159 | sh = GNUNET_new(struct GNUNET_SCHEDULER_Handle); | 2183 | sh = GNUNET_new (struct GNUNET_SCHEDULER_Handle); |
2160 | shutdown_pipe_handle = GNUNET_DISK_pipe(GNUNET_NO, | 2184 | shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, |
2161 | GNUNET_NO, | 2185 | GNUNET_NO, |
2162 | GNUNET_NO, | 2186 | GNUNET_NO, |
2163 | GNUNET_NO); | 2187 | GNUNET_NO); |
2164 | GNUNET_assert(NULL != shutdown_pipe_handle); | 2188 | GNUNET_assert (NULL != shutdown_pipe_handle); |
2165 | pr = GNUNET_DISK_pipe_handle(shutdown_pipe_handle, | 2189 | pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle, |
2166 | GNUNET_DISK_PIPE_END_READ); | 2190 | GNUNET_DISK_PIPE_END_READ); |
2167 | my_pid = getpid(); | 2191 | my_pid = getpid (); |
2168 | scheduler_driver = driver; | 2192 | scheduler_driver = driver; |
2169 | 2193 | ||
2170 | /* install signal handlers */ | 2194 | /* install signal handlers */ |
2171 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2195 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2172 | "Registering signal handlers\n"); | 2196 | "Registering signal handlers\n"); |
2173 | sh->shc_int = GNUNET_SIGNAL_handler_install(SIGINT, | 2197 | sh->shc_int = GNUNET_SIGNAL_handler_install (SIGINT, |
2174 | &sighandler_shutdown); | ||
2175 | sh->shc_term = GNUNET_SIGNAL_handler_install(SIGTERM, | ||
2176 | &sighandler_shutdown); | 2198 | &sighandler_shutdown); |
2177 | #if (SIGTERM != GNUNET_TERM_SIG) | 2199 | sh->shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, |
2178 | sh->shc_gterm = GNUNET_SIGNAL_handler_install(GNUNET_TERM_SIG, | ||
2179 | &sighandler_shutdown); | 2200 | &sighandler_shutdown); |
2201 | #if (SIGTERM != GNUNET_TERM_SIG) | ||
2202 | sh->shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG, | ||
2203 | &sighandler_shutdown); | ||
2180 | #endif | 2204 | #endif |
2181 | sh->shc_pipe = GNUNET_SIGNAL_handler_install(SIGPIPE, | 2205 | sh->shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE, |
2182 | &sighandler_pipe); | 2206 | &sighandler_pipe); |
2183 | sh->shc_quit = GNUNET_SIGNAL_handler_install(SIGQUIT, | 2207 | sh->shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, |
2208 | &sighandler_shutdown); | ||
2209 | sh->shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, | ||
2184 | &sighandler_shutdown); | 2210 | &sighandler_shutdown); |
2185 | sh->shc_hup = GNUNET_SIGNAL_handler_install(SIGHUP, | ||
2186 | &sighandler_shutdown); | ||
2187 | 2211 | ||
2188 | /* Setup initial tasks */ | 2212 | /* Setup initial tasks */ |
2189 | current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; | 2213 | current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; |
2190 | current_lifeness = GNUNET_NO; | 2214 | current_lifeness = GNUNET_NO; |
2191 | install_parent_control_task = | 2215 | install_parent_control_task = |
2192 | GNUNET_SCHEDULER_add_now(&install_parent_control_handler, | 2216 | GNUNET_SCHEDULER_add_now (&install_parent_control_handler, |
2193 | NULL); | 2217 | NULL); |
2194 | shutdown_pipe_task = | 2218 | shutdown_pipe_task = |
2195 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 2219 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
2196 | pr, | 2220 | pr, |
2197 | &shutdown_pipe_cb, | 2221 | &shutdown_pipe_cb, |
2198 | NULL); | 2222 | NULL); |
2199 | current_lifeness = GNUNET_YES; | 2223 | current_lifeness = GNUNET_YES; |
2200 | scheduler_driver->set_wakeup(scheduler_driver->cls, | 2224 | scheduler_driver->set_wakeup (scheduler_driver->cls, |
2201 | get_timeout()); | 2225 | get_timeout ()); |
2202 | /* begin main event loop */ | 2226 | /* begin main event loop */ |
2203 | sh->rs = GNUNET_NETWORK_fdset_create(); | 2227 | sh->rs = GNUNET_NETWORK_fdset_create (); |
2204 | sh->ws = GNUNET_NETWORK_fdset_create(); | 2228 | sh->ws = GNUNET_NETWORK_fdset_create (); |
2205 | GNUNET_NETWORK_fdset_handle_set(sh->rs, pr); | 2229 | GNUNET_NETWORK_fdset_handle_set (sh->rs, pr); |
2206 | return sh; | 2230 | return sh; |
2207 | } | 2231 | } |
2208 | 2232 | ||
@@ -2222,241 +2246,242 @@ GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver) | |||
2222 | * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init | 2246 | * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init |
2223 | */ | 2247 | */ |
2224 | void | 2248 | void |
2225 | GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh) | 2249 | GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh) |
2226 | { | 2250 | { |
2227 | GNUNET_assert(NULL == pending_head); | 2251 | GNUNET_assert (NULL == pending_head); |
2228 | GNUNET_assert(NULL == pending_timeout_head); | 2252 | GNUNET_assert (NULL == pending_timeout_head); |
2229 | GNUNET_assert(NULL == shutdown_head); | 2253 | GNUNET_assert (NULL == shutdown_head); |
2230 | for (int i = 0; i != GNUNET_SCHEDULER_PRIORITY_COUNT; ++i) | 2254 | for (int i = 0; i != GNUNET_SCHEDULER_PRIORITY_COUNT; ++i) |
2231 | { | 2255 | { |
2232 | GNUNET_assert(NULL == ready_head[i]); | 2256 | GNUNET_assert (NULL == ready_head[i]); |
2233 | } | 2257 | } |
2234 | GNUNET_NETWORK_fdset_destroy(sh->rs); | 2258 | GNUNET_NETWORK_fdset_destroy (sh->rs); |
2235 | GNUNET_NETWORK_fdset_destroy(sh->ws); | 2259 | GNUNET_NETWORK_fdset_destroy (sh->ws); |
2236 | 2260 | ||
2237 | /* uninstall signal handlers */ | 2261 | /* uninstall signal handlers */ |
2238 | GNUNET_SIGNAL_handler_uninstall(sh->shc_int); | 2262 | GNUNET_SIGNAL_handler_uninstall (sh->shc_int); |
2239 | GNUNET_SIGNAL_handler_uninstall(sh->shc_term); | 2263 | GNUNET_SIGNAL_handler_uninstall (sh->shc_term); |
2240 | #if (SIGTERM != GNUNET_TERM_SIG) | 2264 | #if (SIGTERM != GNUNET_TERM_SIG) |
2241 | GNUNET_SIGNAL_handler_uninstall(sh->shc_gterm); | 2265 | GNUNET_SIGNAL_handler_uninstall (sh->shc_gterm); |
2242 | #endif | 2266 | #endif |
2243 | GNUNET_SIGNAL_handler_uninstall(sh->shc_pipe); | 2267 | GNUNET_SIGNAL_handler_uninstall (sh->shc_pipe); |
2244 | GNUNET_SIGNAL_handler_uninstall(sh->shc_quit); | 2268 | GNUNET_SIGNAL_handler_uninstall (sh->shc_quit); |
2245 | GNUNET_SIGNAL_handler_uninstall(sh->shc_hup); | 2269 | GNUNET_SIGNAL_handler_uninstall (sh->shc_hup); |
2246 | GNUNET_DISK_pipe_close(shutdown_pipe_handle); | 2270 | GNUNET_DISK_pipe_close (shutdown_pipe_handle); |
2247 | shutdown_pipe_handle = NULL; | 2271 | shutdown_pipe_handle = NULL; |
2248 | scheduler_driver = NULL; | 2272 | scheduler_driver = NULL; |
2249 | GNUNET_free(sh); | 2273 | GNUNET_free (sh); |
2250 | } | 2274 | } |
2251 | 2275 | ||
2252 | 2276 | ||
2253 | static int | 2277 | static int |
2254 | select_loop(struct GNUNET_SCHEDULER_Handle *sh, | 2278 | select_loop (struct GNUNET_SCHEDULER_Handle *sh, |
2255 | struct DriverContext *context) | 2279 | struct DriverContext *context) |
2256 | { | 2280 | { |
2257 | struct GNUNET_NETWORK_FDSet *rs; | 2281 | struct GNUNET_NETWORK_FDSet *rs; |
2258 | struct GNUNET_NETWORK_FDSet *ws; | 2282 | struct GNUNET_NETWORK_FDSet *ws; |
2259 | int select_result; | 2283 | int select_result; |
2260 | 2284 | ||
2261 | GNUNET_assert(NULL != context); | 2285 | GNUNET_assert (NULL != context); |
2262 | rs = GNUNET_NETWORK_fdset_create(); | 2286 | rs = GNUNET_NETWORK_fdset_create (); |
2263 | ws = GNUNET_NETWORK_fdset_create(); | 2287 | ws = GNUNET_NETWORK_fdset_create (); |
2264 | while ((NULL != context->scheduled_head) || | 2288 | while ((NULL != context->scheduled_head) || |
2265 | (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us != context->timeout.abs_value_us)) | 2289 | (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us != |
2290 | context->timeout.abs_value_us)) | ||
2291 | { | ||
2292 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2293 | "select timeout = %s\n", | ||
2294 | GNUNET_STRINGS_absolute_time_to_string (context->timeout)); | ||
2295 | |||
2296 | GNUNET_NETWORK_fdset_zero (rs); | ||
2297 | GNUNET_NETWORK_fdset_zero (ws); | ||
2298 | |||
2299 | for (struct Scheduled *pos = context->scheduled_head; | ||
2300 | NULL != pos; | ||
2301 | pos = pos->next) | ||
2266 | { | 2302 | { |
2267 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2303 | if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et)) |
2268 | "select timeout = %s\n", | 2304 | { |
2269 | GNUNET_STRINGS_absolute_time_to_string(context->timeout)); | 2305 | GNUNET_NETWORK_fdset_set_native (rs, pos->fdi->sock); |
2270 | 2306 | } | |
2271 | GNUNET_NETWORK_fdset_zero(rs); | 2307 | if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et)) |
2272 | GNUNET_NETWORK_fdset_zero(ws); | 2308 | { |
2273 | 2309 | GNUNET_NETWORK_fdset_set_native (ws, pos->fdi->sock); | |
2274 | for (struct Scheduled *pos = context->scheduled_head; | 2310 | } |
2275 | NULL != pos; | 2311 | } |
2276 | pos = pos->next) | 2312 | struct GNUNET_TIME_Relative time_remaining = |
2277 | { | 2313 | GNUNET_TIME_absolute_get_remaining (context->timeout); |
2278 | if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et)) | 2314 | if (NULL == scheduler_select) |
2279 | { | 2315 | { |
2280 | GNUNET_NETWORK_fdset_set_native(rs, pos->fdi->sock); | 2316 | select_result = GNUNET_NETWORK_socket_select (rs, |
2281 | } | 2317 | ws, |
2282 | if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et)) | 2318 | NULL, |
2283 | { | 2319 | time_remaining); |
2284 | GNUNET_NETWORK_fdset_set_native(ws, pos->fdi->sock); | 2320 | } |
2285 | } | 2321 | else |
2286 | } | 2322 | { |
2287 | struct GNUNET_TIME_Relative time_remaining = | 2323 | select_result = scheduler_select (scheduler_select_cls, |
2288 | GNUNET_TIME_absolute_get_remaining(context->timeout); | 2324 | rs, |
2289 | if (NULL == scheduler_select) | 2325 | ws, |
2290 | { | 2326 | NULL, |
2291 | select_result = GNUNET_NETWORK_socket_select(rs, | 2327 | time_remaining); |
2292 | ws, | 2328 | } |
2293 | NULL, | 2329 | if (select_result == GNUNET_SYSERR) |
2294 | time_remaining); | 2330 | { |
2295 | } | 2331 | if (errno == EINTR) |
2296 | else | 2332 | continue; |
2297 | { | ||
2298 | select_result = scheduler_select(scheduler_select_cls, | ||
2299 | rs, | ||
2300 | ws, | ||
2301 | NULL, | ||
2302 | time_remaining); | ||
2303 | } | ||
2304 | if (select_result == GNUNET_SYSERR) | ||
2305 | { | ||
2306 | if (errno == EINTR) | ||
2307 | continue; | ||
2308 | 2333 | ||
2309 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, | 2334 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, |
2310 | "select"); | 2335 | "select"); |
2311 | #if USE_LSOF | 2336 | #if USE_LSOF |
2312 | char lsof[512]; | 2337 | char lsof[512]; |
2313 | 2338 | ||
2314 | snprintf(lsof, | 2339 | snprintf (lsof, |
2315 | sizeof(lsof), | 2340 | sizeof(lsof), |
2316 | "lsof -p %d", | 2341 | "lsof -p %d", |
2317 | getpid()); | 2342 | getpid ()); |
2318 | (void)close(1); | 2343 | (void) close (1); |
2319 | (void)dup2(2, 1); | 2344 | (void) dup2 (2, 1); |
2320 | if (0 != system(lsof)) | 2345 | if (0 != system (lsof)) |
2321 | LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, | 2346 | LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, |
2322 | "system"); | 2347 | "system"); |
2323 | #endif | 2348 | #endif |
2324 | #if DEBUG_FDS | 2349 | #if DEBUG_FDS |
2325 | for (struct Scheduled *s = context->scheduled_head; | 2350 | for (struct Scheduled *s = context->scheduled_head; |
2326 | NULL != s; | 2351 | NULL != s; |
2327 | s = s->next) | 2352 | s = s->next) |
2328 | { | 2353 | { |
2329 | int flags = fcntl(s->fdi->sock, | 2354 | int flags = fcntl (s->fdi->sock, |
2330 | F_GETFD); | 2355 | F_GETFD); |
2331 | 2356 | ||
2332 | if ((flags == -1) && | 2357 | if ((flags == -1) && |
2333 | (EBADF == errno)) | 2358 | (EBADF == errno)) |
2334 | { | 2359 | { |
2335 | LOG(GNUNET_ERROR_TYPE_ERROR, | 2360 | LOG (GNUNET_ERROR_TYPE_ERROR, |
2336 | "Got invalid file descriptor %d!\n", | 2361 | "Got invalid file descriptor %d!\n", |
2337 | s->fdi->sock); | 2362 | s->fdi->sock); |
2338 | #if EXECINFO | 2363 | #if EXECINFO |
2339 | dump_backtrace(s->task); | 2364 | dump_backtrace (s->task); |
2340 | #endif | 2365 | #endif |
2341 | } | 2366 | } |
2342 | } | 2367 | } |
2343 | #endif | 2368 | #endif |
2344 | GNUNET_assert(0); | 2369 | GNUNET_assert (0); |
2345 | GNUNET_NETWORK_fdset_destroy(rs); | 2370 | GNUNET_NETWORK_fdset_destroy (rs); |
2346 | GNUNET_NETWORK_fdset_destroy(ws); | 2371 | GNUNET_NETWORK_fdset_destroy (ws); |
2347 | return GNUNET_SYSERR; | 2372 | return GNUNET_SYSERR; |
2373 | } | ||
2374 | if (select_result > 0) | ||
2375 | { | ||
2376 | for (struct Scheduled *pos = context->scheduled_head; | ||
2377 | NULL != pos; | ||
2378 | pos = pos->next) | ||
2379 | { | ||
2380 | int is_ready = GNUNET_NO; | ||
2381 | |||
2382 | if ((0 != (GNUNET_SCHEDULER_ET_IN & pos->et)) && | ||
2383 | (GNUNET_YES == | ||
2384 | GNUNET_NETWORK_fdset_test_native (rs, | ||
2385 | pos->fdi->sock)) ) | ||
2386 | { | ||
2387 | pos->fdi->et |= GNUNET_SCHEDULER_ET_IN; | ||
2388 | is_ready = GNUNET_YES; | ||
2348 | } | 2389 | } |
2349 | if (select_result > 0) | 2390 | if ((0 != (GNUNET_SCHEDULER_ET_OUT & pos->et)) && |
2391 | (GNUNET_YES == | ||
2392 | GNUNET_NETWORK_fdset_test_native (ws, | ||
2393 | pos->fdi->sock)) ) | ||
2350 | { | 2394 | { |
2351 | for (struct Scheduled *pos = context->scheduled_head; | 2395 | pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT; |
2352 | NULL != pos; | 2396 | is_ready = GNUNET_YES; |
2353 | pos = pos->next) | ||
2354 | { | ||
2355 | int is_ready = GNUNET_NO; | ||
2356 | |||
2357 | if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) && | ||
2358 | GNUNET_YES == | ||
2359 | GNUNET_NETWORK_fdset_test_native(rs, | ||
2360 | pos->fdi->sock)) | ||
2361 | { | ||
2362 | pos->fdi->et |= GNUNET_SCHEDULER_ET_IN; | ||
2363 | is_ready = GNUNET_YES; | ||
2364 | } | ||
2365 | if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) && | ||
2366 | GNUNET_YES == | ||
2367 | GNUNET_NETWORK_fdset_test_native(ws, | ||
2368 | pos->fdi->sock)) | ||
2369 | { | ||
2370 | pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT; | ||
2371 | is_ready = GNUNET_YES; | ||
2372 | } | ||
2373 | if (GNUNET_YES == is_ready) | ||
2374 | { | ||
2375 | GNUNET_SCHEDULER_task_ready(pos->task, | ||
2376 | pos->fdi); | ||
2377 | } | ||
2378 | } | ||
2379 | } | 2397 | } |
2380 | if (GNUNET_YES == GNUNET_SCHEDULER_do_work(sh)) | 2398 | if (GNUNET_YES == is_ready) |
2381 | { | 2399 | { |
2382 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2400 | GNUNET_SCHEDULER_task_ready (pos->task, |
2383 | "scheduler has more tasks ready!\n"); | 2401 | pos->fdi); |
2384 | } | 2402 | } |
2403 | } | ||
2404 | } | ||
2405 | if (GNUNET_YES == GNUNET_SCHEDULER_do_work (sh)) | ||
2406 | { | ||
2407 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2408 | "scheduler has more tasks ready!\n"); | ||
2385 | } | 2409 | } |
2386 | GNUNET_NETWORK_fdset_destroy(rs); | 2410 | } |
2387 | GNUNET_NETWORK_fdset_destroy(ws); | 2411 | GNUNET_NETWORK_fdset_destroy (rs); |
2412 | GNUNET_NETWORK_fdset_destroy (ws); | ||
2388 | return GNUNET_OK; | 2413 | return GNUNET_OK; |
2389 | } | 2414 | } |
2390 | 2415 | ||
2391 | 2416 | ||
2392 | static int | 2417 | static int |
2393 | select_add(void *cls, | 2418 | select_add (void *cls, |
2394 | struct GNUNET_SCHEDULER_Task *task, | 2419 | struct GNUNET_SCHEDULER_Task *task, |
2395 | struct GNUNET_SCHEDULER_FdInfo *fdi) | 2420 | struct GNUNET_SCHEDULER_FdInfo *fdi) |
2396 | { | 2421 | { |
2397 | struct DriverContext *context = cls; | 2422 | struct DriverContext *context = cls; |
2398 | 2423 | ||
2399 | GNUNET_assert(NULL != context); | 2424 | GNUNET_assert (NULL != context); |
2400 | GNUNET_assert(NULL != task); | 2425 | GNUNET_assert (NULL != task); |
2401 | GNUNET_assert(NULL != fdi); | 2426 | GNUNET_assert (NULL != fdi); |
2402 | GNUNET_assert(0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) || | 2427 | GNUNET_assert (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) || |
2403 | 0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)); | 2428 | 0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)); |
2404 | 2429 | ||
2405 | if (!((NULL != fdi->fd) ^ (NULL != fdi->fh)) || (fdi->sock < 0)) | 2430 | if (! ((NULL != fdi->fd) ^ (NULL != fdi->fh)) || (fdi->sock < 0)) |
2406 | { | 2431 | { |
2407 | /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */ | 2432 | /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */ |
2408 | return GNUNET_SYSERR; | 2433 | return GNUNET_SYSERR; |
2409 | } | 2434 | } |
2410 | 2435 | ||
2411 | struct Scheduled *scheduled = GNUNET_new(struct Scheduled); | 2436 | struct Scheduled *scheduled = GNUNET_new (struct Scheduled); |
2412 | scheduled->task = task; | 2437 | scheduled->task = task; |
2413 | scheduled->fdi = fdi; | 2438 | scheduled->fdi = fdi; |
2414 | scheduled->et = fdi->et; | 2439 | scheduled->et = fdi->et; |
2415 | 2440 | ||
2416 | GNUNET_CONTAINER_DLL_insert(context->scheduled_head, | 2441 | GNUNET_CONTAINER_DLL_insert (context->scheduled_head, |
2417 | context->scheduled_tail, | 2442 | context->scheduled_tail, |
2418 | scheduled); | 2443 | scheduled); |
2419 | return GNUNET_OK; | 2444 | return GNUNET_OK; |
2420 | } | 2445 | } |
2421 | 2446 | ||
2422 | 2447 | ||
2423 | static int | 2448 | static int |
2424 | select_del(void *cls, | 2449 | select_del (void *cls, |
2425 | struct GNUNET_SCHEDULER_Task *task) | 2450 | struct GNUNET_SCHEDULER_Task *task) |
2426 | { | 2451 | { |
2427 | struct DriverContext *context; | 2452 | struct DriverContext *context; |
2428 | struct Scheduled *pos; | 2453 | struct Scheduled *pos; |
2429 | int ret; | 2454 | int ret; |
2430 | 2455 | ||
2431 | GNUNET_assert(NULL != cls); | 2456 | GNUNET_assert (NULL != cls); |
2432 | 2457 | ||
2433 | context = cls; | 2458 | context = cls; |
2434 | ret = GNUNET_SYSERR; | 2459 | ret = GNUNET_SYSERR; |
2435 | pos = context->scheduled_head; | 2460 | pos = context->scheduled_head; |
2436 | while (NULL != pos) | 2461 | while (NULL != pos) |
2462 | { | ||
2463 | struct Scheduled *next = pos->next; | ||
2464 | if (pos->task == task) | ||
2437 | { | 2465 | { |
2438 | struct Scheduled *next = pos->next; | 2466 | GNUNET_CONTAINER_DLL_remove (context->scheduled_head, |
2439 | if (pos->task == task) | 2467 | context->scheduled_tail, |
2440 | { | 2468 | pos); |
2441 | GNUNET_CONTAINER_DLL_remove(context->scheduled_head, | 2469 | GNUNET_free (pos); |
2442 | context->scheduled_tail, | 2470 | ret = GNUNET_OK; |
2443 | pos); | ||
2444 | GNUNET_free(pos); | ||
2445 | ret = GNUNET_OK; | ||
2446 | } | ||
2447 | pos = next; | ||
2448 | } | 2471 | } |
2472 | pos = next; | ||
2473 | } | ||
2449 | return ret; | 2474 | return ret; |
2450 | } | 2475 | } |
2451 | 2476 | ||
2452 | 2477 | ||
2453 | static void | 2478 | static void |
2454 | select_set_wakeup(void *cls, | 2479 | select_set_wakeup (void *cls, |
2455 | struct GNUNET_TIME_Absolute dt) | 2480 | struct GNUNET_TIME_Absolute dt) |
2456 | { | 2481 | { |
2457 | struct DriverContext *context = cls; | 2482 | struct DriverContext *context = cls; |
2458 | 2483 | ||
2459 | GNUNET_assert(NULL != context); | 2484 | GNUNET_assert (NULL != context); |
2460 | context->timeout = dt; | 2485 | context->timeout = dt; |
2461 | } | 2486 | } |
2462 | 2487 | ||
@@ -2467,11 +2492,11 @@ select_set_wakeup(void *cls, | |||
2467 | * @return NULL on error | 2492 | * @return NULL on error |
2468 | */ | 2493 | */ |
2469 | struct GNUNET_SCHEDULER_Driver * | 2494 | struct GNUNET_SCHEDULER_Driver * |
2470 | GNUNET_SCHEDULER_driver_select() | 2495 | GNUNET_SCHEDULER_driver_select () |
2471 | { | 2496 | { |
2472 | struct GNUNET_SCHEDULER_Driver *select_driver; | 2497 | struct GNUNET_SCHEDULER_Driver *select_driver; |
2473 | 2498 | ||
2474 | select_driver = GNUNET_new(struct GNUNET_SCHEDULER_Driver); | 2499 | select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver); |
2475 | 2500 | ||
2476 | select_driver->add = &select_add; | 2501 | select_driver->add = &select_add; |
2477 | select_driver->del = &select_del; | 2502 | select_driver->del = &select_del; |
@@ -2494,14 +2519,14 @@ GNUNET_SCHEDULER_driver_select() | |||
2494 | * @param aid the asynchronous scope id to enter | 2519 | * @param aid the asynchronous scope id to enter |
2495 | */ | 2520 | */ |
2496 | void | 2521 | void |
2497 | GNUNET_SCHEDULER_begin_async_scope(struct GNUNET_AsyncScopeId *aid) | 2522 | GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid) |
2498 | { | 2523 | { |
2499 | struct GNUNET_AsyncScopeSave dummy_old_scope; | 2524 | struct GNUNET_AsyncScopeSave dummy_old_scope; |
2500 | 2525 | ||
2501 | GNUNET_assert(NULL != active_task); | 2526 | GNUNET_assert (NULL != active_task); |
2502 | /* Since we're in a task, the context will be automatically | 2527 | /* Since we're in a task, the context will be automatically |
2503 | restored by the scheduler. */ | 2528 | restored by the scheduler. */ |
2504 | GNUNET_async_scope_enter(aid, &dummy_old_scope); | 2529 | GNUNET_async_scope_enter (aid, &dummy_old_scope); |
2505 | } | 2530 | } |
2506 | 2531 | ||
2507 | 2532 | ||