Merge pull request #2796 from elfiesmelfie/feat_ipmi_SEL_ignore_list
[collectd.git] / src / utils_vl_lookup.c
1 /**
2  * collectd - src/utils_vl_lookup.c
3  * Copyright (C) 2012       Florian Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian Forster <octo at collectd.org>
25  **/
26
27 #include "collectd.h"
28
29 #include <pthread.h>
30 #include <regex.h>
31
32 #include "common.h"
33 #include "utils_avltree.h"
34 #include "utils_vl_lookup.h"
35
36 #if HAVE_KSTAT_H
37 #include <kstat.h>
38 #endif
39
40 #if HAVE_LIBKSTAT
41 kstat_ctl_t *kc;
42 #endif /* HAVE_LIBKSTAT */
43
44 #if BUILD_TEST
45 #define sstrncpy strncpy
46 #define plugin_log(s, ...)                                                     \
47   do {                                                                         \
48     printf("[severity %i] ", s);                                               \
49     printf(__VA_ARGS__);                                                       \
50     printf("\n");                                                              \
51   } while (0)
52 #endif
53
54 /*
55  * Types
56  */
57 struct part_match_s {
58   char str[DATA_MAX_NAME_LEN];
59   regex_t regex;
60   bool is_regex;
61 };
62 typedef struct part_match_s part_match_t;
63
64 struct identifier_match_s {
65   part_match_t host;
66   part_match_t plugin;
67   part_match_t plugin_instance;
68   part_match_t type;
69   part_match_t type_instance;
70
71   unsigned int group_by;
72 };
73 typedef struct identifier_match_s identifier_match_t;
74
75 struct lookup_s {
76   c_avl_tree_t *by_type_tree;
77
78   lookup_class_callback_t cb_user_class;
79   lookup_obj_callback_t cb_user_obj;
80   lookup_free_class_callback_t cb_free_class;
81   lookup_free_obj_callback_t cb_free_obj;
82 };
83
84 struct user_obj_s;
85 typedef struct user_obj_s user_obj_t;
86 struct user_obj_s {
87   void *user_obj;
88   lookup_identifier_t ident;
89
90   user_obj_t *next;
91 };
92
93 struct user_class_s {
94   pthread_mutex_t lock;
95   void *user_class;
96   identifier_match_t match;
97   user_obj_t *user_obj_list; /* list of user_obj */
98 };
99 typedef struct user_class_s user_class_t;
100
101 struct user_class_list_s;
102 typedef struct user_class_list_s user_class_list_t;
103 struct user_class_list_s {
104   user_class_t entry;
105   user_class_list_t *next;
106 };
107
108 struct by_type_entry_s {
109   c_avl_tree_t *by_plugin_tree; /* plugin -> user_class_list_t */
110   user_class_list_t *wildcard_plugin_list;
111 };
112 typedef struct by_type_entry_s by_type_entry_t;
113
114 /*
115  * Private functions
116  */
117 static bool lu_part_matches(part_match_t const *match, /* {{{ */
118                             char const *str) {
119   if (match->is_regex) {
120     /* Short cut popular catch-all regex. */
121     if (strcmp(".*", match->str) == 0)
122       return true;
123
124     int status = regexec(&match->regex, str,
125                          /* nmatch = */ 0, /* pmatch = */ NULL,
126                          /* flags = */ 0);
127     if (status == 0)
128       return true;
129     else
130       return false;
131   } else if (strcmp(match->str, str) == 0)
132     return true;
133   else
134     return false;
135 } /* }}} bool lu_part_matches */
136
137 static int lu_copy_ident_to_match_part(part_match_t *match_part, /* {{{ */
138                                        char const *ident_part) {
139   size_t len = strlen(ident_part);
140   int status;
141
142   if ((len < 3) || (ident_part[0] != '/') || (ident_part[len - 1] != '/')) {
143     sstrncpy(match_part->str, ident_part, sizeof(match_part->str));
144     match_part->is_regex = false;
145     return 0;
146   }
147
148   /* Copy string without the leading slash. */
149   sstrncpy(match_part->str, ident_part + 1, sizeof(match_part->str));
150   assert(sizeof(match_part->str) > len);
151   /* strip trailing slash */
152   match_part->str[len - 2] = 0;
153
154   status = regcomp(&match_part->regex, match_part->str,
155                    /* flags = */ REG_EXTENDED);
156   if (status != 0) {
157     char errbuf[1024];
158     regerror(status, &match_part->regex, errbuf, sizeof(errbuf));
159     ERROR("utils_vl_lookup: Compiling regular expression \"%s\" failed: %s",
160           match_part->str, errbuf);
161     return EINVAL;
162   }
163   match_part->is_regex = true;
164
165   return 0;
166 } /* }}} int lu_copy_ident_to_match_part */
167
168 static int lu_copy_ident_to_match(identifier_match_t *match, /* {{{ */
169                                   lookup_identifier_t const *ident,
170                                   unsigned int group_by) {
171   memset(match, 0, sizeof(*match));
172
173   match->group_by = group_by;
174
175 #define COPY_FIELD(field)                                                      \
176   do {                                                                         \
177     int status = lu_copy_ident_to_match_part(&match->field, ident->field);     \
178     if (status != 0)                                                           \
179       return status;                                                           \
180   } while (0)
181
182   COPY_FIELD(host);
183   COPY_FIELD(plugin);
184   COPY_FIELD(plugin_instance);
185   COPY_FIELD(type);
186   COPY_FIELD(type_instance);
187
188 #undef COPY_FIELD
189
190   return 0;
191 } /* }}} int lu_copy_ident_to_match */
192
193 /* user_class->lock must be held when calling this function */
194 static void *lu_create_user_obj(lookup_t *obj, /* {{{ */
195                                 data_set_t const *ds, value_list_t const *vl,
196                                 user_class_t *user_class) {
197   user_obj_t *user_obj;
198
199   user_obj = calloc(1, sizeof(*user_obj));
200   if (user_obj == NULL) {
201     ERROR("utils_vl_lookup: calloc failed.");
202     return NULL;
203   }
204   user_obj->next = NULL;
205
206   user_obj->user_obj = obj->cb_user_class(ds, vl, user_class->user_class);
207   if (user_obj->user_obj == NULL) {
208     sfree(user_obj);
209     WARNING("utils_vl_lookup: User-provided constructor failed.");
210     return NULL;
211   }
212
213 #define COPY_FIELD(field, group_mask)                                          \
214   do {                                                                         \
215     if (user_class->match.field.is_regex &&                                    \
216         ((user_class->match.group_by & group_mask) == 0))                      \
217       sstrncpy(user_obj->ident.field, "/.*/", sizeof(user_obj->ident.field));  \
218     else                                                                       \
219       sstrncpy(user_obj->ident.field, vl->field,                               \
220                sizeof(user_obj->ident.field));                                 \
221   } while (0)
222
223   COPY_FIELD(host, LU_GROUP_BY_HOST);
224   COPY_FIELD(plugin, LU_GROUP_BY_PLUGIN);
225   COPY_FIELD(plugin_instance, LU_GROUP_BY_PLUGIN_INSTANCE);
226   COPY_FIELD(type, 0);
227   COPY_FIELD(type_instance, LU_GROUP_BY_TYPE_INSTANCE);
228
229 #undef COPY_FIELD
230
231   if (user_class->user_obj_list == NULL) {
232     user_class->user_obj_list = user_obj;
233   } else {
234     user_obj_t *last = user_class->user_obj_list;
235     while (last->next != NULL)
236       last = last->next;
237     last->next = user_obj;
238   }
239
240   return user_obj;
241 } /* }}} void *lu_create_user_obj */
242
243 /* user_class->lock must be held when calling this function */
244 static user_obj_t *lu_find_user_obj(user_class_t *user_class, /* {{{ */
245                                     value_list_t const *vl) {
246   user_obj_t *ptr;
247
248   for (ptr = user_class->user_obj_list; ptr != NULL; ptr = ptr->next) {
249     if (user_class->match.host.is_regex &&
250         (user_class->match.group_by & LU_GROUP_BY_HOST) &&
251         (strcmp(vl->host, ptr->ident.host) != 0))
252       continue;
253     if (user_class->match.plugin.is_regex &&
254         (user_class->match.group_by & LU_GROUP_BY_PLUGIN) &&
255         (strcmp(vl->plugin, ptr->ident.plugin) != 0))
256       continue;
257     if (user_class->match.plugin_instance.is_regex &&
258         (user_class->match.group_by & LU_GROUP_BY_PLUGIN_INSTANCE) &&
259         (strcmp(vl->plugin_instance, ptr->ident.plugin_instance) != 0))
260       continue;
261     if (user_class->match.type_instance.is_regex &&
262         (user_class->match.group_by & LU_GROUP_BY_TYPE_INSTANCE) &&
263         (strcmp(vl->type_instance, ptr->ident.type_instance) != 0))
264       continue;
265
266     return ptr;
267   }
268
269   return NULL;
270 } /* }}} user_obj_t *lu_find_user_obj */
271
272 static int lu_handle_user_class(lookup_t *obj, /* {{{ */
273                                 data_set_t const *ds, value_list_t const *vl,
274                                 user_class_t *user_class) {
275   user_obj_t *user_obj;
276   int status;
277
278   assert(strcmp(vl->type, user_class->match.type.str) == 0);
279   assert(user_class->match.plugin.is_regex ||
280          (strcmp(vl->plugin, user_class->match.plugin.str)) == 0);
281
282   if (!lu_part_matches(&user_class->match.type_instance, vl->type_instance) ||
283       !lu_part_matches(&user_class->match.plugin_instance,
284                        vl->plugin_instance) ||
285       !lu_part_matches(&user_class->match.plugin, vl->plugin) ||
286       !lu_part_matches(&user_class->match.host, vl->host))
287     return 1;
288
289   pthread_mutex_lock(&user_class->lock);
290   user_obj = lu_find_user_obj(user_class, vl);
291   if (user_obj == NULL) {
292     /* call lookup_class_callback_t() and insert into the list of user objects.
293      */
294     user_obj = lu_create_user_obj(obj, ds, vl, user_class);
295     if (user_obj == NULL) {
296       pthread_mutex_unlock(&user_class->lock);
297       return -1;
298     }
299   }
300   pthread_mutex_unlock(&user_class->lock);
301
302   status = obj->cb_user_obj(ds, vl, user_class->user_class, user_obj->user_obj);
303   if (status != 0) {
304     ERROR("utils_vl_lookup: The user object callback failed with status %i.",
305           status);
306     /* Returning a negative value means: abort! */
307     if (status < 0)
308       return status;
309     else
310       return 1;
311   }
312
313   return 0;
314 } /* }}} int lu_handle_user_class */
315
316 static int lu_handle_user_class_list(lookup_t *obj, /* {{{ */
317                                      data_set_t const *ds,
318                                      value_list_t const *vl,
319                                      user_class_list_t *user_class_list) {
320   user_class_list_t *ptr;
321   int retval = 0;
322
323   for (ptr = user_class_list; ptr != NULL; ptr = ptr->next) {
324     int status;
325
326     status = lu_handle_user_class(obj, ds, vl, &ptr->entry);
327     if (status < 0)
328       return status;
329     else if (status == 0)
330       retval++;
331   }
332
333   return retval;
334 } /* }}} int lu_handle_user_class_list */
335
336 static by_type_entry_t *lu_search_by_type(lookup_t *obj, /* {{{ */
337                                           char const *type,
338                                           bool allocate_if_missing) {
339   by_type_entry_t *by_type;
340   char *type_copy;
341   int status;
342
343   status = c_avl_get(obj->by_type_tree, type, (void *)&by_type);
344   if (status == 0)
345     return by_type;
346
347   if (!allocate_if_missing)
348     return NULL;
349
350   type_copy = strdup(type);
351   if (type_copy == NULL) {
352     ERROR("utils_vl_lookup: strdup failed.");
353     return NULL;
354   }
355
356   by_type = calloc(1, sizeof(*by_type));
357   if (by_type == NULL) {
358     ERROR("utils_vl_lookup: calloc failed.");
359     sfree(type_copy);
360     return NULL;
361   }
362   by_type->wildcard_plugin_list = NULL;
363
364   by_type->by_plugin_tree =
365       c_avl_create((int (*)(const void *, const void *))strcmp);
366   if (by_type->by_plugin_tree == NULL) {
367     ERROR("utils_vl_lookup: c_avl_create failed.");
368     sfree(by_type);
369     sfree(type_copy);
370     return NULL;
371   }
372
373   status = c_avl_insert(obj->by_type_tree,
374                         /* key = */ type_copy, /* value = */ by_type);
375   assert(status <= 0); /* >0 => entry exists => race condition. */
376   if (status != 0) {
377     ERROR("utils_vl_lookup: c_avl_insert failed.");
378     c_avl_destroy(by_type->by_plugin_tree);
379     sfree(by_type);
380     sfree(type_copy);
381     return NULL;
382   }
383
384   return by_type;
385 } /* }}} by_type_entry_t *lu_search_by_type */
386
387 static int lu_add_by_plugin(by_type_entry_t *by_type, /* {{{ */
388                             user_class_list_t *user_class_list) {
389   user_class_list_t *ptr = NULL;
390   identifier_match_t const *match = &user_class_list->entry.match;
391
392   /* Lookup user_class_list from the per-plugin structure. If this is the first
393    * user_class to be added, the block returns immediately. Otherwise they will
394    * set "ptr" to non-NULL. */
395   if (match->plugin.is_regex) {
396     if (by_type->wildcard_plugin_list == NULL) {
397       by_type->wildcard_plugin_list = user_class_list;
398       return 0;
399     }
400
401     ptr = by_type->wildcard_plugin_list;
402   }    /* if (plugin is wildcard) */
403   else /* (plugin is not wildcard) */
404   {
405     int status;
406
407     status =
408         c_avl_get(by_type->by_plugin_tree, match->plugin.str, (void *)&ptr);
409
410     if (status != 0) /* plugin not yet in tree */
411     {
412       char *plugin_copy = strdup(match->plugin.str);
413
414       if (plugin_copy == NULL) {
415         ERROR("utils_vl_lookup: strdup failed.");
416         sfree(user_class_list);
417         return ENOMEM;
418       }
419
420       status =
421           c_avl_insert(by_type->by_plugin_tree, plugin_copy, user_class_list);
422       if (status != 0) {
423         ERROR("utils_vl_lookup: c_avl_insert(\"%s\") failed with status %i.",
424               plugin_copy, status);
425         sfree(plugin_copy);
426         sfree(user_class_list);
427         return status;
428       } else {
429         return 0;
430       }
431     } /* if (plugin not yet in tree) */
432   }   /* if (plugin is not wildcard) */
433
434   assert(ptr != NULL);
435
436   while (ptr->next != NULL)
437     ptr = ptr->next;
438   ptr->next = user_class_list;
439
440   return 0;
441 } /* }}} int lu_add_by_plugin */
442
443 static void lu_destroy_user_obj(lookup_t *obj, /* {{{ */
444                                 user_obj_t *user_obj) {
445   while (user_obj != NULL) {
446     user_obj_t *next = user_obj->next;
447
448     if (obj->cb_free_obj != NULL)
449       obj->cb_free_obj(user_obj->user_obj);
450     user_obj->user_obj = NULL;
451
452     sfree(user_obj);
453     user_obj = next;
454   }
455 } /* }}} void lu_destroy_user_obj */
456
457 static void lu_destroy_user_class_list(lookup_t *obj, /* {{{ */
458                                        user_class_list_t *user_class_list) {
459   while (user_class_list != NULL) {
460     user_class_list_t *next = user_class_list->next;
461
462     if (obj->cb_free_class != NULL)
463       obj->cb_free_class(user_class_list->entry.user_class);
464     user_class_list->entry.user_class = NULL;
465
466 #define CLEAR_FIELD(field)                                                     \
467   do {                                                                         \
468     if (user_class_list->entry.match.field.is_regex) {                         \
469       regfree(&user_class_list->entry.match.field.regex);                      \
470       user_class_list->entry.match.field.is_regex = false;                     \
471     }                                                                          \
472   } while (0)
473
474     CLEAR_FIELD(host);
475     CLEAR_FIELD(plugin);
476     CLEAR_FIELD(plugin_instance);
477     CLEAR_FIELD(type);
478     CLEAR_FIELD(type_instance);
479
480 #undef CLEAR_FIELD
481
482     lu_destroy_user_obj(obj, user_class_list->entry.user_obj_list);
483     user_class_list->entry.user_obj_list = NULL;
484     pthread_mutex_destroy(&user_class_list->entry.lock);
485
486     sfree(user_class_list);
487     user_class_list = next;
488   }
489 } /* }}} void lu_destroy_user_class_list */
490
491 static void lu_destroy_by_type(lookup_t *obj, /* {{{ */
492                                by_type_entry_t *by_type) {
493
494   while (42) {
495     char *plugin = NULL;
496     user_class_list_t *user_class_list = NULL;
497     int status;
498
499     status = c_avl_pick(by_type->by_plugin_tree, (void *)&plugin,
500                         (void *)&user_class_list);
501     if (status != 0)
502       break;
503
504     DEBUG("utils_vl_lookup: lu_destroy_by_type: Destroying plugin \"%s\".",
505           plugin);
506     sfree(plugin);
507     lu_destroy_user_class_list(obj, user_class_list);
508   }
509
510   c_avl_destroy(by_type->by_plugin_tree);
511   by_type->by_plugin_tree = NULL;
512
513   lu_destroy_user_class_list(obj, by_type->wildcard_plugin_list);
514   by_type->wildcard_plugin_list = NULL;
515
516   sfree(by_type);
517 } /* }}} int lu_destroy_by_type */
518
519 /*
520  * Public functions
521  */
522 lookup_t *lookup_create(lookup_class_callback_t cb_user_class, /* {{{ */
523                         lookup_obj_callback_t cb_user_obj,
524                         lookup_free_class_callback_t cb_free_class,
525                         lookup_free_obj_callback_t cb_free_obj) {
526   lookup_t *obj = calloc(1, sizeof(*obj));
527   if (obj == NULL) {
528     ERROR("utils_vl_lookup: calloc failed.");
529     return NULL;
530   }
531
532   obj->by_type_tree = c_avl_create((int (*)(const void *, const void *))strcmp);
533   if (obj->by_type_tree == NULL) {
534     ERROR("utils_vl_lookup: c_avl_create failed.");
535     sfree(obj);
536     return NULL;
537   }
538
539   obj->cb_user_class = cb_user_class;
540   obj->cb_user_obj = cb_user_obj;
541   obj->cb_free_class = cb_free_class;
542   obj->cb_free_obj = cb_free_obj;
543
544   return obj;
545 } /* }}} lookup_t *lookup_create */
546
547 void lookup_destroy(lookup_t *obj) /* {{{ */
548 {
549   int status;
550
551   if (obj == NULL)
552     return;
553
554   while (42) {
555     char *type = NULL;
556     by_type_entry_t *by_type = NULL;
557
558     status = c_avl_pick(obj->by_type_tree, (void *)&type, (void *)&by_type);
559     if (status != 0)
560       break;
561
562     DEBUG("utils_vl_lookup: lookup_destroy: Destroying type \"%s\".", type);
563     sfree(type);
564     lu_destroy_by_type(obj, by_type);
565   }
566
567   c_avl_destroy(obj->by_type_tree);
568   obj->by_type_tree = NULL;
569
570   sfree(obj);
571 } /* }}} void lookup_destroy */
572
573 int lookup_add(lookup_t *obj, /* {{{ */
574                lookup_identifier_t const *ident, unsigned int group_by,
575                void *user_class) {
576   by_type_entry_t *by_type = NULL;
577   user_class_list_t *user_class_obj;
578
579   by_type = lu_search_by_type(obj, ident->type, /* allocate = */ true);
580   if (by_type == NULL)
581     return -1;
582
583   user_class_obj = calloc(1, sizeof(*user_class_obj));
584   if (user_class_obj == NULL) {
585     ERROR("utils_vl_lookup: calloc failed.");
586     return ENOMEM;
587   }
588   pthread_mutex_init(&user_class_obj->entry.lock, /* attr = */ NULL);
589   user_class_obj->entry.user_class = user_class;
590   lu_copy_ident_to_match(&user_class_obj->entry.match, ident, group_by);
591   user_class_obj->entry.user_obj_list = NULL;
592   user_class_obj->next = NULL;
593
594   return lu_add_by_plugin(by_type, user_class_obj);
595 } /* }}} int lookup_add */
596
597 /* returns the number of successful calls to the callback function */
598 int lookup_search(lookup_t *obj, /* {{{ */
599                   data_set_t const *ds, value_list_t const *vl) {
600   by_type_entry_t *by_type = NULL;
601   user_class_list_t *user_class_list = NULL;
602   int retval = 0;
603   int status;
604
605   if ((obj == NULL) || (ds == NULL) || (vl == NULL))
606     return -EINVAL;
607
608   by_type = lu_search_by_type(obj, vl->type, /* allocate = */ false);
609   if (by_type == NULL)
610     return 0;
611
612   status =
613       c_avl_get(by_type->by_plugin_tree, vl->plugin, (void *)&user_class_list);
614   if (status == 0) {
615     status = lu_handle_user_class_list(obj, ds, vl, user_class_list);
616     if (status < 0)
617       return status;
618     retval += status;
619   }
620
621   if (by_type->wildcard_plugin_list != NULL) {
622     status =
623         lu_handle_user_class_list(obj, ds, vl, by_type->wildcard_plugin_list);
624     if (status < 0)
625       return status;
626     retval += status;
627   }
628
629   return retval;
630 } /* }}} lookup_search */