1 /**
2 * collectd - src/ipc.c, based on src/memcached.c
3 * Copyright (C) 2010 Andres J. Diaz <ajdiaz@connectical.com>
4 * Copyright (C) 2010 Manuel L. Sanmartin <manuel.luis@gmail.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Authors:
21 * Andres J. Diaz <ajdiaz@connectical.com>
22 * Manuel L. Sanmartin <manuel.luis@gmail>
23 **/
25 /* Many of this code is based on busybox ipc implementation, which is:
26 * (C) Rodney Radford <rradford@mindspring.com> and distributed under GPLv2.
27 */
29 #include "collectd.h"
31 #include "common.h"
32 #include "plugin.h"
33 #include "configfile.h"
35 #if KERNEL_LINUX
36 /* _GNU_SOURCE is needed for struct shm_info.used_ids on musl libc */
37 # define _GNU_SOURCE
39 /* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
40 /* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
41 /* X/OPEN tells us to use <sys/{types,ipc,shm}.h> for shmctl() */
42 # include <sys/types.h>
43 # include <sys/ipc.h>
44 # include <sys/sem.h>
45 # include <sys/msg.h>
46 # include <sys/shm.h>
48 /* For older kernels the same holds for the defines below */
49 # ifndef MSG_STAT
50 # define MSG_STAT 11
51 # define MSG_INFO 12
52 # endif
54 # ifndef SHM_STAT
55 # define SHM_STAT 13
56 # define SHM_INFO 14
57 struct shm_info {
58 int used_ids;
59 ulong shm_tot; /* total allocated shm */
60 ulong shm_rss; /* total resident shm */
61 ulong shm_swp; /* total swapped shm */
62 ulong swap_attempts;
63 ulong swap_successes;
64 };
65 # endif
67 # ifndef SEM_STAT
68 # define SEM_STAT 18
69 # define SEM_INFO 19
70 # endif
72 /* The last arg of semctl is a union semun, but where is it defined?
73 X/OPEN tells us to define it ourselves, but until recently
74 Linux include files would also define it. */
75 # if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
76 /* union semun is defined by including <sys/sem.h> */
77 # else
78 /* according to X/OPEN we have to define it ourselves */
79 union semun {
80 int val;
81 struct semid_ds *buf;
82 unsigned short *array;
83 struct seminfo *__buf;
84 };
85 # endif
86 static long pagesize_g;
87 /* #endif KERNEL_LINUX */
88 #elif KERNEL_AIX
89 # include <sys/ipc_info.h>
90 /* #endif KERNEL_AIX */
91 #else
92 # error "No applicable input method."
93 #endif
95 __attribute__ ((nonnull(1)))
96 static void ipc_submit_g (const char *plugin_instance,
97 const char *type,
98 const char *type_instance,
99 gauge_t value) /* {{{ */
100 {
101 value_t values[1];
102 value_list_t vl = VALUE_LIST_INIT;
104 values[0].gauge = value;
106 vl.values = values;
107 vl.values_len = 1;
108 sstrncpy (vl.host, hostname_g, sizeof (vl.host));
109 sstrncpy (vl.plugin, "ipc", sizeof (vl.plugin));
110 sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
111 sstrncpy (vl.type, type, sizeof (vl.type));
112 if (type_instance != NULL)
113 sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
115 plugin_dispatch_values (&vl);
116 } /* }}} */
118 #if KERNEL_LINUX
119 static int ipc_read_sem (void) /* {{{ */
120 {
121 struct seminfo seminfo;
122 union semun arg;
123 int status;
125 arg.array = (void *) &seminfo;
127 status = semctl (/* id = */ 0, /* num = */ 0, SEM_INFO, arg);
128 if (status == -1)
129 {
130 char errbuf[1024];
131 ERROR("ipc plugin: semctl(2) failed: %s. "
132 "Maybe the kernel is not configured for semaphores?",
133 sstrerror (errno, errbuf, sizeof (errbuf)));
134 return (-1);
135 }
137 ipc_submit_g("sem", "count", "arrays", seminfo.semusz);
138 ipc_submit_g("sem", "count", "total", seminfo.semaem);
140 return (0);
141 } /* }}} int ipc_read_sem */
143 static int ipc_read_shm (void) /* {{{ */
144 {
145 struct shm_info shm_info;
146 int status;
148 status = shmctl (/* id = */ 0, SHM_INFO, (void *) &shm_info);
149 if (status == -1)
150 {
151 char errbuf[1024];
152 ERROR("ipc plugin: shmctl(2) failed: %s. "
153 "Maybe the kernel is not configured for shared memory?",
154 sstrerror (errno, errbuf, sizeof (errbuf)));
155 return (-1);
156 }
158 ipc_submit_g("shm", "segments", NULL, shm_info.used_ids);
159 ipc_submit_g("shm", "bytes", "total", shm_info.shm_tot * pagesize_g);
160 ipc_submit_g("shm", "bytes", "rss", shm_info.shm_rss * pagesize_g);
161 ipc_submit_g("shm", "bytes", "swapped", shm_info.shm_swp * pagesize_g);
162 return (0);
163 }
164 /* }}} int ipc_read_shm */
166 static int ipc_read_msg (void) /* {{{ */
167 {
168 struct msginfo msginfo;
170 if ( msgctl(0, MSG_INFO, (struct msqid_ds *) (void *) &msginfo) < 0 )
171 {
172 ERROR("Kernel is not configured for message queues");
173 return (-1);
174 }
175 ipc_submit_g("msg", "count", "queues", msginfo.msgmni);
176 ipc_submit_g("msg", "count", "headers", msginfo.msgmap);
177 ipc_submit_g("msg", "count", "space", msginfo.msgtql);
179 return (0);
180 }
181 /* }}} int ipc_read_msg */
183 static int ipc_init (void) /* {{{ */
184 {
185 pagesize_g = sysconf(_SC_PAGESIZE);
186 return (0);
187 }
188 /* }}} */
189 /* #endif KERNEL_LINUX */
191 #elif KERNEL_AIX
192 static caddr_t ipc_get_info (cid_t cid, int cmd, int version, int stsize, int *nmemb) /* {{{ */
193 {
194 int size = 0;
195 caddr_t buff = NULL;
197 if (get_ipc_info(cid, cmd, version, buff, &size) < 0)
198 {
199 if (errno != ENOSPC) {
200 char errbuf[1024];
201 WARNING ("ipc plugin: get_ipc_info: %s",
202 sstrerror (errno, errbuf, sizeof (errbuf)));
203 return (NULL);
204 }
205 }
207 if (size == 0)
208 return NULL;
210 if (size % stsize) {
211 ERROR ("ipc plugin: ipc_get_info: missmatch struct size and buffer size");
212 return (NULL);
213 }
215 *nmemb = size / stsize;
217 buff = malloc (size);
218 if (buff == NULL) {
219 ERROR ("ipc plugin: ipc_get_info malloc failed.");
220 return (NULL);
221 }
223 if (get_ipc_info(cid, cmd, version, buff, &size) < 0)
224 {
225 char errbuf[1024];
226 WARNING ("ipc plugin: get_ipc_info: %s",
227 sstrerror (errno, errbuf, sizeof (errbuf)));
228 free(buff);
229 return (NULL);
230 }
232 return buff;
233 } /* }}} */
235 static int ipc_read_sem (void) /* {{{ */
236 {
237 ipcinfo_sem_t *ipcinfo_sem;
238 unsigned short sem_nsems=0;
239 unsigned short sems=0;
240 int i,n;
242 ipcinfo_sem = (ipcinfo_sem_t *)ipc_get_info(0,
243 GET_IPCINFO_SEM_ALL, IPCINFO_SEM_VERSION, sizeof(ipcinfo_sem_t), &n);
244 if (ipcinfo_sem == NULL)
245 return -1;
247 for (i=0; i<n; i++) {
248 sem_nsems += ipcinfo_sem[i].sem_nsems;
249 sems++;
250 }
251 free(ipcinfo_sem);
253 ipc_submit_g("sem", "count", "arrays", sem_nsems);
254 ipc_submit_g("sem", "count", "total", sems);
256 return (0);
257 } /* }}} int ipc_read_sem */
259 static int ipc_read_shm (void) /* {{{ */
260 {
261 ipcinfo_shm_t *ipcinfo_shm;
262 ipcinfo_shm_t *pshm;
263 unsigned int shm_segments=0;
264 size64_t shm_bytes=0;
265 int i,n;
267 ipcinfo_shm = (ipcinfo_shm_t *)ipc_get_info(0,
268 GET_IPCINFO_SHM_ALL, IPCINFO_SHM_VERSION, sizeof(ipcinfo_shm_t), &n);
269 if (ipcinfo_shm == NULL)
270 return -1;
272 for (i=0, pshm=ipcinfo_shm; i<n; i++, pshm++) {
273 shm_segments++;
274 shm_bytes += pshm->shm_segsz;
275 }
276 free(ipcinfo_shm);
278 ipc_submit_g("shm", "segments", NULL, shm_segments);
279 ipc_submit_g("shm", "bytes", "total", shm_bytes);
281 return (0);
282 }
283 /* }}} int ipc_read_shm */
285 static int ipc_read_msg (void) /* {{{ */
286 {
287 ipcinfo_msg_t *ipcinfo_msg;
288 uint32_t msg_used_space=0;
289 uint32_t msg_alloc_queues=0;
290 msgqnum32_t msg_qnum=0;
291 int i,n;
293 ipcinfo_msg = (ipcinfo_msg_t *)ipc_get_info(0,
294 GET_IPCINFO_MSG_ALL, IPCINFO_MSG_VERSION, sizeof(ipcinfo_msg_t), &n);
295 if (ipcinfo_msg == NULL)
296 return -1;
298 for (i=0; i<n; i++) {
299 msg_alloc_queues++;
300 msg_used_space += ipcinfo_msg[i].msg_cbytes;
301 msg_qnum += ipcinfo_msg[i].msg_qnum;
302 }
303 free(ipcinfo_msg);
305 ipc_submit_g("msg", "count", "queues", msg_alloc_queues);
306 ipc_submit_g("msg", "count", "headers", msg_qnum);
307 ipc_submit_g("msg", "count", "space", msg_used_space);
309 return (0);
310 }
311 /* }}} */
312 #endif /* KERNEL_AIX */
314 static int ipc_read (void) /* {{{ */
315 {
316 int x = 0;
317 x |= ipc_read_shm();
318 x |= ipc_read_sem();
319 x |= ipc_read_msg();
321 return (x);
322 }
323 /* }}} */
325 void module_register (void) /* {{{ */
326 {
327 #ifdef KERNEL_LINUX
328 plugin_register_init ("ipc", ipc_init);
329 #endif
330 plugin_register_read ("ipc", ipc_read);
331 }
332 /* }}} */
334 /* vim: set sw=2 sts=2 et fdm=marker : */