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