1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
#include "common.h"
typedef enum signal_action {
NETDATA_SIGNAL_END_OF_LIST,
NETDATA_SIGNAL_IGNORE,
NETDATA_SIGNAL_EXIT_CLEANLY,
NETDATA_SIGNAL_SAVE_DATABASE,
NETDATA_SIGNAL_LOG_ROTATE,
NETDATA_SIGNAL_RELOAD_HEALTH,
NETDATA_SIGNAL_FATAL,
} SIGNAL_ACTION;
static struct {
int signo; // the signal
const char *name; // the name of the signal
size_t count; // the number of signals received
SIGNAL_ACTION action; // the action to take
} signals_waiting[] = {
{ SIGPIPE, "SIGPIPE", 0, NETDATA_SIGNAL_IGNORE },
{ SIGINT , "SIGINT", 0, NETDATA_SIGNAL_EXIT_CLEANLY },
{ SIGQUIT, "SIGQUIT", 0, NETDATA_SIGNAL_EXIT_CLEANLY },
{ SIGTERM, "SIGTERM", 0, NETDATA_SIGNAL_EXIT_CLEANLY },
{ SIGHUP, "SIGHUP", 0, NETDATA_SIGNAL_LOG_ROTATE },
{ SIGUSR1, "SIGUSR1", 0, NETDATA_SIGNAL_SAVE_DATABASE },
{ SIGUSR2, "SIGUSR2", 0, NETDATA_SIGNAL_RELOAD_HEALTH },
{ SIGBUS, "SIGBUS", 0, NETDATA_SIGNAL_FATAL },
// terminator
{ 0, "NONE", 0, NETDATA_SIGNAL_END_OF_LIST }
};
static void signal_handler(int signo) {
// find the entry in the list
int i;
for(i = 0; signals_waiting[i].action != NETDATA_SIGNAL_END_OF_LIST ; i++) {
if(unlikely(signals_waiting[i].signo == signo)) {
signals_waiting[i].count++;
if(signals_waiting[i].action == NETDATA_SIGNAL_FATAL) {
char buffer[200 + 1];
snprintfz(buffer, 200, "\nSIGNAL HANLDER: received: %s. Oops! This is bad!\n", signals_waiting[i].name);
if(write(STDERR_FILENO, buffer, strlen(buffer)) == -1) {
// nothing to do - we cannot write but there is no way to complaint about it
;
}
}
return;
}
}
}
void signals_block(void) {
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_BLOCK, &sigset, NULL) == -1)
error("SIGNAL: Could not block signals for threads");
}
void signals_unblock(void) {
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_UNBLOCK, &sigset, NULL) == -1) {
error("SIGNAL: Could not unblock signals for threads");
}
}
void signals_init(void) {
// Catch signals which we want to use
struct sigaction sa;
sa.sa_flags = 0;
// ignore all signals while we run in a signal handler
sigfillset(&sa.sa_mask);
int i;
for (i = 0; signals_waiting[i].action != NETDATA_SIGNAL_END_OF_LIST; i++) {
if(signals_waiting[i].action == NETDATA_SIGNAL_IGNORE)
sa.sa_handler = SIG_IGN;
else
sa.sa_handler = signal_handler;
if(sigaction(signals_waiting[i].signo, &sa, NULL) == -1)
error("SIGNAL: Failed to change signal handler for: %s", signals_waiting[i].name);
}
}
void signals_reset(void) {
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_DFL;
sa.sa_flags = 0;
int i;
for (i = 0; signals_waiting[i].action != NETDATA_SIGNAL_END_OF_LIST; i++) {
if(sigaction(signals_waiting[i].signo, &sa, NULL) == -1)
error("SIGNAL: Failed to reset signal handler for: %s", signals_waiting[i].name);
}
}
void signals_handle(void) {
while(1) {
// pause() causes the calling process (or thread) to sleep until a signal
// is delivered that either terminates the process or causes the invocation
// of a signal-catching function.
if(pause() == -1 && errno == EINTR) {
// loop once, but keep looping while signals are coming in
// this is needed because a few operations may take some time
// so we need to check for new signals before pausing again
int found = 1;
while(found) {
found = 0;
// execute the actions of the signals
int i;
for (i = 0; signals_waiting[i].action != NETDATA_SIGNAL_END_OF_LIST; i++) {
if (signals_waiting[i].count) {
found = 1;
signals_waiting[i].count = 0;
const char *name = signals_waiting[i].name;
switch (signals_waiting[i].action) {
case NETDATA_SIGNAL_RELOAD_HEALTH:
error_log_limit_unlimited();
info("SIGNAL: Received %s. Reloading HEALTH configuration...", name);
health_reload();
error_log_limit_reset();
break;
case NETDATA_SIGNAL_SAVE_DATABASE:
error_log_limit_unlimited();
info("SIGNAL: Received %s. Saving databases...", name);
rrdhost_save_all();
info("Databases saved.");
error_log_limit_reset();
break;
case NETDATA_SIGNAL_LOG_ROTATE:
error_log_limit_unlimited();
info("SIGNAL: Received %s. Reopening all log files...", name);
reopen_all_log_files();
error_log_limit_reset();
break;
case NETDATA_SIGNAL_EXIT_CLEANLY:
info("SIGNAL: Received %s. Cleaning up to exit...", name);
netdata_cleanup_and_exit(0);
exit(0);
case NETDATA_SIGNAL_FATAL:
fatal("SIGNAL: Received %s. netdata now exits.", name);
default:
info("SIGNAL: Received %s. No signal handler configured. Ignoring it.", name);
break;
}
}
}
}
}
else
error("SIGNAL: pause() returned but it was not interrupted by a signal.");
}
}
|
