Merge pull request #2348 from maryamtahhan/feat_dpdkevents_fixes
[collectd.git] / src / mcelog.c
1 /*-
2  * collectd - src/mcelog.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
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is 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
22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23  * DEALINGS IN THE SOFTWARE.
24
25  * Authors:
26  *   Maryam Tahhan <maryam.tahhan@intel.com>
27  *   Volodymyr Mytnyk <volodymyrx.mytnyk@intel.com>
28  *   Taras Chornyi <tarasx.chornyi@intel.com>
29  *   Krzysztof Matczak <krzysztofx.matczak@intel.com>
30  */
31
32 #include "common.h"
33 #include "collectd.h"
34
35 #include <poll.h>
36 #include <sys/socket.h>
37 #include <sys/un.h>
38 #include <unistd.h>
39
40 #define MCELOG_PLUGIN "mcelog"
41 #define MCELOG_BUFF_SIZE 1024
42 #define MCELOG_POLL_TIMEOUT 1000 /* ms */
43 #define MCELOG_SOCKET_STR "SOCKET"
44 #define MCELOG_DIMM_NAME "DMI_NAME"
45 #define MCELOG_CORRECTED_ERR "corrected memory errors"
46 #define MCELOG_UNCORRECTED_ERR "uncorrected memory errors"
47
48 typedef struct mcelog_config_s {
49   char logfile[PATH_MAX]; /* mcelog logfile */
50   pthread_t tid;          /* poll thread id */
51 } mcelog_config_t;
52
53 typedef struct socket_adapter_s socket_adapter_t;
54
55 struct socket_adapter_s {
56   int sock_fd;                  /* mcelog server socket fd */
57   struct sockaddr_un unix_sock; /* mcelog client socket */
58   pthread_rwlock_t lock;
59   /* function pointers for socket operations */
60   int (*write)(socket_adapter_t *self, const char *msg, const size_t len);
61   int (*reinit)(socket_adapter_t *self);
62   int (*receive)(socket_adapter_t *self, FILE **p_file);
63   int (*close)(socket_adapter_t *self);
64 };
65
66 typedef struct mcelog_memory_rec_s {
67   int corrected_err_total; /* x total*/
68   int corrected_err_timed; /* x in 24h*/
69   char corrected_err_timed_period[DATA_MAX_NAME_LEN];
70   int uncorrected_err_total; /* x total*/
71   int uncorrected_err_timed; /* x in 24h*/
72   char uncorrected_err_timed_period[DATA_MAX_NAME_LEN];
73   char location[DATA_MAX_NAME_LEN];  /* SOCKET x CHANNEL x DIMM x*/
74   char dimm_name[DATA_MAX_NAME_LEN]; /* DMI_NAME "DIMM_F1" */
75 } mcelog_memory_rec_t;
76
77 static int socket_close(socket_adapter_t *self);
78 static int socket_write(socket_adapter_t *self, const char *msg,
79                         const size_t len);
80 static int socket_reinit(socket_adapter_t *self);
81 static int socket_receive(socket_adapter_t *self, FILE **p_file);
82
83 static mcelog_config_t g_mcelog_config = {.logfile = "/var/log/mcelog"};
84
85 static socket_adapter_t socket_adapter = {
86     .sock_fd = -1,
87     .unix_sock =
88         {
89             .sun_family = AF_UNIX, .sun_path = "/var/run/mcelog-client",
90         },
91     .lock = PTHREAD_RWLOCK_INITIALIZER,
92     .close = socket_close,
93     .write = socket_write,
94     .reinit = socket_reinit,
95     .receive = socket_receive,
96 };
97
98 static _Bool mcelog_thread_running;
99
100 static int mcelog_config(oconfig_item_t *ci) {
101   for (int i = 0; i < ci->children_num; i++) {
102     oconfig_item_t *child = ci->children + i;
103     if (strcasecmp("McelogClientSocket", child->key) == 0) {
104       if (cf_util_get_string_buffer(child, socket_adapter.unix_sock.sun_path,
105                                     sizeof(socket_adapter.unix_sock.sun_path)) <
106           0) {
107         ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
108               child->key);
109         return -1;
110       }
111     } else if (strcasecmp("McelogLogfile", child->key) == 0) {
112       if (cf_util_get_string_buffer(child, g_mcelog_config.logfile,
113                                     sizeof(g_mcelog_config.logfile)) < 0) {
114         ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
115               child->key);
116         return -1;
117       }
118     } else {
119       ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
120             child->key);
121       return -1;
122     }
123   }
124   return 0;
125 }
126
127 static int socket_close(socket_adapter_t *self) {
128   int ret = 0;
129   pthread_rwlock_rdlock(&self->lock);
130   if (fcntl(self->sock_fd, F_GETFL) != -1) {
131     char errbuf[MCELOG_BUFF_SIZE];
132     if (shutdown(self->sock_fd, SHUT_RDWR) != 0) {
133       ERROR(MCELOG_PLUGIN ": Socket shutdown failed: %s",
134             sstrerror(errno, errbuf, sizeof(errbuf)));
135       ret = -1;
136     }
137     if (close(self->sock_fd) != 0) {
138       ERROR(MCELOG_PLUGIN ": Socket close failed: %s",
139             sstrerror(errno, errbuf, sizeof(errbuf)));
140       ret = -1;
141     }
142   }
143   pthread_rwlock_unlock(&self->lock);
144   return ret;
145 }
146
147 static int socket_write(socket_adapter_t *self, const char *msg,
148                         const size_t len) {
149   int ret = 0;
150   pthread_rwlock_rdlock(&self->lock);
151   if (swrite(self->sock_fd, msg, len) < 0)
152     ret = -1;
153   pthread_rwlock_unlock(&self->lock);
154   return ret;
155 }
156
157 static void mcelog_dispatch_notification(notification_t *n) {
158   if (!n) {
159     ERROR(MCELOG_PLUGIN ": %s: NULL pointer", __FUNCTION__);
160     return;
161   }
162
163   sstrncpy(n->host, hostname_g, sizeof(n->host));
164   sstrncpy(n->type, "gauge", sizeof(n->type));
165   plugin_dispatch_notification(n);
166   if (n->meta)
167     plugin_notification_meta_free(n->meta);
168 }
169
170 static int socket_reinit(socket_adapter_t *self) {
171   char errbuff[MCELOG_BUFF_SIZE];
172   int ret = -1;
173   cdtime_t interval = plugin_get_interval();
174   struct timeval socket_timeout = CDTIME_T_TO_TIMEVAL(interval);
175
176   /* synchronization via write lock since sock_fd may be changed here */
177   pthread_rwlock_wrlock(&self->lock);
178   self->sock_fd =
179       socket(PF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
180   if (self->sock_fd < 0) {
181     ERROR(MCELOG_PLUGIN ": Could not create a socket. %s",
182           sstrerror(errno, errbuff, sizeof(errbuff)));
183     pthread_rwlock_unlock(&self->lock);
184     return ret;
185   }
186
187   /* Set socket timeout option */
188   if (setsockopt(self->sock_fd, SOL_SOCKET, SO_SNDTIMEO, &socket_timeout,
189                  sizeof(socket_timeout)) < 0)
190     ERROR(MCELOG_PLUGIN ": Failed to set the socket timeout option.");
191
192   /* downgrading to read lock due to possible recursive read locks
193    * in self->close(self) call */
194   pthread_rwlock_unlock(&self->lock);
195   pthread_rwlock_rdlock(&self->lock);
196   if (connect(self->sock_fd, (struct sockaddr *)&(self->unix_sock),
197               sizeof(self->unix_sock)) < 0) {
198     ERROR(MCELOG_PLUGIN ": Failed to connect to mcelog server. %s",
199           sstrerror(errno, errbuff, sizeof(errbuff)));
200     self->close(self);
201     ret = -1;
202   } else {
203     ret = 0;
204     mcelog_dispatch_notification(
205         &(notification_t){.severity = NOTIF_OKAY,
206                           .time = cdtime(),
207                           .message = "Connected to mcelog server",
208                           .plugin = MCELOG_PLUGIN,
209                           .type_instance = "mcelog_status"});
210   }
211   pthread_rwlock_unlock(&self->lock);
212   return ret;
213 }
214
215 static int mcelog_prepare_notification(notification_t *n,
216                                        const mcelog_memory_rec_t *mr) {
217   if (n == NULL || mr == NULL)
218     return -1;
219
220   if ((mr->location[0] != '\0') &&
221       (plugin_notification_meta_add_string(n, MCELOG_SOCKET_STR, mr->location) <
222        0)) {
223     ERROR(MCELOG_PLUGIN ": add memory location meta data failed");
224     return -1;
225   }
226   if ((mr->dimm_name[0] != '\0') &&
227       (plugin_notification_meta_add_string(n, MCELOG_DIMM_NAME, mr->dimm_name) <
228        0)) {
229     ERROR(MCELOG_PLUGIN ": add DIMM name meta data failed");
230     plugin_notification_meta_free(n->meta);
231     return -1;
232   }
233   if (plugin_notification_meta_add_signed_int(n, MCELOG_CORRECTED_ERR,
234                                               mr->corrected_err_total) < 0) {
235     ERROR(MCELOG_PLUGIN ": add corrected errors meta data failed");
236     plugin_notification_meta_free(n->meta);
237     return -1;
238   }
239   if (plugin_notification_meta_add_signed_int(
240           n, "corrected memory timed errors", mr->corrected_err_timed) < 0) {
241     ERROR(MCELOG_PLUGIN ": add corrected timed errors meta data failed");
242     plugin_notification_meta_free(n->meta);
243     return -1;
244   }
245   if ((mr->corrected_err_timed_period[0] != '\0') &&
246       (plugin_notification_meta_add_string(n, "corrected errors time period",
247                                            mr->corrected_err_timed_period) <
248        0)) {
249     ERROR(MCELOG_PLUGIN ": add corrected errors period meta data failed");
250     plugin_notification_meta_free(n->meta);
251     return -1;
252   }
253   if (plugin_notification_meta_add_signed_int(n, MCELOG_UNCORRECTED_ERR,
254                                               mr->uncorrected_err_total) < 0) {
255     ERROR(MCELOG_PLUGIN ": add corrected errors meta data failed");
256     plugin_notification_meta_free(n->meta);
257     return -1;
258   }
259   if (plugin_notification_meta_add_signed_int(n,
260                                               "uncorrected memory timed errors",
261                                               mr->uncorrected_err_timed) < 0) {
262     ERROR(MCELOG_PLUGIN ": add corrected timed errors meta data failed");
263     plugin_notification_meta_free(n->meta);
264     return -1;
265   }
266   if ((mr->uncorrected_err_timed_period[0] != '\0') &&
267       (plugin_notification_meta_add_string(n, "uncorrected errors time period",
268                                            mr->uncorrected_err_timed_period) <
269        0)) {
270     ERROR(MCELOG_PLUGIN ": add corrected errors period meta data failed");
271     plugin_notification_meta_free(n->meta);
272     return -1;
273   }
274
275   return 0;
276 }
277
278 static int mcelog_submit(const mcelog_memory_rec_t *mr) {
279
280   if (!mr) {
281     ERROR(MCELOG_PLUGIN ": %s: NULL pointer", __FUNCTION__);
282     return -1;
283   }
284
285   value_list_t vl = {
286       .values_len = 1,
287       .values = &(value_t){.derive = (derive_t)mr->corrected_err_total},
288       .time = cdtime(),
289       .plugin = MCELOG_PLUGIN,
290       .type = "errors",
291       .type_instance = "corrected_memory_errors"};
292
293   if (mr->dimm_name[0] != '\0')
294     ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s_%s",
295               mr->location, mr->dimm_name);
296   else
297     sstrncpy(vl.plugin_instance, mr->location, sizeof(vl.plugin_instance));
298
299   plugin_dispatch_values(&vl);
300
301   ssnprintf(vl.type_instance, sizeof(vl.type_instance),
302             "corrected_memory_errors_in_%s", mr->corrected_err_timed_period);
303   vl.values = &(value_t){.derive = (derive_t)mr->corrected_err_timed};
304   plugin_dispatch_values(&vl);
305
306   sstrncpy(vl.type_instance, "uncorrected_memory_errors",
307            sizeof(vl.type_instance));
308   vl.values = &(value_t){.derive = (derive_t)mr->uncorrected_err_total};
309   plugin_dispatch_values(&vl);
310
311   ssnprintf(vl.type_instance, sizeof(vl.type_instance),
312             "uncorrected_memory_errors_in_%s",
313             mr->uncorrected_err_timed_period);
314   vl.values = &(value_t){.derive = (derive_t)mr->uncorrected_err_timed};
315   plugin_dispatch_values(&vl);
316
317   return 0;
318 }
319
320 static int parse_memory_info(FILE *p_file, mcelog_memory_rec_t *memory_record) {
321   char buf[DATA_MAX_NAME_LEN] = {0};
322   while (fgets(buf, sizeof(buf), p_file)) {
323     /* Got empty line or "done" */
324     if ((!strncmp("\n", buf, strlen(buf))) ||
325         (!strncmp(buf, "done\n", strlen(buf))))
326       return 1;
327     if (strlen(buf) < 5)
328       continue;
329     if (!strncmp(buf, MCELOG_SOCKET_STR, strlen(MCELOG_SOCKET_STR))) {
330       sstrncpy(memory_record->location, buf, strlen(buf));
331       /* replace spaces with '_' */
332       for (size_t i = 0; i < strlen(memory_record->location); i++)
333         if (memory_record->location[i] == ' ')
334           memory_record->location[i] = '_';
335       DEBUG(MCELOG_PLUGIN ": Got SOCKET INFO %s", memory_record->location);
336     }
337     if (!strncmp(buf, MCELOG_DIMM_NAME, strlen(MCELOG_DIMM_NAME))) {
338       char *name = NULL;
339       char *saveptr = NULL;
340       name = strtok_r(buf, "\"", &saveptr);
341       if (name != NULL && saveptr != NULL) {
342         name = strtok_r(NULL, "\"", &saveptr);
343         if (name != NULL) {
344           sstrncpy(memory_record->dimm_name, name,
345                    sizeof(memory_record->dimm_name));
346           DEBUG(MCELOG_PLUGIN ": Got DIMM NAME %s", memory_record->dimm_name);
347         }
348       }
349     }
350     if (!strncmp(buf, MCELOG_CORRECTED_ERR, strlen(MCELOG_CORRECTED_ERR))) {
351       /* Get next line*/
352       if (fgets(buf, sizeof(buf), p_file) != NULL) {
353         sscanf(buf, "\t%d total", &(memory_record->corrected_err_total));
354         DEBUG(MCELOG_PLUGIN ": Got corrected error total %d",
355               memory_record->corrected_err_total);
356       }
357       if (fgets(buf, sizeof(buf), p_file) != NULL) {
358         sscanf(buf, "\t%d in %s", &(memory_record->corrected_err_timed),
359                memory_record->corrected_err_timed_period);
360         DEBUG(MCELOG_PLUGIN ": Got timed corrected errors %d in %s",
361               memory_record->corrected_err_total,
362               memory_record->corrected_err_timed_period);
363       }
364     }
365     if (!strncmp(buf, MCELOG_UNCORRECTED_ERR, strlen(MCELOG_UNCORRECTED_ERR))) {
366       if (fgets(buf, sizeof(buf), p_file) != NULL) {
367         sscanf(buf, "\t%d total", &(memory_record->uncorrected_err_total));
368         DEBUG(MCELOG_PLUGIN ": Got uncorrected error total %d",
369               memory_record->uncorrected_err_total);
370       }
371       if (fgets(buf, sizeof(buf), p_file) != NULL) {
372         sscanf(buf, "\t%d in %s", &(memory_record->uncorrected_err_timed),
373                memory_record->uncorrected_err_timed_period);
374         DEBUG(MCELOG_PLUGIN ": Got timed uncorrected errors %d in %s",
375               memory_record->uncorrected_err_total,
376               memory_record->uncorrected_err_timed_period);
377       }
378     }
379     memset(buf, 0, sizeof(buf));
380   }
381   /* parsing definitely finished */
382   return 0;
383 }
384
385 static void poll_worker_cleanup(void *arg) {
386   mcelog_thread_running = 0;
387   FILE *p_file = *((FILE **)arg);
388   if (p_file != NULL)
389     fclose(p_file);
390   free(arg);
391 }
392
393 static int socket_receive(socket_adapter_t *self, FILE **pp_file) {
394   int res = -1;
395   pthread_rwlock_rdlock(&self->lock);
396   struct pollfd poll_fd = {
397       .fd = self->sock_fd, .events = POLLIN | POLLPRI,
398   };
399
400   if ((res = poll(&poll_fd, 1, MCELOG_POLL_TIMEOUT)) <= 0) {
401     if (res != 0 && errno != EINTR) {
402       char errbuf[MCELOG_BUFF_SIZE];
403       ERROR("mcelog: poll failed: %s",
404             sstrerror(errno, errbuf, sizeof(errbuf)));
405     }
406     pthread_rwlock_unlock(&self->lock);
407     return res;
408   }
409
410   if (poll_fd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
411     /* connection is broken */
412     ERROR(MCELOG_PLUGIN ": Connection to socket is broken");
413     if (poll_fd.revents & (POLLERR | POLLHUP)) {
414       mcelog_dispatch_notification(
415           &(notification_t){.severity = NOTIF_FAILURE,
416                             .time = cdtime(),
417                             .message = "Connection to mcelog socket is broken.",
418                             .plugin = MCELOG_PLUGIN,
419                             .type_instance = "mcelog_status"});
420     }
421     pthread_rwlock_unlock(&self->lock);
422     return -1;
423   }
424
425   if (!(poll_fd.revents & (POLLIN | POLLPRI))) {
426     INFO(MCELOG_PLUGIN ": No data to read");
427     pthread_rwlock_unlock(&self->lock);
428     return 0;
429   }
430
431   if ((*pp_file = fdopen(dup(self->sock_fd), "r")) == NULL)
432     res = -1;
433
434   pthread_rwlock_unlock(&self->lock);
435   return res;
436 }
437
438 static void *poll_worker(__attribute__((unused)) void *arg) {
439   char errbuf[MCELOG_BUFF_SIZE];
440   mcelog_thread_running = 1;
441   FILE **pp_file = calloc(1, sizeof(*pp_file));
442   if (pp_file == NULL) {
443     ERROR("mcelog: memory allocation failed: %s",
444           sstrerror(errno, errbuf, sizeof(errbuf)));
445     pthread_exit((void *)1);
446   }
447
448   pthread_cleanup_push(poll_worker_cleanup, pp_file);
449
450   while (1) {
451     /* blocking call */
452     int res = socket_adapter.receive(&socket_adapter, pp_file);
453     if (res < 0) {
454       socket_adapter.close(&socket_adapter);
455       while (socket_adapter.reinit(&socket_adapter) != 0) {
456         nanosleep(&CDTIME_T_TO_TIMESPEC(MS_TO_CDTIME_T(MCELOG_POLL_TIMEOUT)),
457                   NULL);
458       }
459       continue;
460     }
461     /* timeout or no data to read */
462     else if (res == 0)
463       continue;
464
465     if (*pp_file == NULL)
466       continue;
467
468     mcelog_memory_rec_t memory_record = {0};
469     while (parse_memory_info(*pp_file, &memory_record)) {
470       /* Check if location was successfully parsed */
471       if (memory_record.location[0] == '\0') {
472         memset(&memory_record, 0, sizeof(memory_record));
473         continue;
474       }
475
476       notification_t n = {.severity = NOTIF_OKAY,
477                           .time = cdtime(),
478                           .message = "Got memory errors info.",
479                           .plugin = MCELOG_PLUGIN,
480                           .type_instance = "memory_erros"};
481
482       if (mcelog_prepare_notification(&n, &memory_record) == 0)
483         mcelog_dispatch_notification(&n);
484       if (mcelog_submit(&memory_record) != 0)
485         ERROR(MCELOG_PLUGIN ": Failed to submit memory errors");
486       memset(&memory_record, 0, sizeof(memory_record));
487     }
488
489     fclose(*pp_file);
490     *pp_file = NULL;
491   }
492
493   mcelog_thread_running = 0;
494   pthread_cleanup_pop(1);
495   return NULL;
496 }
497
498 static int mcelog_init(void) {
499   if (socket_adapter.reinit(&socket_adapter) != 0) {
500     ERROR(MCELOG_PLUGIN ": Cannot connect to client socket");
501     return -1;
502   }
503
504   if (plugin_thread_create(&g_mcelog_config.tid, NULL, poll_worker, NULL,
505                            NULL) != 0) {
506     ERROR(MCELOG_PLUGIN ": Error creating poll thread.");
507     return -1;
508   }
509   return 0;
510 }
511
512 static int get_memory_machine_checks(void) {
513   static const char dump[] = "dump all bios\n";
514   int ret = socket_adapter.write(&socket_adapter, dump, sizeof(dump));
515   if (ret != 0)
516     ERROR(MCELOG_PLUGIN ": SENT DUMP REQUEST FAILED");
517   else
518     DEBUG(MCELOG_PLUGIN ": SENT DUMP REQUEST OK");
519   return ret;
520 }
521
522 static int mcelog_read(__attribute__((unused)) user_data_t *ud) {
523   DEBUG(MCELOG_PLUGIN ": %s", __FUNCTION__);
524
525   if (get_memory_machine_checks() != 0)
526     ERROR(MCELOG_PLUGIN ": MACHINE CHECK INFO NOT AVAILABLE");
527
528   return 0;
529 }
530
531 static int mcelog_shutdown(void) {
532   int ret = 0;
533   if (mcelog_thread_running) {
534     pthread_cancel(g_mcelog_config.tid);
535     if (pthread_join(g_mcelog_config.tid, NULL) != 0) {
536       ERROR(MCELOG_PLUGIN ": Stopping thread failed.");
537       ret = -1;
538     }
539   }
540
541   ret = socket_adapter.close(&socket_adapter) || ret;
542   pthread_rwlock_destroy(&(socket_adapter.lock));
543   return -ret;
544 }
545
546 void module_register(void) {
547   plugin_register_complex_config(MCELOG_PLUGIN, mcelog_config);
548   plugin_register_init(MCELOG_PLUGIN, mcelog_init);
549   plugin_register_complex_read(NULL, MCELOG_PLUGIN, mcelog_read, 0, NULL);
550   plugin_register_shutdown(MCELOG_PLUGIN, mcelog_shutdown);
551 }