← Back to branch summary

~ubuntu-branches/ubuntu/vivid/keepalived/vivid

« back to all changes in this revision

Viewing changes to lib/scheduler.h

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2011-10-25 16:10:58 UTC
  • mfrom: (3.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20111025161058-bgqn5elt0xo1tq0a
Tags: 1:1.2.2-1ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - debian/rules: DEB_UPDATE_RCD_PARAMS := explicit init start/stop
    parameters (don't stop at 0 and 6)
  - debian/init.d: init script header adapted to stop rule
  - debian/keepalived.postinst: Remove shutdown and reboot links
* Build with libnl3, thanks to a patch from Marc - A. Dahlhaus.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/scheduler.h
17
17
 *              as published by the Free Software Foundation; either version
18
18
 *              2 of the License, or (at your option) any later version.
19
19
 *
20
 
 * Copyright (C) 2001-2010 Alexandre Cassen, <acassen@freebox.fr>
 
20
 * Copyright (C) 2001-2011 Alexandre Cassen, <acassen@linux-vs.org>
21
21
 */
22
22
 
23
23
#ifndef _SCHEDULER_H
51
51
                        int status;     /* return status of the process */
52
52
                } c;
53
53
        } u;
54
 
} thread;
 
54
} thread_t;
55
55
 
56
56
/* Linked list of thread. */
57
57
typedef struct _thread_list {
58
 
        thread *head;
59
 
        thread *tail;
 
58
        thread_t *head;
 
59
        thread_t *tail;
60
60
        int count;
61
 
} thread_list;
 
61
} thread_list_t;
62
62
 
63
63
/* Master of the theads. */
64
64
typedef struct _thread_master {
65
 
        thread_list read;
66
 
        thread_list write;
67
 
        thread_list timer;
68
 
        thread_list child;
69
 
        thread_list event;
70
 
        thread_list ready;
71
 
        thread_list unuse;
 
65
        thread_list_t read;
 
66
        thread_list_t write;
 
67
        thread_list_t timer;
 
68
        thread_list_t child;
 
69
        thread_list_t event;
 
70
        thread_list_t ready;
 
71
        thread_list_t unuse;
72
72
        fd_set readfd;
73
73
        fd_set writefd;
74
74
        fd_set exceptfd;
75
75
        unsigned long alloc;
76
 
} thread_master;
 
76
} thread_master_t;
77
77
 
78
78
/* Thread types. */
79
79
#define THREAD_READ             0
101
101
#define THREAD_CHILD_STATUS(X) ((X)->u.c.status)
102
102
 
103
103
/* global vars exported */
104
 
extern thread_master *master;
 
104
extern thread_master_t *master;
105
105
 
106
106
/* Prototypes. */
107
 
extern thread_master *thread_make_master(void);
108
 
extern thread *thread_add_terminate_event(thread_master * m);
109
 
extern void thread_destroy_master(thread_master * m);
110
 
extern thread *thread_add_read(thread_master * m, int (*func) (thread *)
111
 
                               , void *arg, int fd, long timeout);
112
 
extern thread *thread_add_write(thread_master * m, int (*func) (thread *)
113
 
                                , void *arg, int fd, long timeout);
114
 
extern thread *thread_add_timer(thread_master * m, int (*func) (thread *)
115
 
                                , void *arg, long timer);
116
 
extern thread *thread_add_child(thread_master * m, int (*func) (thread *)
117
 
                                , void *arg, pid_t pid, long timeout);
118
 
extern thread *thread_add_event(thread_master * m, int (*func) (thread *)
119
 
                                , void *arg, int val);
120
 
extern void thread_cancel(thread * thread_obj);
121
 
extern void thread_cancel_event(thread_master * m, void *arg);
122
 
extern thread *thread_fetch(thread_master * m, thread * fetch);
123
 
extern void thread_child_handler(void * v, int sig);
124
 
extern void thread_call(thread * thread_obj);
 
107
extern thread_master_t *thread_make_master(void);
 
108
extern thread_t *thread_add_terminate_event(thread_master_t *);
 
109
extern void thread_destroy_master(thread_master_t *);
 
110
extern thread_t *thread_add_read(thread_master_t *, int (*func) (thread_t *), void *, int, long);
 
111
extern thread_t *thread_add_write(thread_master_t *, int (*func) (thread_t *), void *, int, long);
 
112
extern thread_t *thread_add_timer(thread_master_t *, int (*func) (thread_t *), void *, long);
 
113
extern thread_t *thread_add_child(thread_master_t *, int (*func) (thread_t *), void *, pid_t, long);
 
114
extern thread_t *thread_add_event(thread_master_t *, int (*func) (thread_t *), void *, int);
 
115
extern void thread_cancel(thread_t *);
 
116
extern void thread_cancel_event(thread_master_t *, void *);
 
117
extern thread_t *thread_fetch(thread_master_t *, thread_t *);
 
118
extern void thread_child_handler(void *, int);
 
119
extern void thread_call(thread_t *);
125
120
extern void launch_scheduler(void);
126
121
 
127
122
#endif