Oops, missed an include
[asterisk/asterisk.git] / utils / astcanary.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007, Digium, Inc.
5  *
6  * Tilghman Lesher <tlesher AT digium DOT com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <sys/time.h>
22 #include <sys/resource.h>
23 #include <utime.h>
24 #include <fcntl.h>
25 #include <unistd.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdio.h>
29
30 /*!\brief
31  * At one time, canaries were carried along with coal miners down
32  * into a mine.  Their purpose was to alert the miners when they
33  * had drilled into a pocket of methane gas or another noxious
34  * substance.  The canary, being the most sensitive animal, would
35  * immediately fall over.  Seeing this, the miners could take
36  * action to escape the mine, seeing an imminent danger.
37  *
38  * This process serves a similar purpose, though with the realtime
39  * priority being the reason.  When a thread starts running away
40  * with the processor, it is typically difficult to tell what
41  * thread caused the problem, as the machine acts as if it is
42  * locked up (in fact, what has happened is that Asterisk runs at
43  * a higher priority than even the login shell, so the runaway
44  * thread hogs all available CPU time.
45  *
46  * If that happens, this canary process will cease to get any
47  * process time, which we can monitor with a realtime thread in
48  * Asterisk.  Should that happen, that monitoring thread may take
49  * immediate action to slow down Asterisk to regular priority,
50  * thus allowing an administrator to login to the system and
51  * restart Asterisk or perhaps take another course of action
52  * (such as retrieving a backtrace to let the developers know
53  * what precisely went wrong).
54  *
55  * Note that according to POSIX.1, all threads inside a single
56  * process must share the same priority, so when the monitoring
57  * thread deprioritizes itself, it deprioritizes all threads at
58  * the same time.  This is also why this canary must exist as a
59  * completely separate process and not simply as a thread within
60  * Asterisk itself.
61  *
62  * Quote:
63  * "The nice value set with setpriority() shall be applied to the
64  * process. If the process is multi-threaded, the nice value shall
65  * affect all system scope threads in the process."
66  *
67  * Source:
68  * http://www.opengroup.org/onlinepubs/000095399/functions/setpriority.html
69  *
70  * In answer to the question, what aren't system scope threads, the
71  * answer is, in Asterisk, nothing.  Process scope threads are the
72  * alternative, but they aren't supported in Linux.
73  */
74
75 static const char explanation[] =
76 "This file is created when Asterisk is run with a realtime priority (-p).  It\n"
77 "must continue to exist, and the astcanary process must be allowed to continue\n"
78 "running, or else the Asterisk process will, within a short period of time,\n"
79 "slow itself down to regular priority.\n\n"
80 "The technical explanation for this file is to provide an assurance to Asterisk\n"
81 "that there are no threads that have gone into runaway mode, thus hogging the\n"
82 "CPU, and making the Asterisk machine seem to be unresponsive.  When that\n"
83 "happens, the astcanary process will be unable to update the timestamp on this\n"
84 "file, and Asterisk will notice within 120 seconds and react.  Slowing the\n"
85 "Asterisk process down to regular priority will permit an administrator to\n"
86 "intervene, thus avoiding a need to reboot the entire machine.\n";
87
88 int main(int argc, char *argv[])
89 {
90         int fd;
91         pid_t parent;
92
93         if (argc < 3) {
94                 fprintf(stderr, "Usage: %s <monitor-filename> <ppid>\n", argv[0]);
95                 exit(1);
96         }
97
98         /* Run at normal priority */
99         setpriority(PRIO_PROCESS, 0, 0);
100
101         /*!\note
102          * See http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_265
103          * for a justification of this approach.  The PPID after the creator dies in Linux and
104          * most other Unix-like systems will be 1, but this is not strictly the case.  The POSIX
105          * specification allows it to be an implementation-defined system process.  However, it
106          * most certainly will not be the original parent PID, which makes the following code
107          * POSIX-compliant.
108          */
109         for (parent = atoi(argv[2]); parent == getppid() ;) {
110                 /* Update the modification times (checked from Asterisk) */
111                 if (utime(argv[1], NULL)) {
112                         /* Recreate the file if it doesn't exist */
113                         if ((fd = open(argv[1], O_RDWR | O_TRUNC | O_CREAT, 0777)) > -1) {
114                                 if (write(fd, explanation, strlen(explanation)) < 0) {
115                                         exit(1);
116                                 }
117                                 close(fd);
118                         } else {
119                                 exit(1);
120                         }
121                         continue;
122                 }
123
124                 /* Run occasionally */
125                 sleep(5);
126         }
127
128         /* Exit when the parent dies */
129         return 0;
130 }
131