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
  31 #include "common.h"
  32 #include "plugin.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/ipc.h>
  42 #include <sys/msg.h>
  43 #include <sys/sem.h>
  44 #include <sys/shm.h>
  45 #include <sys/types.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))) static void
  95 ipc_submit_g(const char *plugin_instance, const char *type,
  96              const char *type_instance, gauge_t value) /* {{{ */
  97 {
  98   value_list_t vl = VALUE_LIST_INIT;
  99
 100   vl.values = &(value_t){.gauge = value};
 101   vl.values_len = 1;
 102   sstrncpy(vl.plugin, "ipc", sizeof(vl.plugin));
 103   sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
 104   sstrncpy(vl.type, type, sizeof(vl.type));
 105   if (type_instance != NULL)
 106     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 107
 108   plugin_dispatch_values(&vl);
 109 } /* }}} */
 110
 111 #if KERNEL_LINUX
 112 static int ipc_read_sem(void) /* {{{ */
 113 {
 114   struct seminfo seminfo;
 115   union semun arg;
 116   int status;
 117
 118   arg.array = (void *)&seminfo;
 119
 120   status = semctl(/* id = */ 0, /* num = */ 0, SEM_INFO, arg);
 121   if (status == -1) {
 122     char errbuf[1024];
 123     ERROR("ipc plugin: semctl(2) failed: %s. "
 124           "Maybe the kernel is not configured for semaphores?",
 125           sstrerror(errno, errbuf, sizeof(errbuf)));
 126     return -1;
 127   }
 128
 129   ipc_submit_g("sem", "count", "arrays", seminfo.semusz);
 130   ipc_submit_g("sem", "count", "total", seminfo.semaem);
 131
 132   return 0;
 133 } /* }}} int ipc_read_sem */
 134
 135 static int ipc_read_shm(void) /* {{{ */
 136 {
 137   struct shm_info shm_info;
 138   int status;
 139
 140   status = shmctl(/* id = */ 0, SHM_INFO, (void *)&shm_info);
 141   if (status == -1) {
 142     char errbuf[1024];
 143     ERROR("ipc plugin: shmctl(2) failed: %s. "
 144           "Maybe the kernel is not configured for shared memory?",
 145           sstrerror(errno, errbuf, sizeof(errbuf)));
 146     return -1;
 147   }
 148
 149   ipc_submit_g("shm", "segments", NULL, shm_info.used_ids);
 150   ipc_submit_g("shm", "bytes", "total", shm_info.shm_tot * pagesize_g);
 151   ipc_submit_g("shm", "bytes", "rss", shm_info.shm_rss * pagesize_g);
 152   ipc_submit_g("shm", "bytes", "swapped", shm_info.shm_swp * pagesize_g);
 153   return 0;
 154 }
 155 /* }}} int ipc_read_shm */
 156
 157 static int ipc_read_msg(void) /* {{{ */
 158 {
 159   struct msginfo msginfo;
 160
 161   if (msgctl(0, MSG_INFO, (struct msqid_ds *)(void *)&msginfo) < 0) {
 162     ERROR("Kernel is not configured for message queues");
 163     return -1;
 164   }
 165   ipc_submit_g("msg", "count", "queues", msginfo.msgmni);
 166   ipc_submit_g("msg", "count", "headers", msginfo.msgmap);
 167   ipc_submit_g("msg", "count", "space", msginfo.msgtql);
 168
 169   return 0;
 170 }
 171 /* }}} int ipc_read_msg */
 172
 173 static int ipc_init(void) /* {{{ */
 174 {
 175   pagesize_g = sysconf(_SC_PAGESIZE);
 176   return 0;
 177 }
 178 /* }}} */
 179 /* #endif KERNEL_LINUX */
 180
 181 #elif KERNEL_AIX
 182 static caddr_t ipc_get_info(cid_t cid, int cmd, int version, int stsize,
 183                             int *nmemb) /* {{{ */
 184 {
 185   int size = 0;
 186   caddr_t buff = NULL;
 187
 188   if (get_ipc_info(cid, cmd, version, buff, &size) < 0) {
 189     if (errno != ENOSPC) {
 190       char errbuf[1024];
 191       WARNING("ipc plugin: get_ipc_info: %s",
 192               sstrerror(errno, errbuf, sizeof(errbuf)));
 193       return NULL;
 194     }
 195   }
 196
 197   if (size == 0)
 198     return NULL;
 199
 200   if (size % stsize) {
 201     ERROR("ipc plugin: ipc_get_info: missmatch struct size and buffer size");
 202     return NULL;
 203   }
 204
 205   *nmemb = size / stsize;
 206
 207   buff = malloc(size);
 208   if (buff == NULL) {
 209     ERROR("ipc plugin: ipc_get_info malloc failed.");
 210     return NULL;
 211   }
 212
 213   if (get_ipc_info(cid, cmd, version, buff, &size) < 0) {
 214     char errbuf[1024];
 215     WARNING("ipc plugin: get_ipc_info: %s",
 216             sstrerror(errno, errbuf, sizeof(errbuf)));
 217     free(buff);
 218     return NULL;
 219   }
 220
 221   return buff;
 222 } /* }}} */
 223
 224 static int ipc_read_sem(void) /* {{{ */
 225 {
 226   ipcinfo_sem_t *ipcinfo_sem;
 227   unsigned short sem_nsems = 0;
 228   unsigned short sems = 0;
 229   int n;
 230
 231   ipcinfo_sem = (ipcinfo_sem_t *)ipc_get_info(
 232       0, GET_IPCINFO_SEM_ALL, IPCINFO_SEM_VERSION, sizeof(ipcinfo_sem_t), &n);
 233   if (ipcinfo_sem == NULL)
 234     return -1;
 235
 236   for (int i = 0; i < n; i++) {
 237     sem_nsems += ipcinfo_sem[i].sem_nsems;
 238     sems++;
 239   }
 240   free(ipcinfo_sem);
 241
 242   ipc_submit_g("sem", "count", "arrays", sem_nsems);
 243   ipc_submit_g("sem", "count", "total", sems);
 244
 245   return 0;
 246 } /* }}} int ipc_read_sem */
 247
 248 static int ipc_read_shm(void) /* {{{ */
 249 {
 250   ipcinfo_shm_t *ipcinfo_shm;
 251   ipcinfo_shm_t *pshm;
 252   unsigned int shm_segments = 0;
 253   size64_t shm_bytes = 0;
 254   int i, n;
 255
 256   ipcinfo_shm = (ipcinfo_shm_t *)ipc_get_info(
 257       0, GET_IPCINFO_SHM_ALL, IPCINFO_SHM_VERSION, sizeof(ipcinfo_shm_t), &n);
 258   if (ipcinfo_shm == NULL)
 259     return -1;
 260
 261   for (i = 0, pshm = ipcinfo_shm; i < n; i++, pshm++) {
 262     shm_segments++;
 263     shm_bytes += pshm->shm_segsz;
 264   }
 265   free(ipcinfo_shm);
 266
 267   ipc_submit_g("shm", "segments", NULL, shm_segments);
 268   ipc_submit_g("shm", "bytes", "total", shm_bytes);
 269
 270   return 0;
 271 }
 272 /* }}} int ipc_read_shm */
 273
 274 static int ipc_read_msg(void) /* {{{ */
 275 {
 276   ipcinfo_msg_t *ipcinfo_msg;
 277   uint32_t msg_used_space = 0;
 278   uint32_t msg_alloc_queues = 0;
 279   msgqnum32_t msg_qnum = 0;
 280   int n;
 281
 282   ipcinfo_msg = (ipcinfo_msg_t *)ipc_get_info(
 283       0, GET_IPCINFO_MSG_ALL, IPCINFO_MSG_VERSION, sizeof(ipcinfo_msg_t), &n);
 284   if (ipcinfo_msg == NULL)
 285     return -1;
 286
 287   for (int i = 0; i < n; i++) {
 288     msg_alloc_queues++;
 289     msg_used_space += ipcinfo_msg[i].msg_cbytes;
 290     msg_qnum += ipcinfo_msg[i].msg_qnum;
 291   }
 292   free(ipcinfo_msg);
 293
 294   ipc_submit_g("msg", "count", "queues", msg_alloc_queues);
 295   ipc_submit_g("msg", "count", "headers", msg_qnum);
 296   ipc_submit_g("msg", "count", "space", msg_used_space);
 297
 298   return 0;
 299 }
 300 /* }}} */
 301 #endif /* KERNEL_AIX */
 302
 303 static int ipc_read(void) /* {{{ */
 304 {
 305   int x = 0;
 306   x |= ipc_read_shm();
 307   x |= ipc_read_sem();
 308   x |= ipc_read_msg();
 309
 310   return x;
 311 }
 312 /* }}} */
 313
 314 void module_register(void) /* {{{ */
 315 {
 316 #ifdef KERNEL_LINUX
 317   plugin_register_init("ipc", ipc_init);
 318 #endif
 319   plugin_register_read("ipc", ipc_read);
 320 }
 321 /* }}} */