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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "plugin_proc.h"
#include <sys/sem.h>
#include <sys/msg.h>
#include <sys/shm.h>
#ifndef SEMVMX
#define SEMVMX 32767 /* <= 32767 semaphore maximum value */
#endif
/* Some versions of libc only define IPC_INFO when __USE_GNU is defined. */
#ifndef IPC_INFO
#define IPC_INFO 3
#endif
struct ipc_limits {
uint64_t shmmni; /* max number of segments */
uint64_t shmmax; /* max segment size */
uint64_t shmall; /* max total shared memory */
uint64_t shmmin; /* min segment size */
int semmni; /* max number of arrays */
int semmsl; /* max semaphores per array */
int semmns; /* max semaphores system wide */
int semopm; /* max ops per semop call */
unsigned int semvmx; /* semaphore max value (constant) */
int msgmni; /* max queues system wide */
size_t msgmax; /* max size of message */
int msgmnb; /* default max size of queue */
};
struct ipc_status {
int semusz; /* current number of arrays */
int semaem; /* current semaphores system wide */
};
/*
* The last arg of semctl is a union semun, but where is it defined? X/OPEN
* tells us to define it ourselves, but until recently Linux include files
* would also define it.
*/
#ifndef HAVE_UNION_SEMUN
/* according to X/OPEN we have to define it ourselves */
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
#endif
static inline int ipc_sem_get_limits(struct ipc_limits *lim) {
static procfile *ff = NULL;
static int error_shown = 0;
static char filename[FILENAME_MAX + 1] = "";
if(unlikely(!filename[0]))
snprintfz(filename, FILENAME_MAX, "%s/proc/sys/kernel/sem", netdata_configured_host_prefix);
if(unlikely(!ff)) {
ff = procfile_open(filename, NULL, PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) {
if(unlikely(!error_shown)) {
error("IPC: Cannot open file '%s'.", filename);
error_shown = 1;
}
goto ipc;
}
}
ff = procfile_readall(ff);
if(unlikely(!ff)) {
if(unlikely(!error_shown)) {
error("IPC: Cannot read file '%s'.", filename);
error_shown = 1;
}
goto ipc;
}
if(procfile_lines(ff) >= 1 && procfile_linewords(ff, 0) >= 4) {
lim->semvmx = SEMVMX;
lim->semmsl = str2i(procfile_lineword(ff, 0, 0));
lim->semmns = str2i(procfile_lineword(ff, 0, 1));
lim->semopm = str2i(procfile_lineword(ff, 0, 2));
lim->semmni = str2i(procfile_lineword(ff, 0, 3));
return 0;
}
else {
if(unlikely(!error_shown)) {
error("IPC: Invalid content in file '%s'.", filename);
error_shown = 1;
}
goto ipc;
}
ipc:
// cannot do it from the file
// query IPC
{
struct seminfo seminfo = {.semmni = 0};
union semun arg = {.array = (ushort *) &seminfo};
if(unlikely(semctl(0, 0, IPC_INFO, arg) < 0)) {
error("IPC: Failed to read '%s' and request IPC_INFO with semctl().", filename);
goto error;
}
lim->semvmx = SEMVMX;
lim->semmni = seminfo.semmni;
lim->semmsl = seminfo.semmsl;
lim->semmns = seminfo.semmns;
lim->semopm = seminfo.semopm;
return 0;
}
error:
lim->semvmx = 0;
lim->semmni = 0;
lim->semmsl = 0;
lim->semmns = 0;
lim->semopm = 0;
return -1;
}
/*
printf ("------ Semaphore Limits --------\n");
printf ("max number of arrays = %d\n", limits.semmni);
printf ("max semaphores per array = %d\n", limits.semmsl);
printf ("max semaphores system wide = %d\n", limits.semmns);
printf ("max ops per semop call = %d\n", limits.semopm);
printf ("semaphore max value = %u\n", limits.semvmx);
printf ("------ Semaphore Status --------\n");
printf ("used arrays = %d\n", status.semusz);
printf ("allocated semaphores = %d\n", status.semaem);
*/
static inline int ipc_sem_get_status(struct ipc_status *st) {
struct seminfo seminfo;
union semun arg;
arg.array = (ushort *) (void *) &seminfo;
if(unlikely(semctl (0, 0, SEM_INFO, arg) < 0)) {
/* kernel not configured for semaphores */
static int error_shown = 0;
if(unlikely(!error_shown)) {
error("IPC: kernel is not configured for semaphores");
error_shown = 1;
}
st->semusz = 0;
st->semaem = 0;
return -1;
}
st->semusz = seminfo.semusz;
st->semaem = seminfo.semaem;
return 0;
}
int do_ipc(int update_every, usec_t dt) {
(void)dt;
static int initialized = 0, read_limits_next = -1;
static struct ipc_limits limits;
static struct ipc_status status;
static RRDVAR *arrays_max = NULL, *semaphores_max = NULL;
static RRDSET *st_semaphores = NULL, *st_arrays = NULL;
static RRDDIM *rd_semaphores = NULL, *rd_arrays = NULL;
if(unlikely(!initialized)) {
initialized = 1;
// make sure it works
if(ipc_sem_get_limits(&limits) == -1) {
error("unable to fetch semaphore limits");
return 1;
}
// make sure it works
if(ipc_sem_get_status(&status) == -1) {
error("unable to fetch semaphore statistics");
return 1;
}
// create the charts
if(unlikely(!st_semaphores)) {
st_semaphores = rrdset_create_localhost(
"system"
, "ipc_semaphores"
, NULL
, "ipc semaphores"
, NULL
, "IPC Semaphores"
, "semaphores"
, PLUGIN_PROC_NAME
, "ipc"
, NETDATA_CHART_PRIO_SYSTEM_IPC_SEMAPHORES
, localhost->rrd_update_every
, RRDSET_TYPE_AREA
);
rd_semaphores = rrddim_add(st_semaphores, "semaphores", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
if(unlikely(!st_arrays)) {
st_arrays = rrdset_create_localhost(
"system"
, "ipc_semaphore_arrays"
, NULL
, "ipc semaphores"
, NULL
, "IPC Semaphore Arrays"
, "arrays"
, PLUGIN_PROC_NAME
, "ipc"
, NETDATA_CHART_PRIO_SYSTEM_IPC_SEM_ARRAYS
, localhost->rrd_update_every
, RRDSET_TYPE_AREA
);
rd_arrays = rrddim_add(st_arrays, "arrays", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
// variables
semaphores_max = rrdvar_custom_host_variable_create(localhost, "ipc_semaphores_max");
arrays_max = rrdvar_custom_host_variable_create(localhost, "ipc_semaphores_arrays_max");
}
if(unlikely(read_limits_next < 0)) {
if(unlikely(ipc_sem_get_limits(&limits) == -1)) {
error("Unable to fetch semaphore limits.");
}
else {
if(semaphores_max) rrdvar_custom_host_variable_set(localhost, semaphores_max, limits.semmns);
if(arrays_max) rrdvar_custom_host_variable_set(localhost, arrays_max, limits.semmni);
st_arrays->red = limits.semmni;
st_semaphores->red = limits.semmns;
read_limits_next = 60 / update_every;
}
}
else
read_limits_next--;
if(unlikely(ipc_sem_get_status(&status) == -1)) {
error("Unable to get semaphore statistics");
return 0;
}
if(st_semaphores->counter_done) rrdset_next(st_semaphores);
rrddim_set_by_pointer(st_semaphores, rd_semaphores, status.semaem);
rrdset_done(st_semaphores);
if(st_arrays->counter_done) rrdset_next(st_arrays);
rrddim_set_by_pointer(st_arrays, rd_arrays, status.semusz);
rrdset_done(st_arrays);
return 0;
}
|
