Merge branch 'collectd-5.7'
[collectd.git] / src / hugepages.c
1 /*-
2  * collectd - src/hugepages.c
3  * MIT License
4  *
5  * Copyright(c) 2016 Intel Corporation. All rights reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  *
25  * Authors:
26  *   Jaroslav Safka <jaroslavx.safka@intel.com>
27  *   Kim-Marie Jones <kim-marie.jones@intel.com>
28  *   Florian Forster <octo at collectd.org>
29  */
30
31 #include "collectd.h"
32
33 #include "common.h" /* auxiliary functions */
34 #include "plugin.h" /* plugin_register_*, plugin_dispatch_values */
35
36 static const char g_plugin_name[] = "hugepages";
37
38 static _Bool g_flag_rpt_numa = 1;
39 static _Bool g_flag_rpt_mm = 1;
40
41 static _Bool g_values_pages = 1;
42 static _Bool g_values_bytes = 0;
43 static _Bool g_values_percent = 0;
44
45 #define HP_HAVE_NR 0x01
46 #define HP_HAVE_SURPLUS 0x02
47 #define HP_HAVE_FREE 0x04
48 #define HP_HAVE_ALL 0x07
49
50 struct entry_info {
51   char *d_name;
52   const char *node;
53   size_t page_size_kb;
54
55   gauge_t nr;
56   gauge_t surplus;
57   gauge_t free;
58   uint8_t flags;
59 };
60
61 static int hp_config(oconfig_item_t *ci) {
62   for (int i = 0; i < ci->children_num; i++) {
63     oconfig_item_t *child = ci->children + i;
64     if (strcasecmp("ReportPerNodeHP", child->key) == 0)
65       cf_util_get_boolean(child, &g_flag_rpt_numa);
66     else if (strcasecmp("ReportRootHP", child->key) == 0)
67       cf_util_get_boolean(child, &g_flag_rpt_mm);
68     else if (strcasecmp("ValuesPages", child->key) == 0)
69       cf_util_get_boolean(child, &g_values_pages);
70     else if (strcasecmp("ValuesBytes", child->key) == 0)
71       cf_util_get_boolean(child, &g_values_bytes);
72     else if (strcasecmp("ValuesPercentage", child->key) == 0)
73       cf_util_get_boolean(child, &g_values_percent);
74     else
75       ERROR("%s: Invalid configuration option: \"%s\".", g_plugin_name,
76             child->key);
77   }
78
79   return 0;
80 }
81
82 static void submit_hp(const struct entry_info *info) {
83   value_list_t vl = VALUE_LIST_INIT;
84
85   vl.values = &(value_t){.gauge = NAN};
86   vl.values_len = 1;
87
88   sstrncpy(vl.plugin, g_plugin_name, sizeof(vl.plugin));
89   if (info->node) {
90     snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%zuKb",
91              info->node, info->page_size_kb);
92   } else {
93     snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%zuKb",
94              info->page_size_kb);
95   }
96
97   /* ensure all metrics have the same timestamp */
98   vl.time = cdtime();
99
100   gauge_t free = info->free;
101   gauge_t used = (info->nr + info->surplus) - info->free;
102
103   if (g_values_pages) {
104     sstrncpy(vl.type, "vmpage_number", sizeof(vl.type));
105     plugin_dispatch_multivalue(&vl, /* store_percentage = */ 0, DS_TYPE_GAUGE,
106                                "free", free, "used", used, NULL);
107   }
108   if (g_values_bytes) {
109     gauge_t page_size = (gauge_t)(1024 * info->page_size_kb);
110     sstrncpy(vl.type, "memory", sizeof(vl.type));
111     plugin_dispatch_multivalue(&vl, /* store_percentage = */ 0, DS_TYPE_GAUGE,
112                                "free", free * page_size, "used",
113                                used * page_size, NULL);
114   }
115   if (g_values_percent) {
116     sstrncpy(vl.type, "percent", sizeof(vl.type));
117     plugin_dispatch_multivalue(&vl, /* store_percentage = */ 1, DS_TYPE_GAUGE,
118                                "free", free, "used", used, NULL);
119   }
120 }
121
122 static int read_hugepage_entry(const char *path, const char *entry,
123                                void *e_info) {
124   char path2[PATH_MAX];
125   struct entry_info *info = e_info;
126   double value;
127
128   snprintf(path2, sizeof(path2), "%s/%s", path, entry);
129
130   FILE *fh = fopen(path2, "rt");
131   if (fh == NULL) {
132     ERROR("%s: cannot open %s", g_plugin_name, path2);
133     return -1;
134   }
135
136   if (fscanf(fh, "%lf", &value) != 1) {
137     ERROR("%s: cannot parse file %s", g_plugin_name, path2);
138     fclose(fh);
139     return -1;
140   }
141   fclose(fh);
142
143   if (strcmp(entry, "nr_hugepages") == 0) {
144     info->nr = value;
145     info->flags |= HP_HAVE_NR;
146   } else if (strcmp(entry, "surplus_hugepages") == 0) {
147     info->surplus = value;
148     info->flags |= HP_HAVE_SURPLUS;
149   } else if (strcmp(entry, "free_hugepages") == 0) {
150     info->free = value;
151     info->flags |= HP_HAVE_FREE;
152   }
153
154   if (info->flags != HP_HAVE_ALL) {
155     return 0;
156   }
157
158   submit_hp(info);
159
160   /* Reset flags so subsequent calls don't submit again. */
161   info->flags = 0;
162   return 0;
163 }
164
165 static int read_syshugepages(const char *path, const char *node) {
166   static const char hugepages_dir[] = "hugepages-";
167   DIR *dir;
168   struct dirent *result;
169   char path2[PATH_MAX];
170
171   dir = opendir(path);
172   if (dir == NULL) {
173     ERROR("%s: cannot open directory %s", g_plugin_name, path);
174     return -1;
175   }
176
177   /* read "hugepages-XXXXXkB" entries */
178   while ((result = readdir(dir)) != NULL) {
179     if (strncmp(result->d_name, hugepages_dir, sizeof(hugepages_dir) - 1)) {
180       /* not node dir */
181       errno = 0;
182       continue;
183     }
184
185     long page_size = strtol(result->d_name + strlen(hugepages_dir),
186                             /* endptr = */ NULL, /* base = */ 10);
187     if (errno != 0) {
188       char errbuf[1024];
189       ERROR("%s: failed to determine page size from directory name \"%s\": %s",
190             g_plugin_name, result->d_name,
191             sstrerror(errno, errbuf, sizeof(errbuf)));
192       continue;
193     }
194
195     /* /sys/devices/system/node/node?/hugepages/ */
196     snprintf(path2, sizeof(path2), "%s/%s", path, result->d_name);
197
198     walk_directory(path2, read_hugepage_entry,
199                    &(struct entry_info){
200                        .d_name = result->d_name,
201                        .node = node,
202                        .page_size_kb = (size_t)page_size,
203                    },
204                    /* hidden = */ 0);
205     errno = 0;
206   }
207
208   /* Check if NULL return from readdir() was an error */
209   if (errno != 0) {
210     ERROR("%s: readdir failed", g_plugin_name);
211     closedir(dir);
212     return -1;
213   }
214
215   closedir(dir);
216   return 0;
217 }
218
219 static int read_nodes(void) {
220   static const char sys_node[] = "/sys/devices/system/node";
221   static const char node_string[] = "node";
222   static const char sys_node_hugepages[] =
223       "/sys/devices/system/node/%s/hugepages";
224   DIR *dir;
225   struct dirent *result;
226   char path[PATH_MAX];
227
228   dir = opendir(sys_node);
229   if (dir == NULL) {
230     ERROR("%s: cannot open directory %s", g_plugin_name, sys_node);
231     return -1;
232   }
233
234   while ((result = readdir(dir)) != NULL) {
235     if (strncmp(result->d_name, node_string, sizeof(node_string) - 1)) {
236       /* not node dir */
237       errno = 0;
238       continue;
239     }
240
241     snprintf(path, sizeof(path), sys_node_hugepages, result->d_name);
242     read_syshugepages(path, result->d_name);
243     errno = 0;
244   }
245
246   /* Check if NULL return from readdir() was an error */
247   if (errno != 0) {
248     ERROR("%s: readdir failed", g_plugin_name);
249     closedir(dir);
250     return -1;
251   }
252
253   closedir(dir);
254   return 0;
255 }
256
257 static int huge_read(void) {
258   static const char sys_mm_hugepages[] = "/sys/kernel/mm/hugepages";
259
260   if (g_flag_rpt_mm) {
261     if (read_syshugepages(sys_mm_hugepages, "mm") != 0) {
262       return -1;
263     }
264   }
265   if (g_flag_rpt_numa) {
266     if (read_nodes() != 0) {
267       return -1;
268     }
269   }
270
271   return 0;
272 }
273
274 void module_register(void) {
275   plugin_register_complex_config(g_plugin_name, hp_config);
276   plugin_register_read(g_plugin_name, huge_read);
277 }