collectdctl: let automake compute dependencies
[collectd.git] / src / ipc.c
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  **/
24
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  */
28
29 #include "collectd.h"
30 #include "common.h"
31 #include "plugin.h"
32 #include "configfile.h"
33
34 #if KERNEL_LINUX
35   /* _GNU_SOURCE is needed for struct shm_info.used_ids on musl libc */
36 # define _GNU_SOURCE
37
38   /* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
39   /* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
40   /* X/OPEN tells us to use <sys/{types,ipc,shm}.h> for shmctl() */
41 # include <sys/types.h>
42 # include <sys/ipc.h>
43 # include <sys/sem.h>
44 # include <sys/msg.h>
45 # include <sys/shm.h>
46
47   /* For older kernels the same holds for the defines below */
48 # ifndef MSG_STAT
49 #  define MSG_STAT    11
50 #  define MSG_INFO    12
51 # endif
52
53 # ifndef SHM_STAT
54 #   define SHM_STAT        13
55 #   define SHM_INFO        14
56     struct shm_info {
57         int used_ids;
58         ulong shm_tot;      /* total allocated shm */
59         ulong shm_rss;      /* total resident shm */
60         ulong shm_swp;      /* total swapped shm */
61         ulong swap_attempts;
62         ulong swap_successes;
63     };
64 # endif
65
66 # ifndef SEM_STAT
67 #  define SEM_STAT    18
68 #  define SEM_INFO    19
69 # endif
70
71   /* The last arg of semctl is a union semun, but where is it defined?
72      X/OPEN tells us to define it ourselves, but until recently
73      Linux include files would also define it. */
74 # if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
75     /* union semun is defined by including <sys/sem.h> */
76 # else
77     /* according to X/OPEN we have to define it ourselves */
78     union semun {
79       int val;
80       struct semid_ds *buf;
81       unsigned short *array;
82       struct seminfo *__buf;
83     };
84 # endif
85 static long pagesize_g;
86 /* #endif  KERNEL_LINUX */
87 #elif KERNEL_AIX
88 # include <sys/ipc_info.h>
89 /* #endif KERNEL_AIX */
90 #else
91 # error "No applicable input method."
92 #endif
93
94 __attribute__ ((nonnull(1)))
95 static void ipc_submit_g (const char *plugin_instance,
96                           const char *type,
97                           const char *type_instance,
98                           gauge_t value) /* {{{ */
99 {
100   value_t values[1];
101   value_list_t vl = VALUE_LIST_INIT;
102
103   values[0].gauge = value;
104
105   vl.values = values;
106   vl.values_len = 1;
107   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
108   sstrncpy (vl.plugin, "ipc", sizeof (vl.plugin));
109   sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
110   sstrncpy (vl.type, type, sizeof (vl.type));
111   if (type_instance != NULL)
112     sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
113
114   plugin_dispatch_values (&vl);
115 } /* }}} */
116
117 #if KERNEL_LINUX
118 static int ipc_read_sem (void) /* {{{ */
119 {
120   struct seminfo seminfo;
121   union semun arg;
122   int status;
123
124   arg.array = (void *) &seminfo;
125
126   status = semctl (/* id = */ 0, /* num = */ 0, SEM_INFO, arg);
127   if (status == -1)
128   {
129     char errbuf[1024];
130     ERROR("ipc plugin: semctl(2) failed: %s. "
131         "Maybe the kernel is not configured for semaphores?",
132         sstrerror (errno, errbuf, sizeof (errbuf)));
133     return (-1);
134   }
135
136   ipc_submit_g("sem", "count", "arrays", seminfo.semusz);
137   ipc_submit_g("sem", "count", "total", seminfo.semaem);
138
139   return (0);
140 } /* }}} int ipc_read_sem */
141
142 static int ipc_read_shm (void) /* {{{ */
143 {
144   struct shm_info shm_info;
145   int status;
146
147   status = shmctl (/* id = */ 0, SHM_INFO, (void *) &shm_info);
148   if (status == -1)
149   {
150     char errbuf[1024];
151     ERROR("ipc plugin: shmctl(2) failed: %s. "
152         "Maybe the kernel is not configured for shared memory?",
153         sstrerror (errno, errbuf, sizeof (errbuf)));
154     return (-1);
155   }
156
157   ipc_submit_g("shm", "segments", NULL, shm_info.used_ids);
158   ipc_submit_g("shm", "bytes", "total", shm_info.shm_tot * pagesize_g);
159   ipc_submit_g("shm", "bytes", "rss", shm_info.shm_rss * pagesize_g);
160   ipc_submit_g("shm", "bytes", "swapped", shm_info.shm_swp * pagesize_g);
161   return (0);
162 }
163 /* }}} int ipc_read_shm */
164
165 static int ipc_read_msg (void) /* {{{ */
166 {
167   struct msginfo msginfo;
168
169   if ( msgctl(0, MSG_INFO, (struct msqid_ds *) (void *) &msginfo) < 0 )
170   {
171     ERROR("Kernel is not configured for message queues");
172     return (-1);
173   }
174   ipc_submit_g("msg", "count", "queues", msginfo.msgmni);
175   ipc_submit_g("msg", "count", "headers", msginfo.msgmap);
176   ipc_submit_g("msg", "count", "space", msginfo.msgtql);
177
178   return (0);
179 }
180 /* }}} int ipc_read_msg */
181
182 static int ipc_init (void) /* {{{ */
183 {
184   pagesize_g = sysconf(_SC_PAGESIZE);
185   return (0);
186 }
187 /* }}} */
188 /* #endif KERNEL_LINUX */
189
190 #elif KERNEL_AIX
191 static caddr_t ipc_get_info (cid_t cid, int cmd, int version, int stsize, int *nmemb) /* {{{ */
192 {
193   int size = 0;
194   caddr_t buff = NULL;
195
196   if (get_ipc_info(cid, cmd, version, buff, &size) < 0)
197   {
198     if (errno != ENOSPC) {
199       char errbuf[1024];
200       WARNING ("ipc plugin: get_ipc_info: %s",
201         sstrerror (errno, errbuf, sizeof (errbuf)));
202       return (NULL);
203     }
204   }
205
206   if (size == 0)
207     return NULL;
208
209   if (size % stsize) {
210     ERROR ("ipc plugin: ipc_get_info: missmatch struct size and buffer size");
211     return (NULL);
212   }
213
214   *nmemb = size / stsize;
215
216   buff = malloc (size);
217   if (buff == NULL)  {
218     ERROR ("ipc plugin: ipc_get_info malloc failed.");
219     return (NULL);
220   }
221
222   if (get_ipc_info(cid, cmd, version, buff, &size) < 0)
223   {
224     char errbuf[1024];
225     WARNING ("ipc plugin: get_ipc_info: %s",
226       sstrerror (errno, errbuf, sizeof (errbuf)));
227     free(buff);
228     return (NULL);
229   }
230
231   return buff;
232 } /* }}} */
233
234 static int ipc_read_sem (void) /* {{{ */
235 {
236   ipcinfo_sem_t *ipcinfo_sem;
237   unsigned short sem_nsems=0;
238   unsigned short sems=0;
239   int i,n;
240
241   ipcinfo_sem = (ipcinfo_sem_t *)ipc_get_info(0,
242     GET_IPCINFO_SEM_ALL, IPCINFO_SEM_VERSION, sizeof(ipcinfo_sem_t), &n);
243   if (ipcinfo_sem == NULL)
244     return -1;
245
246   for (i=0; i<n; i++) {
247     sem_nsems += ipcinfo_sem[i].sem_nsems;
248     sems++;
249   }
250   free(ipcinfo_sem);
251
252   ipc_submit_g("sem", "count", "arrays", sem_nsems);
253   ipc_submit_g("sem", "count", "total", sems);
254
255   return (0);
256 } /* }}} int ipc_read_sem */
257
258 static int ipc_read_shm (void) /* {{{ */
259 {
260   ipcinfo_shm_t *ipcinfo_shm;
261   ipcinfo_shm_t *pshm;
262   unsigned int shm_segments=0;
263   size64_t shm_bytes=0;
264   int i,n;
265
266   ipcinfo_shm = (ipcinfo_shm_t *)ipc_get_info(0,
267     GET_IPCINFO_SHM_ALL, IPCINFO_SHM_VERSION, sizeof(ipcinfo_shm_t), &n);
268   if (ipcinfo_shm == NULL)
269     return -1;
270
271   for (i=0, pshm=ipcinfo_shm; i<n; i++, pshm++) {
272     shm_segments++;
273     shm_bytes += pshm->shm_segsz;
274   }
275   free(ipcinfo_shm);
276
277   ipc_submit_g("shm", "segments", NULL, shm_segments);
278   ipc_submit_g("shm", "bytes", "total", shm_bytes);
279
280   return (0);
281 }
282 /* }}} int ipc_read_shm */
283
284 static int ipc_read_msg (void) /* {{{ */
285 {
286   ipcinfo_msg_t *ipcinfo_msg;
287   uint32_t msg_used_space=0;
288   uint32_t msg_alloc_queues=0;
289   msgqnum32_t msg_qnum=0;
290   int i,n;
291
292   ipcinfo_msg = (ipcinfo_msg_t *)ipc_get_info(0,
293     GET_IPCINFO_MSG_ALL, IPCINFO_MSG_VERSION, sizeof(ipcinfo_msg_t), &n);
294   if (ipcinfo_msg == NULL)
295     return -1;
296
297   for (i=0; i<n; i++) {
298     msg_alloc_queues++;
299     msg_used_space += ipcinfo_msg[i].msg_cbytes;
300     msg_qnum += ipcinfo_msg[i].msg_qnum;
301   }
302   free(ipcinfo_msg);
303
304   ipc_submit_g("msg", "count", "queues", msg_alloc_queues);
305   ipc_submit_g("msg", "count", "headers", msg_qnum);
306   ipc_submit_g("msg", "count", "space", msg_used_space);
307
308   return (0);
309 }
310 /* }}} */
311 #endif /* KERNEL_AIX */
312
313 static int ipc_read (void) /* {{{ */
314 {
315   int x = 0;
316   x |= ipc_read_shm();
317   x |= ipc_read_sem();
318   x |= ipc_read_msg();
319
320   return (x);
321 }
322 /* }}} */
323
324 void module_register (void) /* {{{ */
325 {
326 #ifdef KERNEL_LINUX
327   plugin_register_init ("ipc", ipc_init);
328 #endif
329   plugin_register_read ("ipc", ipc_read);
330 }
331 /* }}} */
332
333 /* vim: set sw=2 sts=2 et fdm=marker : */