src/zone.c

   1 /**
   2  * collectd - src/zone.c
   3  * Copyright (C) 2011       Mathijs Mohlmann
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Mathijs Mohlmann
  20  *   Dagobert Michelsen (forward-porting)
  21  **/
  22
  23 #if HAVE_CONFIG_H
  24 #include "config.h"
  25 #undef HAVE_CONFIG_H
  26 #endif
  27 /* avoid procfs.h error "Cannot use procfs in the large file compilation
  28  * environment" */
  29 #if !defined(_LP64) && _FILE_OFFSET_BITS == 64
  30 #undef _FILE_OFFSET_BITS
  31 #undef _LARGEFILE64_SOURCE
  32 #endif
  33
  34 #include "collectd.h"
  35
  36 #include "common.h"
  37 #include "plugin.h"
  38
  39 #include <procfs.h>
  40 #include <zone.h>
  41
  42 #include "utils_avltree.h"
  43
  44 #define MAX_PROCFS_PATH 40
  45 #define FRC2PCT(pp) (((float)(pp)) / 0x8000 * 100)
  46
  47 typedef struct zone_stats {
  48   ushort_t pctcpu;
  49   ushort_t pctmem;
  50 } zone_stats_t;
  51
  52 static int zone_compare(const void *a, const void *b) {
  53   if (*(const zoneid_t *)a == *(const zoneid_t *)b)
  54     return (0);
  55   if (*(const zoneid_t *)a < *(const zoneid_t *)b)
  56     return (-1);
  57   return (1);
  58 }
  59
  60 static int zone_read_procfile(char const *pidstr, char const *name, void *buf,
  61                               size_t bufsize) {
  62   int fd;
  63
  64   char procfile[MAX_PROCFS_PATH];
  65   (void)snprintf(procfile, sizeof(procfile), "/proc/%s/%s", pidstr, name);
  66   if ((fd = open(procfile, O_RDONLY)) == -1) {
  67     return (1);
  68   }
  69
  70   if (sread(fd, buf, bufsize) != 0) {
  71     char errbuf[1024];
  72     ERROR("zone plugin: Reading \"%s\" failed: %s", procfile,
  73           sstrerror(errno, errbuf, sizeof(errbuf)));
  74     close(fd);
  75     return (1);
  76   }
  77
  78   close(fd);
  79   return (0);
  80 }
  81
  82 static int zone_submit_value(char *zone, gauge_t value) {
  83   value_list_t vl = VALUE_LIST_INIT;
  84   value_t values[1];
  85
  86   values[0].gauge = value;
  87
  88   vl.values = values;
  89   vl.values_len = 1; /*STATIC_ARRAY_SIZE (values);*/
  90   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
  91   sstrncpy(vl.plugin, "zone", sizeof(vl.plugin));
  92   sstrncpy(vl.type, "percent", sizeof(vl.type));
  93   sstrncpy(vl.type_instance, zone, sizeof(vl.type_instance));
  94
  95   return (plugin_dispatch_values(&vl));
  96 }
  97
  98 static zone_stats_t *zone_find_stats(c_avl_tree_t *tree, zoneid_t zoneid) {
  99   zone_stats_t *ret = NULL;
 100   zoneid_t *key = NULL;
 101
 102   if (c_avl_get(tree, (void **)&zoneid, (void **)&ret)) {
 103     if (!(ret = malloc(sizeof(*ret)))) {
 104       WARNING("zone plugin: no memory");
 105       return (NULL);
 106     }
 107     if (!(key = malloc(sizeof(*key)))) {
 108       WARNING("zone plugin: no memory");
 109       free(ret);
 110       return (NULL);
 111     }
 112     *key = zoneid;
 113     if (c_avl_insert(tree, key, ret)) {
 114       WARNING("zone plugin: error inserting into tree");
 115       return (NULL);
 116     }
 117   }
 118   return (ret);
 119 }
 120
 121 static void zone_submit_values(c_avl_tree_t *tree) {
 122   char zonename[ZONENAME_MAX];
 123   zoneid_t *zoneid = NULL;
 124   zone_stats_t *stats = NULL;
 125
 126   while (c_avl_pick(tree, (void **)&zoneid, (void **)&stats) == 0) {
 127     if (getzonenamebyid(*zoneid, zonename, sizeof(zonename)) == -1) {
 128       WARNING("zone plugin: error retrieving zonename");
 129     } else {
 130       zone_submit_value(zonename, (gauge_t)FRC2PCT(stats->pctcpu));
 131     }
 132     free(stats);
 133     free(zoneid);
 134   }
 135   c_avl_destroy(tree);
 136 }
 137
 138 static c_avl_tree_t *zone_scandir(DIR *procdir) {
 139   pid_t pid;
 140   dirent_t *direntp;
 141   psinfo_t psinfo;
 142   c_avl_tree_t *tree;
 143   zone_stats_t *stats;
 144
 145   if (!(tree = c_avl_create(zone_compare))) {
 146     WARNING("zone plugin: Failed to create tree");
 147     return (NULL);
 148   }
 149
 150   rewinddir(procdir);
 151   while ((direntp = readdir(procdir))) {
 152     char const *pidstr = direntp->d_name;
 153     if (pidstr[0] == '.') /* skip "." and ".."  */
 154       continue;
 155
 156     pid = atoi(pidstr);
 157     if (pid == 0 || pid == 2 || pid == 3)
 158       continue; /* skip sched, pageout and fsflush */
 159
 160     if (zone_read_procfile(pidstr, "psinfo", &psinfo, sizeof(psinfo_t)) != 0)
 161       continue;
 162
 163     stats = zone_find_stats(tree, psinfo.pr_zoneid);
 164     if (stats) {
 165       stats->pctcpu += psinfo.pr_pctcpu;
 166       stats->pctmem += psinfo.pr_pctmem;
 167     }
 168   }
 169   return (tree);
 170 }
 171
 172 static int zone_read(void) {
 173   DIR *procdir;
 174   c_avl_tree_t *tree;
 175
 176   if ((procdir = opendir("/proc")) == NULL) {
 177     ERROR("zone plugin: cannot open /proc directory\n");
 178     return (-1);
 179   }
 180
 181   tree = zone_scandir(procdir);
 182   closedir(procdir);
 183   if (tree == NULL) {
 184     return (-1);
 185   }
 186   zone_submit_values(tree); /* this also frees tree */
 187   return (0);
 188 }
 189
 190 void module_register(void) {
 191   plugin_register_read("zone", zone_read);
 192 } /* void module_register */