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.plugin, "zone", sizeof(vl.plugin));
  91   sstrncpy(vl.type, "percent", sizeof(vl.type));
  92   sstrncpy(vl.type_instance, zone, sizeof(vl.type_instance));
  93
  94   return plugin_dispatch_values(&vl);
  95 }
  96
  97 static zone_stats_t *zone_find_stats(c_avl_tree_t *tree, zoneid_t zoneid) {
  98   zone_stats_t *ret = NULL;
  99   zoneid_t *key = NULL;
 100
 101   if (c_avl_get(tree, (void **)&zoneid, (void **)&ret)) {
 102     if (!(ret = malloc(sizeof(*ret)))) {
 103       WARNING("zone plugin: no memory");
 104       return NULL;
 105     }
 106     if (!(key = malloc(sizeof(*key)))) {
 107       WARNING("zone plugin: no memory");
 108       free(ret);
 109       return NULL;
 110     }
 111     *key = zoneid;
 112     if (c_avl_insert(tree, key, ret)) {
 113       WARNING("zone plugin: error inserting into tree");
 114       return NULL;
 115     }
 116   }
 117   return ret;
 118 }
 119
 120 static void zone_submit_values(c_avl_tree_t *tree) {
 121   char zonename[ZONENAME_MAX];
 122   zoneid_t *zoneid = NULL;
 123   zone_stats_t *stats = NULL;
 124
 125   while (c_avl_pick(tree, (void **)&zoneid, (void **)&stats) == 0) {
 126     if (getzonenamebyid(*zoneid, zonename, sizeof(zonename)) == -1) {
 127       WARNING("zone plugin: error retrieving zonename");
 128     } else {
 129       zone_submit_value(zonename, (gauge_t)FRC2PCT(stats->pctcpu));
 130     }
 131     free(stats);
 132     free(zoneid);
 133   }
 134   c_avl_destroy(tree);
 135 }
 136
 137 static c_avl_tree_t *zone_scandir(DIR *procdir) {
 138   pid_t pid;
 139   dirent_t *direntp;
 140   psinfo_t psinfo;
 141   c_avl_tree_t *tree;
 142   zone_stats_t *stats;
 143
 144   if (!(tree = c_avl_create(zone_compare))) {
 145     WARNING("zone plugin: Failed to create tree");
 146     return NULL;
 147   }
 148
 149   rewinddir(procdir);
 150   while ((direntp = readdir(procdir))) {
 151     char const *pidstr = direntp->d_name;
 152     if (pidstr[0] == '.') /* skip "." and ".."  */
 153       continue;
 154
 155     pid = atoi(pidstr);
 156     if (pid == 0 || pid == 2 || pid == 3)
 157       continue; /* skip sched, pageout and fsflush */
 158
 159     if (zone_read_procfile(pidstr, "psinfo", &psinfo, sizeof(psinfo_t)) != 0)
 160       continue;
 161
 162     stats = zone_find_stats(tree, psinfo.pr_zoneid);
 163     if (stats) {
 164       stats->pctcpu += psinfo.pr_pctcpu;
 165       stats->pctmem += psinfo.pr_pctmem;
 166     }
 167   }
 168   return tree;
 169 }
 170
 171 static int zone_read(void) {
 172   DIR *procdir;
 173   c_avl_tree_t *tree;
 174
 175   if ((procdir = opendir("/proc")) == NULL) {
 176     ERROR("zone plugin: cannot open /proc directory\n");
 177     return -1;
 178   }
 179
 180   tree = zone_scandir(procdir);
 181   closedir(procdir);
 182   if (tree == NULL) {
 183     return -1;
 184   }
 185   zone_submit_values(tree); /* this also frees tree */
 186   return 0;
 187 }
 188
 189 void module_register(void) {
 190   plugin_register_read("zone", zone_read);
 191 } /* void module_register */