virt plugin: Fix segfaults on shutdown
[collectd.git] / src / lua.c
1 /**
2  * collectd - src/lua.c
3  * Copyright (C) 2010       Julien Ammous
4  * Copyright (C) 2010       Florian Forster
5  * Copyright (C) 2016       Ruben Kerkhof
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  *   Julien Ammous
27  *   Florian Forster <octo at collectd.org>
28  *   Ruben Kerkhof <ruben at rubenkerkhof.com>
29  **/
30
31 #include "collectd.h"
32 #include "plugin.h"
33 #include "utils/common/common.h"
34 #include "utils_lua.h"
35
36 /* Include the Lua API header files. */
37 #include <lauxlib.h>
38 #include <lua.h>
39 #include <lualib.h>
40
41 #include <pthread.h>
42
43 typedef struct lua_script_s {
44   char *script_path;
45   lua_State *lua_state;
46   struct lua_script_s *next;
47 } lua_script_t;
48
49 typedef struct {
50   lua_State *lua_state;
51   char *lua_function_name;
52   pthread_mutex_t lock;
53   int callback_id;
54 } clua_callback_data_t;
55
56 static char base_path[PATH_MAX];
57 static lua_script_t *scripts;
58
59 static int clua_store_callback(lua_State *L, int idx) /* {{{ */
60 {
61   /* Copy the function pointer */
62   lua_pushvalue(L, idx);
63
64   return luaL_ref(L, LUA_REGISTRYINDEX);
65 } /* }}} int clua_store_callback */
66
67 static int clua_load_callback(lua_State *L, int callback_ref) /* {{{ */
68 {
69   lua_rawgeti(L, LUA_REGISTRYINDEX, callback_ref);
70
71   if (!lua_isfunction(L, -1)) {
72     lua_pop(L, 1);
73     return -1;
74   }
75
76   return 0;
77 } /* }}} int clua_load_callback */
78
79 /* Store the threads in a global variable so they are not cleaned up by the
80  * garbage collector. */
81 static int clua_store_thread(lua_State *L, int idx) /* {{{ */
82 {
83   if (idx < 0)
84     idx += lua_gettop(L) + 1;
85
86   /* Copy the thread pointer */
87   lua_pushvalue(L, idx); /* +1 = 3 */
88   if (!lua_isthread(L, -1)) {
89     lua_pop(L, 3); /* -3 = 0 */
90     return -1;
91   }
92
93   luaL_ref(L, LUA_REGISTRYINDEX);
94   lua_pop(L, 1); /* -1 = 0 */
95   return 0;
96 } /* }}} int clua_store_thread */
97
98 static int clua_read(user_data_t *ud) /* {{{ */
99 {
100   clua_callback_data_t *cb = ud->data;
101
102   pthread_mutex_lock(&cb->lock);
103
104   lua_State *L = cb->lua_state;
105
106   int status = clua_load_callback(L, cb->callback_id);
107   if (status != 0) {
108     ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
109           cb->lua_function_name, cb->callback_id);
110     pthread_mutex_unlock(&cb->lock);
111     return -1;
112   }
113   /* +1 = 1 */
114
115   status = lua_pcall(L, 0, 1, 0);
116   if (status != 0) {
117     const char *errmsg = lua_tostring(L, -1);
118     if (errmsg == NULL)
119       ERROR("Lua plugin: Calling a read callback failed. "
120             "In addition, retrieving the error message failed.");
121     else
122       ERROR("Lua plugin: Calling a read callback failed: %s", errmsg);
123     lua_pop(L, 1);
124     pthread_mutex_unlock(&cb->lock);
125     return -1;
126   }
127
128   if (!lua_isnumber(L, -1)) {
129     ERROR("Lua plugin: Read function \"%s\" (id %i) did not return a numeric "
130           "status.",
131           cb->lua_function_name, cb->callback_id);
132     status = -1;
133   } else {
134     status = (int)lua_tointeger(L, -1);
135   }
136
137   /* pop return value and function */
138   lua_pop(L, 1); /* -1 = 0 */
139
140   pthread_mutex_unlock(&cb->lock);
141   return status;
142 } /* }}} int clua_read */
143
144 static int clua_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
145                       user_data_t *ud) {
146   clua_callback_data_t *cb = ud->data;
147
148   pthread_mutex_lock(&cb->lock);
149
150   lua_State *L = cb->lua_state;
151
152   int status = clua_load_callback(L, cb->callback_id);
153   if (status != 0) {
154     ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
155           cb->lua_function_name, cb->callback_id);
156     pthread_mutex_unlock(&cb->lock);
157     return -1;
158   }
159   /* +1 = 1 */
160
161   status = luaC_pushvaluelist(L, ds, vl);
162   if (status != 0) {
163     lua_pop(L, 1); /* -1 = 0 */
164     pthread_mutex_unlock(&cb->lock);
165     ERROR("Lua plugin: luaC_pushvaluelist failed.");
166     return -1;
167   }
168   /* +1 = 2 */
169
170   status = lua_pcall(L, 1, 1, 0); /* -2+1 = 1 */
171   if (status != 0) {
172     const char *errmsg = lua_tostring(L, -1);
173     if (errmsg == NULL)
174       ERROR("Lua plugin: Calling the write callback failed. "
175             "In addition, retrieving the error message failed.");
176     else
177       ERROR("Lua plugin: Calling the write callback failed:\n%s", errmsg);
178     lua_pop(L, 1); /* -1 = 0 */
179     pthread_mutex_unlock(&cb->lock);
180     return -1;
181   }
182
183   if (!lua_isnumber(L, -1)) {
184     ERROR("Lua plugin: Write function \"%s\" (id %i) did not return a numeric "
185           "value.",
186           cb->lua_function_name, cb->callback_id);
187     status = -1;
188   } else {
189     status = (int)lua_tointeger(L, -1);
190   }
191
192   lua_pop(L, 1); /* -1 = 0 */
193   pthread_mutex_unlock(&cb->lock);
194   return status;
195 } /* }}} int clua_write */
196
197 /*
198  * Exported functions
199  */
200
201 static int lua_cb_log_debug(lua_State *L) /* {{{ */
202 {
203   const char *msg = luaL_checkstring(L, 1);
204   plugin_log(LOG_DEBUG, "%s", msg);
205   return 0;
206 } /* }}} int lua_cb_log_debug */
207
208 static int lua_cb_log_error(lua_State *L) /* {{{ */
209 {
210   const char *msg = luaL_checkstring(L, 1);
211   plugin_log(LOG_ERR, "%s", msg);
212   return 0;
213 } /* }}} int lua_cb_log_error */
214
215 static int lua_cb_log_info(lua_State *L) /* {{{ */
216 {
217   const char *msg = luaL_checkstring(L, 1);
218   plugin_log(LOG_INFO, "%s", msg);
219   return 0;
220 } /* }}} int lua_cb_log_info */
221
222 static int lua_cb_log_notice(lua_State *L) /* {{{ */
223 {
224   const char *msg = luaL_checkstring(L, 1);
225   plugin_log(LOG_NOTICE, "%s", msg);
226   return 0;
227 } /* }}} int lua_cb_log_notice */
228
229 static int lua_cb_log_warning(lua_State *L) /* {{{ */
230 {
231   const char *msg = luaL_checkstring(L, 1);
232   plugin_log(LOG_WARNING, "%s", msg);
233   return 0;
234 } /* }}} int lua_cb_log_warning */
235
236 static int lua_cb_dispatch_values(lua_State *L) /* {{{ */
237 {
238   int nargs = lua_gettop(L);
239
240   if (nargs != 1)
241     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
242
243   luaL_checktype(L, 1, LUA_TTABLE);
244
245   value_list_t *vl = luaC_tovaluelist(L, -1);
246   if (vl == NULL)
247     return luaL_error(L, "%s", "luaC_tovaluelist failed");
248
249 #if COLLECT_DEBUG
250   char identifier[6 * DATA_MAX_NAME_LEN];
251   FORMAT_VL(identifier, sizeof(identifier), vl);
252
253   DEBUG("Lua plugin: collectd.dispatch_values(): Received value list \"%s\", "
254         "time %.3f, interval %.3f.",
255         identifier, CDTIME_T_TO_DOUBLE(vl->time),
256         CDTIME_T_TO_DOUBLE(vl->interval));
257 #endif
258
259   plugin_dispatch_values(vl);
260
261   sfree(vl->values);
262   sfree(vl);
263   return 0;
264 } /* }}} lua_cb_dispatch_values */
265
266 static void lua_cb_free(void *data) {
267   clua_callback_data_t *cb = data;
268   free(cb->lua_function_name);
269   free(cb);
270 }
271
272 static int lua_cb_register_read(lua_State *L) /* {{{ */
273 {
274   int nargs = lua_gettop(L);
275
276   if (nargs != 1)
277     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
278
279   luaL_checktype(L, 1, LUA_TFUNCTION);
280
281   char function_name[DATA_MAX_NAME_LEN];
282   snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
283
284   int callback_id = clua_store_callback(L, 1);
285   if (callback_id < 0)
286     return luaL_error(L, "%s", "Storing callback function failed");
287
288   lua_State *thread = lua_newthread(L);
289   if (thread == NULL)
290     return luaL_error(L, "%s", "lua_newthread failed");
291   clua_store_thread(L, -1);
292   lua_pop(L, 1);
293
294   clua_callback_data_t *cb = calloc(1, sizeof(*cb));
295   if (cb == NULL)
296     return luaL_error(L, "%s", "calloc failed");
297
298   cb->lua_state = thread;
299   cb->callback_id = callback_id;
300   cb->lua_function_name = strdup(function_name);
301   pthread_mutex_init(&cb->lock, NULL);
302
303   int status =
304       plugin_register_complex_read(/* group = */ "lua",
305                                    /* name      = */ function_name,
306                                    /* callback  = */ clua_read,
307                                    /* interval  = */ 0,
308                                    &(user_data_t){
309                                        .data = cb, .free_func = lua_cb_free,
310                                    });
311
312   if (status != 0)
313     return luaL_error(L, "%s", "plugin_register_complex_read failed");
314   return 0;
315 } /* }}} int lua_cb_register_read */
316
317 static int lua_cb_register_write(lua_State *L) /* {{{ */
318 {
319   int nargs = lua_gettop(L);
320
321   if (nargs != 1)
322     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
323
324   luaL_checktype(L, 1, LUA_TFUNCTION);
325
326   char function_name[DATA_MAX_NAME_LEN] = "";
327   snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
328
329   int callback_id = clua_store_callback(L, 1);
330   if (callback_id < 0)
331     return luaL_error(L, "%s", "Storing callback function failed");
332
333   lua_State *thread = lua_newthread(L);
334   if (thread == NULL)
335     return luaL_error(L, "%s", "lua_newthread failed");
336   clua_store_thread(L, -1);
337   lua_pop(L, 1);
338
339   clua_callback_data_t *cb = calloc(1, sizeof(*cb));
340   if (cb == NULL)
341     return luaL_error(L, "%s", "calloc failed");
342
343   cb->lua_state = thread;
344   cb->callback_id = callback_id;
345   cb->lua_function_name = strdup(function_name);
346   pthread_mutex_init(&cb->lock, NULL);
347
348   int status = plugin_register_write(/* name = */ function_name,
349                                      /* callback  = */ clua_write,
350                                      &(user_data_t){
351                                          .data = cb, .free_func = lua_cb_free,
352                                      });
353
354   if (status != 0)
355     return luaL_error(L, "%s", "plugin_register_write failed");
356   return 0;
357 } /* }}} int lua_cb_register_write */
358
359 static const luaL_Reg collectdlib[] = {
360     {"log_debug", lua_cb_log_debug},
361     {"log_error", lua_cb_log_error},
362     {"log_info", lua_cb_log_info},
363     {"log_notice", lua_cb_log_notice},
364     {"log_warning", lua_cb_log_warning},
365     {"dispatch_values", lua_cb_dispatch_values},
366     {"register_read", lua_cb_register_read},
367     {"register_write", lua_cb_register_write},
368     {NULL, NULL}};
369
370 static int open_collectd(lua_State *L) /* {{{ */
371 {
372 #if LUA_VERSION_NUM < 502
373   luaL_register(L, "collectd", collectdlib);
374 #else
375   luaL_newlib(L, collectdlib);
376 #endif
377   return 1;
378 } /* }}} */
379
380 static void lua_script_free(lua_script_t *script) /* {{{ */
381 {
382   if (script == NULL)
383     return;
384
385   lua_script_t *next = script->next;
386
387   if (script->lua_state != NULL) {
388     lua_close(script->lua_state);
389     script->lua_state = NULL;
390   }
391
392   sfree(script->script_path);
393   sfree(script);
394
395   lua_script_free(next);
396 } /* }}} void lua_script_free */
397
398 static int lua_script_init(lua_script_t *script) /* {{{ */
399 {
400   memset(script, 0, sizeof(*script));
401
402   /* initialize the lua context */
403   script->lua_state = luaL_newstate();
404   if (script->lua_state == NULL) {
405     ERROR("Lua plugin: luaL_newstate() failed.");
406     return -1;
407   }
408
409   /* Open up all the standard Lua libraries. */
410   luaL_openlibs(script->lua_state);
411
412 /* Load the 'collectd' library */
413 #if LUA_VERSION_NUM < 502
414   lua_pushcfunction(script->lua_state, open_collectd);
415   lua_pushstring(script->lua_state, "collectd");
416   lua_call(script->lua_state, 1, 0);
417 #else
418   luaL_requiref(script->lua_state, "collectd", open_collectd, 1);
419   lua_pop(script->lua_state, 1);
420 #endif
421
422   /* Prepend BasePath to package.path */
423   if (base_path[0] != '\0') {
424     lua_getglobal(script->lua_state, "package");
425     lua_getfield(script->lua_state, -1, "path");
426
427     const char *cur_path = lua_tostring(script->lua_state, -1);
428     char *new_path = ssnprintf_alloc("%s/?.lua;%s", base_path, cur_path);
429
430     lua_pop(script->lua_state, 1);
431     lua_pushstring(script->lua_state, new_path);
432
433     free(new_path);
434
435     lua_setfield(script->lua_state, -2, "path");
436     lua_pop(script->lua_state, 1);
437   }
438
439   return 0;
440 } /* }}} int lua_script_init */
441
442 static int lua_script_load(const char *script_path) /* {{{ */
443 {
444   lua_script_t *script = malloc(sizeof(*script));
445   if (script == NULL) {
446     ERROR("Lua plugin: malloc failed.");
447     return -1;
448   }
449
450   int status = lua_script_init(script);
451   if (status != 0) {
452     lua_script_free(script);
453     return status;
454   }
455
456   script->script_path = strdup(script_path);
457   if (script->script_path == NULL) {
458     ERROR("Lua plugin: strdup failed.");
459     lua_script_free(script);
460     return -1;
461   }
462
463   status = luaL_loadfile(script->lua_state, script->script_path);
464   if (status != 0) {
465     ERROR("Lua plugin: luaL_loadfile failed: %s",
466           lua_tostring(script->lua_state, -1));
467     lua_pop(script->lua_state, 1);
468     lua_script_free(script);
469     return -1;
470   }
471
472   status = lua_pcall(script->lua_state,
473                      /* nargs = */ 0,
474                      /* nresults = */ LUA_MULTRET,
475                      /* errfunc = */ 0);
476   if (status != 0) {
477     const char *errmsg = lua_tostring(script->lua_state, -1);
478
479     if (errmsg == NULL)
480       ERROR("Lua plugin: lua_pcall failed with status %i. "
481             "In addition, no error message could be retrieved from the stack.",
482             status);
483     else
484       ERROR("Lua plugin: Executing script \"%s\" failed:\n%s",
485             script->script_path, errmsg);
486
487     lua_script_free(script);
488     return -1;
489   }
490
491   /* Append this script to the global list of scripts. */
492   if (scripts) {
493     lua_script_t *last = scripts;
494     while (last->next)
495       last = last->next;
496
497     last->next = script;
498   } else {
499     scripts = script;
500   }
501
502   return 0;
503 } /* }}} int lua_script_load */
504
505 static int lua_config_base_path(const oconfig_item_t *ci) /* {{{ */
506 {
507   int status = cf_util_get_string_buffer(ci, base_path, sizeof(base_path));
508   if (status != 0)
509     return status;
510
511   size_t len = strlen(base_path);
512   while ((len > 0) && (base_path[len - 1] == '/')) {
513     len--;
514     base_path[len] = '\0';
515   }
516
517   DEBUG("Lua plugin: base_path = \"%s\";", base_path);
518
519   return 0;
520 } /* }}} int lua_config_base_path */
521
522 static int lua_config_script(const oconfig_item_t *ci) /* {{{ */
523 {
524   char rel_path[PATH_MAX];
525
526   int status = cf_util_get_string_buffer(ci, rel_path, sizeof(rel_path));
527   if (status != 0)
528     return status;
529
530   char abs_path[PATH_MAX];
531
532   if (base_path[0] == '\0')
533     sstrncpy(abs_path, rel_path, sizeof(abs_path));
534   else
535     snprintf(abs_path, sizeof(abs_path), "%s/%s", base_path, rel_path);
536
537   DEBUG("Lua plugin: abs_path = \"%s\";", abs_path);
538
539   status = lua_script_load(abs_path);
540   if (status != 0)
541     return status;
542
543   INFO("Lua plugin: File \"%s\" loaded successfully", abs_path);
544
545   return 0;
546 } /* }}} int lua_config_script */
547
548 /*
549  * <Plugin lua>
550  *   BasePath "/"
551  *   Script "script1.lua"
552  *   Script "script2.lua"
553  * </Plugin>
554  */
555 static int lua_config(oconfig_item_t *ci) /* {{{ */
556 {
557   int status = 0;
558   for (int i = 0; i < ci->children_num; i++) {
559     oconfig_item_t *child = ci->children + i;
560
561     if (strcasecmp("BasePath", child->key) == 0) {
562       status = lua_config_base_path(child);
563     } else if (strcasecmp("Script", child->key) == 0) {
564       status = lua_config_script(child);
565     } else {
566       ERROR("Lua plugin: Option `%s' is not allowed here.", child->key);
567       status = 1;
568     }
569   }
570
571   return status;
572 } /* }}} int lua_config */
573
574 static int lua_shutdown(void) /* {{{ */
575 {
576   lua_script_free(scripts);
577
578   return 0;
579 } /* }}} int lua_shutdown */
580
581 void module_register(void) {
582   plugin_register_complex_config("lua", lua_config);
583   plugin_register_shutdown("lua", lua_shutdown);
584 }