freeipmi_plugin.c · cryptotaxi247/netdata-1

Code Commits Issues Pulls Sessions CI/CD

master

c 2,126 lines 82.4 KB

Raw

1	// SPDX-License-Identifier: GPL-3.0-or-later
2	/*
3	* Based on:
4	* ipmimonitoring-sensors.c,v 1.51 2016/11/02 23:46:24 chu11 Exp
5	* ipmimonitoring-sel.c,v 1.51 2016/11/02 23:46:24 chu11 Exp
6	*
7	* Copyright (C) 2007-2015 Lawrence Livermore National Security, LLC.
8	* Copyright (C) 2006-2007 The Regents of the University of California.
9	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
10	* Written by Albert Chu <chu11@llnl.gov>
11	* UCRL-CODE-222073
12	*/
13
14	// ----------------------------------------------------------------------------
15	// BEGIN NETDATA CODE
16
17	// #define NETDATA_TIMING_REPORT 1
18	#include "libnetdata/libnetdata.h"
19
20	#define FREEIPMI_GLOBAL_FUNCTION_SENSORS() do { \
21	fprintf(stdout, PLUGINSD_KEYWORD_FUNCTION " GLOBAL \"ipmi-sensors\" %d \"%s\" \"top\" "HTTP_ACCESS_FORMAT" %d\n", \
22	5, "Shows IPMI hardware sensor readings including temperatures, voltages, fan speeds, and component health status.", \
23	(HTTP_ACCESS_FORMAT_CAST)(HTTP_ACCESS_NONE), 100); \
24	} while(0)
25
26	// component names, based on our patterns
27	#define NETDATA_SENSOR_COMPONENT_MEMORY_MODULE "Memory Module"
28	#define NETDATA_SENSOR_COMPONENT_MEMORY "Memory"
29	#define NETDATA_SENSOR_COMPONENT_PROCESSOR "Processor"
30	#define NETDATA_SENSOR_COMPONENT_IPU "Image Processor"
31	#define NETDATA_SENSOR_COMPONENT_STORAGE "Storage"
32	#define NETDATA_SENSOR_COMPONENT_MOTHERBOARD "Motherboard"
33	#define NETDATA_SENSOR_COMPONENT_NETWORK "Network"
34	#define NETDATA_SENSOR_COMPONENT_POWER_SUPPLY "Power Supply"
35	#define NETDATA_SENSOR_COMPONENT_SYSTEM "System"
36	#define NETDATA_SENSOR_COMPONENT_PERIPHERAL "Peripheral"
37
38	// netdata plugin defaults
39	#define SENSORS_DICT_KEY_SIZE 2048 // the max size of the key for the dictionary of sensors
40	#define SPEED_TEST_ITERATIONS 5 // how many times to repeat data collection to decide latency
41	#define IPMI_SENSORS_DASHBOARD_PRIORITY 90000 // the priority of the sensors charts on the dashboard
42	#define IPMI_SEL_DASHBOARD_PRIORITY 99000 // the priority of the SEL events chart on the dashboard
43	#define IPMI_SENSORS_MIN_UPDATE_EVERY 5 // the minimum data collection frequency for sensors
44	#define IPMI_SEL_MIN_UPDATE_EVERY 30 // the minimum data collection frequency for SEL events
45	#define IPMI_ENABLE_SEL_BY_DEFAULT true // true/false, to enable/disable SEL by default
46	#define IPMI_RESTART_EVERY_SECONDS 14400 // restart the plugin every this many seconds
47	// this is to prevent possible bugs/leaks in ipmi libraries
48	#define IPMI_RESTART_IF_SENSORS_DONT_ITERATE_EVERY_SECONDS (10 * 60) // stale data collection detection time
49
50	// forward definition of functions and structures
51	struct netdata_ipmi_state;
52	static void netdata_update_ipmi_sensor_reading(
53	int record_id
54	, int sensor_number
55	, int sensor_type
56	, int sensor_state
57	, int sensor_units
58	, int sensor_reading_type
59	, char *sensor_name
60	, void *sensor_reading
61	, int event_reading_type_code
62	, int sensor_bitmask_type
63	, int sensor_bitmask
64	, char **sensor_bitmask_strings
65	, struct netdata_ipmi_state *stt);
66	static void netdata_update_ipmi_sel_events_count(struct netdata_ipmi_state *stt, uint32_t events);
67
68	// END NETDATA CODE
69	// ----------------------------------------------------------------------------
70
71	#include <stdio.h>
72	#include <stdlib.h>
73	#include <stdint.h>
74	#include <string.h>
75	#include <assert.h>
76	#include <errno.h>
77	#include <unistd.h>
78	#include <sys/time.h>
79
80	#include <ipmi_monitoring.h>
81	#include <ipmi_monitoring_bitmasks.h>
82	#include <ipmi_monitoring_offsets.h>
83
84	/* Communication Configuration - Initialize accordingly */
85
86	static netdata_mutex_t stdout_mutex;
87
88	static void __attribute__((constructor)) init_mutex(void) {
89	netdata_mutex_init(&stdout_mutex);
90	}
91
92	static void __attribute__((destructor)) destroy_mutex(void) {
93	netdata_mutex_destroy(&stdout_mutex);
94	}
95
96	static bool function_plugin_should_exit = false;
97
98	int update_every = IPMI_SENSORS_MIN_UPDATE_EVERY; // this is the minimum update frequency
99	int update_every_sel = IPMI_SEL_MIN_UPDATE_EVERY; // this is the minimum update frequency for SEL events
100
101	/* Hostname, NULL for In-band communication, non-null for a hostname */
102	char *hostname = NULL;
103
104	/* In-band Communication Configuration */
105	int driver_type = -1; // IPMI_MONITORING_DRIVER_TYPE_KCS, etc. or -1 for default
106	int disable_auto_probe = 0; /* probe for in-band device */
107	unsigned int driver_address = 0; /* not used if probing */
108	unsigned int register_spacing = 0; /* not used if probing */
109	char driver_device = NULL; / not used if probing */
110
111	/* Out-of-band Communication Configuration */
112	int freeimpi_protocol_version = -1; // IPMI_MONITORING_PROTOCOL_VERSION_1_5, etc. or -1 for default
113	char *username = "";
114	char *password = "";
115	unsigned char *k_g = NULL;
116	unsigned int k_g_len = 0;
117	int privilege_level = -1; // IPMI_MONITORING_PRIVILEGE_LEVEL_USER, etc. or -1 for default
118	int authentication_type = -1; // IPMI_MONITORING_AUTHENTICATION_TYPE_MD5, etc. or -1 for default
119	int cipher_suite_id = -1; /* 0 or -1 for default */
120	int session_timeout = 0; /* 0 for default */
121	int retransmission_timeout = 0; /* 0 for default */
122
123	/* Workarounds - specify workaround flags if necessary */
124	unsigned int workaround_flags = 0;
125
126	/* Set to an appropriate alternate if desired */
127	char *sdr_cache_directory = "/tmp";
128	char *sdr_sensors_cache_format = ".netdata-freeipmi-sensors-%H-on-%L.sdr";
129	char *sdr_sel_cache_format = ".netdata-freeipmi-sel-%H-on-%L.sdr";
130	char *sensor_config_file = NULL;
131	char *sel_config_file = NULL;
132
133	// controlled via command line options
134	unsigned int global_sel_flags = IPMI_MONITORING_SEL_FLAGS_REREAD_SDR_CACHE;
135	unsigned int global_sensor_reading_flags = IPMI_MONITORING_SENSOR_READING_FLAGS_DISCRETE_READING\|IPMI_MONITORING_SENSOR_READING_FLAGS_REREAD_SDR_CACHE;
136	bool remove_reread_sdr_after_first_use = true;
137
138	/* Initialization flags
139	*
140	* Most commonly bitwise OR IPMI_MONITORING_FLAGS_DEBUG and/or
141	* IPMI_MONITORING_FLAGS_DEBUG_IPMI_PACKETS for extra debugging
142	* information.
143	*/
144	unsigned int ipmimonitoring_init_flags = 0;
145
146	// ----------------------------------------------------------------------------
147	// functions common to sensors and SEL
148
149	static void initialize_ipmi_config (struct ipmi_monitoring_ipmi_config *ipmi_config) {
150	fatal_assert(ipmi_config);
151
152	ipmi_config->driver_type = driver_type;
153	ipmi_config->disable_auto_probe = disable_auto_probe;
154	ipmi_config->driver_address = driver_address;
155	ipmi_config->register_spacing = register_spacing;
156	ipmi_config->driver_device = driver_device;
157
158	ipmi_config->protocol_version = freeimpi_protocol_version;
159	ipmi_config->username = username;
160	ipmi_config->password = password;
161	ipmi_config->k_g = k_g;
162	ipmi_config->k_g_len = k_g_len;
163	ipmi_config->privilege_level = privilege_level;
164	ipmi_config->authentication_type = authentication_type;
165	ipmi_config->cipher_suite_id = cipher_suite_id;
166	ipmi_config->session_timeout_len = session_timeout;
167	ipmi_config->retransmission_timeout_len = retransmission_timeout;
168
169	ipmi_config->workaround_flags = workaround_flags;
170	}
171
172	static const char netdata_ipmi_get_sensor_type_string (int sensor_type, const char *component) {
173	switch (sensor_type) {
174	case IPMI_MONITORING_SENSOR_TYPE_RESERVED:
175	return ("Reserved");
176
177	case IPMI_MONITORING_SENSOR_TYPE_TEMPERATURE:
178	return ("Temperature");
179
180	case IPMI_MONITORING_SENSOR_TYPE_VOLTAGE:
181	return ("Voltage");
182
183	case IPMI_MONITORING_SENSOR_TYPE_CURRENT:
184	return ("Current");
185
186	case IPMI_MONITORING_SENSOR_TYPE_FAN:
187	return ("Fan");
188
189	case IPMI_MONITORING_SENSOR_TYPE_PHYSICAL_SECURITY:
190	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
191	return ("Physical Security");
192
193	case IPMI_MONITORING_SENSOR_TYPE_PLATFORM_SECURITY_VIOLATION_ATTEMPT:
194	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
195	return ("Platform Security Violation Attempt");
196
197	case IPMI_MONITORING_SENSOR_TYPE_PROCESSOR:
198	*component = NETDATA_SENSOR_COMPONENT_PROCESSOR;
199	return ("Processor");
200
201	case IPMI_MONITORING_SENSOR_TYPE_POWER_SUPPLY:
202	*component = NETDATA_SENSOR_COMPONENT_POWER_SUPPLY;
203	return ("Power Supply");
204
205	case IPMI_MONITORING_SENSOR_TYPE_POWER_UNIT:
206	*component = NETDATA_SENSOR_COMPONENT_POWER_SUPPLY;
207	return ("Power Unit");
208
209	case IPMI_MONITORING_SENSOR_TYPE_COOLING_DEVICE:
210	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
211	return ("Cooling Device");
212
213	case IPMI_MONITORING_SENSOR_TYPE_OTHER_UNITS_BASED_SENSOR:
214	return ("Other Units Based Sensor");
215
216	case IPMI_MONITORING_SENSOR_TYPE_MEMORY:
217	*component = NETDATA_SENSOR_COMPONENT_MEMORY;
218	return ("Memory");
219
220	case IPMI_MONITORING_SENSOR_TYPE_DRIVE_SLOT:
221	*component = NETDATA_SENSOR_COMPONENT_STORAGE;
222	return ("Drive Slot");
223
224	case IPMI_MONITORING_SENSOR_TYPE_POST_MEMORY_RESIZE:
225	*component = NETDATA_SENSOR_COMPONENT_MEMORY;
226	return ("POST Memory Resize");
227
228	case IPMI_MONITORING_SENSOR_TYPE_SYSTEM_FIRMWARE_PROGRESS:
229	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
230	return ("System Firmware Progress");
231
232	case IPMI_MONITORING_SENSOR_TYPE_EVENT_LOGGING_DISABLED:
233	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
234	return ("Event Logging Disabled");
235
236	case IPMI_MONITORING_SENSOR_TYPE_WATCHDOG1:
237	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
238	return ("Watchdog 1");
239
240	case IPMI_MONITORING_SENSOR_TYPE_SYSTEM_EVENT:
241	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
242	return ("System Event");
243
244	case IPMI_MONITORING_SENSOR_TYPE_CRITICAL_INTERRUPT:
245	return ("Critical Interrupt");
246
247	case IPMI_MONITORING_SENSOR_TYPE_BUTTON_SWITCH:
248	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
249	return ("Button/Switch");
250
251	case IPMI_MONITORING_SENSOR_TYPE_MODULE_BOARD:
252	return ("Module/Board");
253
254	case IPMI_MONITORING_SENSOR_TYPE_MICROCONTROLLER_COPROCESSOR:
255	*component = NETDATA_SENSOR_COMPONENT_PROCESSOR;
256	return ("Microcontroller/Coprocessor");
257
258	case IPMI_MONITORING_SENSOR_TYPE_ADD_IN_CARD:
259	return ("Add In Card");
260
261	case IPMI_MONITORING_SENSOR_TYPE_CHASSIS:
262	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
263	return ("Chassis");
264
265	case IPMI_MONITORING_SENSOR_TYPE_CHIP_SET:
266	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
267	return ("Chip Set");
268
269	case IPMI_MONITORING_SENSOR_TYPE_OTHER_FRU:
270	return ("Other Fru");
271
272	case IPMI_MONITORING_SENSOR_TYPE_CABLE_INTERCONNECT:
273	return ("Cable/Interconnect");
274
275	case IPMI_MONITORING_SENSOR_TYPE_TERMINATOR:
276	return ("Terminator");
277
278	case IPMI_MONITORING_SENSOR_TYPE_SYSTEM_BOOT_INITIATED:
279	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
280	return ("System Boot Initiated");
281
282	case IPMI_MONITORING_SENSOR_TYPE_BOOT_ERROR:
283	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
284	return ("Boot Error");
285
286	case IPMI_MONITORING_SENSOR_TYPE_OS_BOOT:
287	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
288	return ("OS Boot");
289
290	case IPMI_MONITORING_SENSOR_TYPE_OS_CRITICAL_STOP:
291	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
292	return ("OS Critical Stop");
293
294	case IPMI_MONITORING_SENSOR_TYPE_SLOT_CONNECTOR:
295	return ("Slot/Connector");
296
297	case IPMI_MONITORING_SENSOR_TYPE_SYSTEM_ACPI_POWER_STATE:
298	return ("System ACPI Power State");
299
300	case IPMI_MONITORING_SENSOR_TYPE_WATCHDOG2:
301	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
302	return ("Watchdog 2");
303
304	case IPMI_MONITORING_SENSOR_TYPE_PLATFORM_ALERT:
305	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
306	return ("Platform Alert");
307
308	case IPMI_MONITORING_SENSOR_TYPE_ENTITY_PRESENCE:
309	return ("Entity Presence");
310
311	case IPMI_MONITORING_SENSOR_TYPE_MONITOR_ASIC_IC:
312	return ("Monitor ASIC/IC");
313
314	case IPMI_MONITORING_SENSOR_TYPE_LAN:
315	*component = NETDATA_SENSOR_COMPONENT_NETWORK;
316	return ("LAN");
317
318	case IPMI_MONITORING_SENSOR_TYPE_MANAGEMENT_SUBSYSTEM_HEALTH:
319	*component = NETDATA_SENSOR_COMPONENT_SYSTEM;
320	return ("Management Subsystem Health");
321
322	case IPMI_MONITORING_SENSOR_TYPE_BATTERY:
323	return ("Battery");
324
325	case IPMI_MONITORING_SENSOR_TYPE_SESSION_AUDIT:
326	return ("Session Audit");
327
328	case IPMI_MONITORING_SENSOR_TYPE_VERSION_CHANGE:
329	return ("Version Change");
330
331	case IPMI_MONITORING_SENSOR_TYPE_FRU_STATE:
332	return ("FRU State");
333
334	case IPMI_MONITORING_SENSOR_TYPE_UNKNOWN:
335	return ("Unknown");
336
337	default:
338	if(sensor_type >= IPMI_MONITORING_SENSOR_TYPE_OEM_MIN && sensor_type <= IPMI_MONITORING_SENSOR_TYPE_OEM_MAX)
339	return ("OEM");
340
341	return ("Unrecognized");
342	}
343	}
344
345	#define netdata_ipmi_get_value_int(var, func, ctx) do { \
346	(var) = func(ctx); \
347	if( (var) < 0) { \
348	collector_error("%s(): call to " #func " failed: %s", \
349	__FUNCTION__, ipmi_monitoring_ctx_errormsg(ctx)); \
350	goto cleanup; \
351	} \
352	timing_step(TIMING_STEP_FREEIPMI_READ_ ## var); \
353	} while(0)
354
355	#define netdata_ipmi_get_value_ptr(var, func, ctx) do { \
356	(var) = func(ctx); \
357	if(!(var)) { \
358	collector_error("%s(): call to " #func " failed: %s", \
359	__FUNCTION__, ipmi_monitoring_ctx_errormsg(ctx)); \
360	goto cleanup; \
361	} \
362	timing_step(TIMING_STEP_FREEIPMI_READ_ ## var); \
363	} while(0)
364
365	#define netdata_ipmi_get_value_no_check(var, func, ctx) do { \
366	(var) = func(ctx); \
367	timing_step(TIMING_STEP_FREEIPMI_READ_ ## var); \
368	} while(0)
369
370	static int netdata_read_ipmi_sensors(struct ipmi_monitoring_ipmi_config ipmi_config, struct netdata_ipmi_state state) {
371	timing_init();
372
373	ipmi_monitoring_ctx_t ctx = NULL;
374	unsigned int sensor_reading_flags = global_sensor_reading_flags;
375	int i;
376	int sensor_count;
377	int rv = -1;
378
379	if (!(ctx = ipmi_monitoring_ctx_create ())) {
380	collector_error("ipmi_monitoring_ctx_create()");
381	goto cleanup;
382	}
383
384	timing_step(TIMING_STEP_FREEIPMI_CTX_CREATE);
385
386	if (sdr_cache_directory) {
387	if (ipmi_monitoring_ctx_sdr_cache_directory (ctx, sdr_cache_directory) < 0) {
388	collector_error("ipmi_monitoring_ctx_sdr_cache_directory(): %s\n", ipmi_monitoring_ctx_errormsg (ctx));
389	goto cleanup;
390	}
391	}
392	if (sdr_sensors_cache_format) {
393	if (ipmi_monitoring_ctx_sdr_cache_filenames(ctx, sdr_sensors_cache_format) < 0) {
394	collector_error("ipmi_monitoring_ctx_sdr_cache_filenames(): %s\n", ipmi_monitoring_ctx_errormsg (ctx));
395	goto cleanup;
396	}
397	}
398
399	timing_step(TIMING_STEP_FREEIPMI_DSR_CACHE_DIR);
400
401	// Must call otherwise only default interpretations ever used
402	// sensor_config_file can be NULL
403	if (ipmi_monitoring_ctx_sensor_config_file (ctx, sensor_config_file) < 0) {
404	collector_error( "ipmi_monitoring_ctx_sensor_config_file(): %s\n", ipmi_monitoring_ctx_errormsg (ctx));
405	goto cleanup;
406	}
407
408	timing_step(TIMING_STEP_FREEIPMI_SENSOR_CONFIG_FILE);
409
410	if ((sensor_count = ipmi_monitoring_sensor_readings_by_record_id (ctx,
411	hostname,
412	ipmi_config,
413	sensor_reading_flags,
414	NULL,
415	0,
416	NULL,
417	NULL)) < 0) {
418	collector_error( "ipmi_monitoring_sensor_readings_by_record_id(): %s",
419	ipmi_monitoring_ctx_errormsg (ctx));
420	goto cleanup;
421	}
422
423	timing_step(TIMING_STEP_FREEIPMI_SENSOR_READINGS_BY_X);
424
425	for (i = 0; i < sensor_count; i++, ipmi_monitoring_sensor_iterator_next (ctx)) {
426	int record_id, sensor_number, sensor_type, sensor_state, sensor_units,
427	sensor_bitmask_type, sensor_bitmask, event_reading_type_code, sensor_reading_type;
428
429	char **sensor_bitmask_strings = NULL;
430	char *sensor_name = NULL;
431	void *sensor_reading;
432
433	netdata_ipmi_get_value_int(record_id, ipmi_monitoring_sensor_read_record_id, ctx);
434	netdata_ipmi_get_value_int(sensor_number, ipmi_monitoring_sensor_read_sensor_number, ctx);
435	netdata_ipmi_get_value_int(sensor_type, ipmi_monitoring_sensor_read_sensor_type, ctx);
436	netdata_ipmi_get_value_ptr(sensor_name, ipmi_monitoring_sensor_read_sensor_name, ctx);
437	netdata_ipmi_get_value_int(sensor_state, ipmi_monitoring_sensor_read_sensor_state, ctx);
438	netdata_ipmi_get_value_int(sensor_units, ipmi_monitoring_sensor_read_sensor_units, ctx);
439	netdata_ipmi_get_value_int(sensor_bitmask_type, ipmi_monitoring_sensor_read_sensor_bitmask_type, ctx);
440	netdata_ipmi_get_value_int(sensor_bitmask, ipmi_monitoring_sensor_read_sensor_bitmask, ctx);
441	// it's ok for this to be NULL, i.e. sensor_bitmask == IPMI_MONITORING_SENSOR_BITMASK_TYPE_UNKNOWN
442	netdata_ipmi_get_value_no_check(sensor_bitmask_strings, ipmi_monitoring_sensor_read_sensor_bitmask_strings, ctx);
443	netdata_ipmi_get_value_int(sensor_reading_type, ipmi_monitoring_sensor_read_sensor_reading_type, ctx);
444	// whatever we read from the sensor, it is ok
445	netdata_ipmi_get_value_no_check(sensor_reading, ipmi_monitoring_sensor_read_sensor_reading, ctx);
446	netdata_ipmi_get_value_int(event_reading_type_code, ipmi_monitoring_sensor_read_event_reading_type_code, ctx);
447
448	netdata_update_ipmi_sensor_reading(
449	record_id, sensor_number, sensor_type, sensor_state, sensor_units, sensor_reading_type, sensor_name,
450	sensor_reading, event_reading_type_code, sensor_bitmask_type, sensor_bitmask, sensor_bitmask_strings,
451	state
452	);
453
454	#ifdef NETDATA_COMMENTED
455	/* It is possible you may want to monitor specific event
456	* conditions that may occur. If that is the case, you may want
457	* to check out what specific bitmask type and bitmask events
458	* occurred. See ipmi_monitoring_bitmasks.h for a list of
459	* bitmasks and types.
460	*/
461
462	if (sensor_bitmask_type != IPMI_MONITORING_SENSOR_BITMASK_TYPE_UNKNOWN)
463	printf (", %Xh", sensor_bitmask);
464	else
465	printf (", N/A");
466
467	if (sensor_bitmask_type != IPMI_MONITORING_SENSOR_BITMASK_TYPE_UNKNOWN
468	&& sensor_bitmask_strings)
469	{
470	unsigned int i = 0;
471
472	printf (",");
473
474	while (sensor_bitmask_strings[i])
475	{
476	printf (" ");
477
478	printf ("'%s'",
479	sensor_bitmask_strings[i]);
480
481	i++;
482	}
483	}
484	else
485	printf (", N/A");
486
487	printf ("\n");
488	#endif // NETDATA_COMMENTED
489	}
490
491	rv = 0;
492
493	cleanup:
494	if (ctx)
495	ipmi_monitoring_ctx_destroy (ctx);
496
497	timing_report();
498
499	if(remove_reread_sdr_after_first_use)
500	global_sensor_reading_flags &= ~(IPMI_MONITORING_SENSOR_READING_FLAGS_REREAD_SDR_CACHE);
501
502	return (rv);
503	}
504
505
506	static int netdata_get_ipmi_sel_events_count(struct ipmi_monitoring_ipmi_config ipmi_config, struct netdata_ipmi_state state) {
507	timing_init();
508
509	ipmi_monitoring_ctx_t ctx = NULL;
510	unsigned int sel_flags = global_sel_flags;
511	int sel_count;
512	int rv = -1;
513
514	if (!(ctx = ipmi_monitoring_ctx_create ())) {
515	collector_error("ipmi_monitoring_ctx_create()");
516	goto cleanup;
517	}
518
519	if (sdr_cache_directory) {
520	if (ipmi_monitoring_ctx_sdr_cache_directory (ctx, sdr_cache_directory) < 0) {
521	collector_error( "ipmi_monitoring_ctx_sdr_cache_directory(): %s", ipmi_monitoring_ctx_errormsg (ctx));
522	goto cleanup;
523	}
524	}
525	if (sdr_sel_cache_format) {
526	if (ipmi_monitoring_ctx_sdr_cache_filenames(ctx, sdr_sel_cache_format) < 0) {
527	collector_error("ipmi_monitoring_ctx_sdr_cache_filenames(): %s\n", ipmi_monitoring_ctx_errormsg (ctx));
528	goto cleanup;
529	}
530	}
531
532	// Must call otherwise only default interpretations ever used
533	// sel_config_file can be NULL
534	if (ipmi_monitoring_ctx_sel_config_file (ctx, sel_config_file) < 0) {
535	collector_error( "ipmi_monitoring_ctx_sel_config_file(): %s",
536	ipmi_monitoring_ctx_errormsg (ctx));
537	goto cleanup;
538	}
539
540	if ((sel_count = ipmi_monitoring_sel_by_record_id (ctx,
541	hostname,
542	ipmi_config,
543	sel_flags,
544	NULL,
545	0,
546	NULL,
547	NULL)) < 0) {
548	collector_error( "ipmi_monitoring_sel_by_record_id(): %s",
549	ipmi_monitoring_ctx_errormsg (ctx));
550	goto cleanup;
551	}
552
553	netdata_update_ipmi_sel_events_count(state, sel_count);
554
555	rv = 0;
556
557	cleanup:
558	if (ctx)
559	ipmi_monitoring_ctx_destroy (ctx);
560
561	timing_report();
562
563	if(remove_reread_sdr_after_first_use)
564	global_sel_flags &= ~(IPMI_MONITORING_SEL_FLAGS_REREAD_SDR_CACHE);
565
566	return (rv);
567	}
568
569	// ----------------------------------------------------------------------------
570	// copied from freeipmi codebase commit 8dea6dec4012d0899901e595f2c868a05e1cefed
571	// added netdata_ in-front to not overwrite library functions
572
573	// FROM: common/miscutil/network.c
574	static int netdata_host_is_localhost (const char *host) {
575	/* Ordered by my assumption of most popular */
576	if (!strcasecmp (host, "localhost")
577	\|\| !strcmp (host, "127.0.0.1")
578	\|\| !strcasecmp (host, "ipv6-localhost")
579	\|\| !strcmp (host, "::1")
580	\|\| !strcasecmp (host, "ip6-localhost")
581	\|\| !strcmp (host, "0:0:0:0:0:0:0:1"))
582	return (1);
583
584	return (0);
585	}
586
587	// FROM: common/parsecommon/parse-common.h
588	#define IPMI_PARSE_DEVICE_LAN_STR "lan"
589	#define IPMI_PARSE_DEVICE_LAN_2_0_STR "lan_2_0"
590	#define IPMI_PARSE_DEVICE_LAN_2_0_STR2 "lan20"
591	#define IPMI_PARSE_DEVICE_LAN_2_0_STR3 "lan_20"
592	#define IPMI_PARSE_DEVICE_LAN_2_0_STR4 "lan2_0"
593	#define IPMI_PARSE_DEVICE_LAN_2_0_STR5 "lanplus"
594	#define IPMI_PARSE_DEVICE_KCS_STR "kcs"
595	#define IPMI_PARSE_DEVICE_SSIF_STR "ssif"
596	#define IPMI_PARSE_DEVICE_OPENIPMI_STR "openipmi"
597	#define IPMI_PARSE_DEVICE_OPENIPMI_STR2 "open"
598	#define IPMI_PARSE_DEVICE_SUNBMC_STR "sunbmc"
599	#define IPMI_PARSE_DEVICE_SUNBMC_STR2 "bmc"
600	#define IPMI_PARSE_DEVICE_INTELDCMI_STR "inteldcmi"
601
602	// FROM: common/parsecommon/parse-common.c
603	// changed the return values to match ipmi_monitoring.h
604	static int netdata_parse_outofband_driver_type (const char *str) {
605	if (strcasecmp (str, IPMI_PARSE_DEVICE_LAN_STR) == 0)
606	return (IPMI_MONITORING_PROTOCOL_VERSION_1_5);
607
608	/* support "lanplus" for those that might be used to ipmitool.
609	* support typo variants to ease.
610	*/
611	else if (strcasecmp (str, IPMI_PARSE_DEVICE_LAN_2_0_STR) == 0
612	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_LAN_2_0_STR2) == 0
613	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_LAN_2_0_STR3) == 0
614	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_LAN_2_0_STR4) == 0
615	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_LAN_2_0_STR5) == 0)
616	return (IPMI_MONITORING_PROTOCOL_VERSION_2_0);
617
618	return (-1);
619	}
620
621	// FROM: common/parsecommon/parse-common.c
622	// changed the return values to match ipmi_monitoring.h
623	static int netdata_parse_inband_driver_type (const char *str) {
624	if (strcasecmp (str, IPMI_PARSE_DEVICE_KCS_STR) == 0)
625	return (IPMI_MONITORING_DRIVER_TYPE_KCS);
626	else if (strcasecmp (str, IPMI_PARSE_DEVICE_SSIF_STR) == 0)
627	return (IPMI_MONITORING_DRIVER_TYPE_SSIF);
628	/* support "open" for those that might be used to
629	* ipmitool.
630	*/
631	else if (strcasecmp (str, IPMI_PARSE_DEVICE_OPENIPMI_STR) == 0
632	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_OPENIPMI_STR2) == 0)
633	return (IPMI_MONITORING_DRIVER_TYPE_OPENIPMI);
634	/* support "bmc" for those that might be used to
635	* ipmitool.
636	*/
637	else if (strcasecmp (str, IPMI_PARSE_DEVICE_SUNBMC_STR) == 0
638	\|\| strcasecmp (str, IPMI_PARSE_DEVICE_SUNBMC_STR2) == 0)
639	return (IPMI_MONITORING_DRIVER_TYPE_SUNBMC);
640
641	#ifdef IPMI_MONITORING_DRIVER_TYPE_INTELDCMI
642	else if (strcasecmp (str, IPMI_PARSE_DEVICE_INTELDCMI_STR) == 0)
643	return (IPMI_MONITORING_DRIVER_TYPE_INTELDCMI);
644	#endif // IPMI_MONITORING_DRIVER_TYPE_INTELDCMI
645
646	return (-1);
647	}
648
649	// ----------------------------------------------------------------------------
650	// BEGIN NETDATA CODE
651
652	typedef enum __attribute__((packed)) {
653	IPMI_COLLECT_TYPE_SENSORS = (1 << 0),
654	IPMI_COLLECT_TYPE_SEL = (1 << 1),
655	} IPMI_COLLECTION_TYPE;
656
657	struct sensor {
658	int sensor_type;
659	int sensor_state;
660	int sensor_units;
661	char *sensor_name;
662
663	int sensor_reading_type;
664	union {
665	uint8_t bool_value;
666	uint32_t uint32_value;
667	double double_value;
668	} sensor_reading;
669
670	// netdata provided
671	const char *context;
672	const char *title;
673	const char *units;
674	const char *family;
675	const char *chart_type;
676	const char *dimension;
677	int priority;
678
679	const char *type;
680	const char *component;
681
682	int multiplier;
683	bool do_metric;
684	bool do_state;
685	bool metric_chart_sent;
686	bool state_chart_sent;
687	usec_t last_collected_metric_ut;
688	usec_t last_collected_state_ut;
689	};
690
691	typedef enum __attribute__((packed)) {
692	ICS_INIT,
693	ICS_INIT_FAILED,
694	ICS_RUNNING,
695	ICS_FAILED,
696	} IPMI_COLLECTOR_STATUS;
697
698	struct netdata_ipmi_state {
699	bool debug;
700
701	struct {
702	IPMI_COLLECTOR_STATUS status;
703	usec_t last_iteration_ut;
704	size_t collected;
705	usec_t now_ut;
706	usec_t freq_ut;
707	int priority;
708	DICTIONARY *dict;
709	} sensors;
710
711	struct {
712	IPMI_COLLECTOR_STATUS status;
713	usec_t last_iteration_ut;
714	size_t events;
715	usec_t now_ut;
716	usec_t freq_ut;
717	int priority;
718	} sel;
719
720	struct {
721	usec_t now_ut;
722	} updates;
723	};
724
725	struct netdata_ipmi_state state = {0};
726
727	// ----------------------------------------------------------------------------
728	// excluded record ids maintenance (both for sensor data and state)
729
730	static int *excluded_record_ids = NULL;
731	size_t excluded_record_ids_length = 0;
732
733	static void excluded_record_ids_parse(const char *s, bool debug) {
734	if(!s) return;
735
736	while(*s) {
737	while(s && !isdigit(s)) s++;
738
739	if(isdigit(*s)) {
740	char *e;
741	unsigned long n = strtoul(s, &e, 10);
742	s = e;
743
744	if(n != 0) {
745	excluded_record_ids = reallocz(excluded_record_ids, (excluded_record_ids_length + 1) * sizeof(int));
746	excluded_record_ids[excluded_record_ids_length++] = (int)n;
747	}
748	}
749	}
750
751	if(debug) {
752	fprintf(stderr, "%s: excluded record ids:", program_name);
753	size_t i;
754	for(i = 0; i < excluded_record_ids_length; i++) {
755	fprintf(stderr, " %d", excluded_record_ids[i]);
756	}
757	fprintf(stderr, "\n");
758	}
759	}
760
761	static int *excluded_status_record_ids = NULL;
762	size_t excluded_status_record_ids_length = 0;
763
764	static void excluded_status_record_ids_parse(const char *s, bool debug) {
765	if(!s) return;
766
767	while(*s) {
768	while(s && !isdigit(s)) s++;
769
770	if(isdigit(*s)) {
771	char *e;
772	unsigned long n = strtoul(s, &e, 10);
773	s = e;
774
775	if(n != 0) {
776	excluded_status_record_ids = reallocz(excluded_status_record_ids, (excluded_status_record_ids_length + 1) * sizeof(int));
777	excluded_status_record_ids[excluded_status_record_ids_length++] = (int)n;
778	}
779	}
780	}
781
782	if(debug) {
783	fprintf(stderr, "%s: excluded status record ids:", program_name);
784	size_t i;
785	for(i = 0; i < excluded_status_record_ids_length; i++) {
786	fprintf(stderr, " %d", excluded_status_record_ids[i]);
787	}
788	fprintf(stderr, "\n");
789	}
790	}
791
792
793	static int excluded_record_ids_check(int record_id) {
794	size_t i;
795
796	for(i = 0; i < excluded_record_ids_length; i++) {
797	if(excluded_record_ids[i] == record_id)
798	return 1;
799	}
800
801	return 0;
802	}
803
804	static int excluded_status_record_ids_check(int record_id) {
805	size_t i;
806
807	for(i = 0; i < excluded_status_record_ids_length; i++) {
808	if(excluded_status_record_ids[i] == record_id)
809	return 1;
810	}
811
812	return 0;
813	}
814
815	// ----------------------------------------------------------------------------
816	// data collection functions
817
818	struct {
819	const char *search;
820	SIMPLE_PATTERN *pattern;
821	const char *label;
822	} sensors_component_patterns[] = {
823
824	// The order is important!
825	// They are evaluated top to bottom
826	// The first the matches is used
827
828	{
829	.search = "DIMM\|_DIM\|VTT\|VDDQ\|ECC\|MEMCRC\|MEMBD",
830	.label = NETDATA_SENSOR_COMPONENT_MEMORY_MODULE,
831	},
832	{
833	.search = "CPU\|SOC_\|VDDCR\|P_VDD\|_DTS\|VCORE\|PROC",
834	.label = NETDATA_SENSOR_COMPONENT_PROCESSOR,
835	},
836	{
837	.search = "IPU*",
838	.label = NETDATA_SENSOR_COMPONENT_IPU,
839	},
840	{
841	.search = "M2_\|SSD\|HSC\|HDD\|NVME*",
842	.label = NETDATA_SENSOR_COMPONENT_STORAGE,
843	},
844	{
845	.search = "MB_\|PCH\|VBAT\|I/OBD\|IOBD*",
846	.label = NETDATA_SENSOR_COMPONENT_MOTHERBOARD,
847	},
848	{
849	.search = "Watchdog\|SEL\|SYS_\|CHASSIS*",
850	.label = NETDATA_SENSOR_COMPONENT_SYSTEM,
851	},
852	{
853	.search = "PS\|P_\|PSU\|PWR\|TERMV\|D2D",
854	.label = NETDATA_SENSOR_COMPONENT_POWER_SUPPLY,
855	},
856
857	// fallback components
858	{
859	.search = "VR_P\|VRMP*",
860	.label = NETDATA_SENSOR_COMPONENT_PROCESSOR,
861	},
862	{
863	.search = "VSB\|PS",
864	.label = NETDATA_SENSOR_COMPONENT_POWER_SUPPLY,
865	},
866	{
867	.search = "MEM\|MEMRAID*",
868	.label = NETDATA_SENSOR_COMPONENT_MEMORY,
869	},
870	{
871	.search = "RAID", // there is also "Memory RAID", so keep this after memory
872	.label = NETDATA_SENSOR_COMPONENT_STORAGE,
873	},
874	{
875	.search = "PERIPHERAL\|USB",
876	.label = NETDATA_SENSOR_COMPONENT_PERIPHERAL,
877	},
878	{
879	.search = "FAN\|12V\|VCC\|PCI\|CHIPSET\|AMP\|BD",
880	.label = NETDATA_SENSOR_COMPONENT_SYSTEM,
881	},
882
883	// terminator
884	{
885	.search = NULL,
886	.label = NULL,
887	}
888	};
889
890	static const char netdata_sensor_name_to_component(const char sensor_name) {
891	for(int i = 0; sensors_component_patterns[i].search ;i++) {
892	if(!sensors_component_patterns[i].pattern)
893	sensors_component_patterns[i].pattern = simple_pattern_create(sensors_component_patterns[i].search, "\|", SIMPLE_PATTERN_EXACT, false);
894
895	if(simple_pattern_matches(sensors_component_patterns[i].pattern, sensor_name))
896	return sensors_component_patterns[i].label;
897	}
898
899	return "Other";
900	}
901
902	const char *netdata_collect_type_to_string(IPMI_COLLECTION_TYPE type) {
903	if((type & (IPMI_COLLECT_TYPE_SENSORS\|IPMI_COLLECT_TYPE_SEL)) == (IPMI_COLLECT_TYPE_SENSORS\|IPMI_COLLECT_TYPE_SEL))
904	return "sensors,sel";
905	if(type & IPMI_COLLECT_TYPE_SEL)
906	return "sel";
907	if(type & IPMI_COLLECT_TYPE_SENSORS)
908	return "sensors";
909
910	return "unknown";
911	}
912
913	static void netdata_sensor_set_value(struct sensor sn, void sensor_reading, struct netdata_ipmi_state *stt __maybe_unused) {
914	switch(sn->sensor_reading_type) {
915	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER8_BOOL:
916	sn->sensor_reading.bool_value = ((uint8_t )sensor_reading);
917	break;
918
919	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER32:
920	sn->sensor_reading.uint32_value = ((uint32_t )sensor_reading);
921	break;
922
923	case IPMI_MONITORING_SENSOR_READING_TYPE_DOUBLE:
924	sn->sensor_reading.double_value = ((double )sensor_reading);
925	break;
926
927	default:
928	case IPMI_MONITORING_SENSOR_READING_TYPE_UNKNOWN:
929	sn->do_metric = false;
930	break;
931	}
932	}
933
934	static void netdata_update_ipmi_sensor_reading(
935	int record_id
936	, int sensor_number
937	, int sensor_type
938	, int sensor_state
939	, int sensor_units
940	, int sensor_reading_type
941	, char *sensor_name
942	, void *sensor_reading
943	, int event_reading_type_code __maybe_unused
944	, int sensor_bitmask_type __maybe_unused
945	, int sensor_bitmask __maybe_unused
946	, char **sensor_bitmask_strings __maybe_unused
947	, struct netdata_ipmi_state *stt) {
948	if(unlikely(sensor_state == IPMI_MONITORING_STATE_UNKNOWN &&
949	sensor_type == IPMI_MONITORING_SENSOR_TYPE_UNKNOWN &&
950	sensor_units == IPMI_MONITORING_SENSOR_UNITS_UNKNOWN &&
951	sensor_reading_type == IPMI_MONITORING_SENSOR_READING_TYPE_UNKNOWN &&
952	(!sensor_name \|\| !*sensor_name)))
953	// we can't do anything about this sensor - everything is unknown
954	return;
955
956	if(unlikely(!sensor_name \|\| !*sensor_name))
957	sensor_name = "UNNAMED";
958
959	stt->sensors.collected++;
960
961	char key[SENSORS_DICT_KEY_SIZE + 1];
962	snprintfz(key, SENSORS_DICT_KEY_SIZE, "i%d_n%d_t%d_u%d_%s",
963	record_id, sensor_number, sensor_reading_type, sensor_units, sensor_name);
964
965	// find the sensor record
966	const DICTIONARY_ITEM *item = dictionary_get_and_acquire_item(stt->sensors.dict, key);
967	if(likely(item)) {
968	// recurring collection
969
970	if(stt->debug)
971	fprintf(stderr, "%s: reusing sensor record for sensor '%s', id %d, number %d, type %d, state %d, units %d, reading_type %d\n",
972	program_name, sensor_name, record_id, sensor_number, sensor_type, sensor_state, sensor_units, sensor_reading_type);
973
974	struct sensor *sn = dictionary_acquired_item_value(item);
975
976	if(sensor_reading) {
977	netdata_sensor_set_value(sn, sensor_reading, stt);
978	sn->last_collected_metric_ut = stt->sensors.now_ut;
979	}
980
981	sn->sensor_state = sensor_state;
982
983	sn->last_collected_state_ut = stt->sensors.now_ut;
984
985	dictionary_acquired_item_release(stt->sensors.dict, item);
986
987	return;
988	}
989
990	if(stt->debug)
991	fprintf(stderr, "Allocating new sensor data record for sensor '%s', id %d, number %d, type %d, state %d, units %d, reading_type %d\n",
992	sensor_name, record_id, sensor_number, sensor_type, sensor_state, sensor_units, sensor_reading_type);
993
994	// check if it is excluded
995	bool excluded_metric = excluded_record_ids_check(record_id);
996	bool excluded_state = excluded_status_record_ids_check(record_id);
997
998	if(excluded_metric) {
999	if(stt->debug)
1000	fprintf(stderr, "Sensor '%s' is excluded by excluded_record_ids_check()\n", sensor_name);
1001	}
1002
1003	if(excluded_state) {
1004	if(stt->debug)
1005	fprintf(stderr, "Sensor '%s' is excluded for status check, by excluded_status_record_ids_check()\n", sensor_name);
1006	}
1007
1008	struct sensor t = {
1009	.sensor_type = sensor_type,
1010	.sensor_state = sensor_state,
1011	.sensor_units = sensor_units,
1012	.sensor_reading_type = sensor_reading_type,
1013	.sensor_name = strdupz(sensor_name),
1014	.component = netdata_sensor_name_to_component(sensor_name),
1015	.do_state = !excluded_state,
1016	.do_metric = !excluded_metric,
1017	};
1018
1019	t.type = netdata_ipmi_get_sensor_type_string(t.sensor_type, &t.component);
1020
1021	switch(t.sensor_units) {
1022	case IPMI_MONITORING_SENSOR_UNITS_CELSIUS:
1023	t.dimension = "temperature";
1024	t.context = "ipmi.sensor_temperature_c";
1025	t.title = "IPMI Sensor Temperature Celsius";
1026	t.units = "Celsius";
1027	t.family = "temperatures";
1028	t.chart_type = "line";
1029	t.priority = stt->sensors.priority + 10;
1030	break;
1031
1032	case IPMI_MONITORING_SENSOR_UNITS_FAHRENHEIT:
1033	t.dimension = "temperature";
1034	t.context = "ipmi.sensor_temperature_f";
1035	t.title = "IPMI Sensor Temperature Fahrenheit";
1036	t.units = "Fahrenheit";
1037	t.family = "temperatures";
1038	t.chart_type = "line";
1039	t.priority = stt->sensors.priority + 20;
1040	break;
1041
1042	case IPMI_MONITORING_SENSOR_UNITS_VOLTS:
1043	t.dimension = "voltage";
1044	t.context = "ipmi.sensor_voltage";
1045	t.title = "IPMI Sensor Voltage";
1046	t.units = "Volts";
1047	t.family = "voltages";
1048	t.chart_type = "line";
1049	t.priority = stt->sensors.priority + 30;
1050	break;
1051
1052	case IPMI_MONITORING_SENSOR_UNITS_AMPS:
1053	t.dimension = "ampere";
1054	t.context = "ipmi.sensor_ampere";
1055	t.title = "IPMI Sensor Current";
1056	t.units = "Amps";
1057	t.family = "current";
1058	t.chart_type = "line";
1059	t.priority = stt->sensors.priority + 40;
1060	break;
1061
1062	case IPMI_MONITORING_SENSOR_UNITS_RPM:
1063	t.dimension = "rotations";
1064	t.context = "ipmi.sensor_fan_speed";
1065	t.title = "IPMI Sensor Fans Speed";
1066	t.units = "RPM";
1067	t.family = "fans";
1068	t.chart_type = "line";
1069	t.priority = stt->sensors.priority + 50;
1070	break;
1071
1072	case IPMI_MONITORING_SENSOR_UNITS_WATTS:
1073	t.dimension = "power";
1074	t.context = "ipmi.sensor_power";
1075	t.title = "IPMI Sensor Power";
1076	t.units = "Watts";
1077	t.family = "power";
1078	t.chart_type = "line";
1079	t.priority = stt->sensors.priority + 60;
1080	break;
1081
1082	case IPMI_MONITORING_SENSOR_UNITS_PERCENT:
1083	t.dimension = "percentage";
1084	t.context = "ipmi.sensor_reading_percent";
1085	t.title = "IPMI Sensor Reading Percentage";
1086	t.units = "%%";
1087	t.family = "other";
1088	t.chart_type = "line";
1089	t.priority = stt->sensors.priority + 70;
1090	break;
1091
1092	default:
1093	t.priority = stt->sensors.priority + 80;
1094	t.do_metric = false;
1095	break;
1096	}
1097
1098	switch(sensor_reading_type) {
1099	case IPMI_MONITORING_SENSOR_READING_TYPE_DOUBLE:
1100	t.multiplier = 1000;
1101	break;
1102
1103	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER8_BOOL:
1104	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER32:
1105	t.multiplier = 1;
1106	break;
1107
1108	default:
1109	t.do_metric = false;
1110	break;
1111	}
1112
1113	if(sensor_reading) {
1114	netdata_sensor_set_value(&t, sensor_reading, stt);
1115	t.last_collected_metric_ut = stt->sensors.now_ut;
1116	}
1117	t.last_collected_state_ut = stt->sensors.now_ut;
1118
1119	dictionary_set(stt->sensors.dict, key, &t, sizeof(t));
1120	}
1121
1122	static void netdata_update_ipmi_sel_events_count(struct netdata_ipmi_state *stt, uint32_t events) {
1123	stt->sel.events = events;
1124	}
1125
1126	int netdata_ipmi_collect_data(struct ipmi_monitoring_ipmi_config ipmi_config, IPMI_COLLECTION_TYPE type, struct netdata_ipmi_state stt) {
1127	errno_clear();
1128
1129	if(type & IPMI_COLLECT_TYPE_SENSORS) {
1130	stt->sensors.collected = 0;
1131	stt->sensors.now_ut = now_monotonic_usec();
1132
1133	if (netdata_read_ipmi_sensors(ipmi_config, stt) < 0) return -1;
1134	}
1135
1136	if(type & IPMI_COLLECT_TYPE_SEL) {
1137	stt->sel.events = 0;
1138	stt->sel.now_ut = now_monotonic_usec();
1139	if(netdata_get_ipmi_sel_events_count(ipmi_config, stt) < 0) return -2;
1140	}
1141
1142	return 0;
1143	}
1144
1145	int netdata_ipmi_detect_speed_secs(struct ipmi_monitoring_ipmi_config ipmi_config, IPMI_COLLECTION_TYPE type, struct netdata_ipmi_state stt) {
1146	int i, checks = SPEED_TEST_ITERATIONS, successful = 0;
1147	usec_t total = 0;
1148
1149	for(i = 0 ; i < checks ; i++) {
1150	if(unlikely(stt->debug))
1151	fprintf(stderr, "%s: checking %s data collection speed iteration %d of %d\n",
1152	program_name, netdata_collect_type_to_string(type), i + 1, checks);
1153
1154	// measure the time a data collection needs
1155	usec_t start = now_realtime_usec();
1156
1157	if(netdata_ipmi_collect_data(ipmi_config, type, stt) < 0)
1158	continue;
1159
1160	usec_t end = now_realtime_usec();
1161
1162	successful++;
1163
1164	if(unlikely(stt->debug))
1165	fprintf(stderr, "%s: %s data collection speed was %"PRIu64" usec\n",
1166	program_name, netdata_collect_type_to_string(type), end - start);
1167
1168	// add it to our total
1169	total += end - start;
1170
1171	// wait the same time
1172	// to avoid flooding the IPMI processor with requests
1173	sleep_usec(end - start);
1174	}
1175
1176	if(!successful)
1177	return 0;
1178
1179	// so, we assume it needed 2x the time
1180	// we find the average in microseconds
1181	// and we round-up to the closest second
1182
1183	return (int)(( total * 2 / successful / USEC_PER_SEC ) + 1);
1184	}
1185
1186	// ----------------------------------------------------------------------------
1187	// data collection threads
1188
1189	struct ipmi_collection_thread {
1190	struct ipmi_monitoring_ipmi_config ipmi_config;
1191	int freq_s;
1192	bool debug;
1193	IPMI_COLLECTION_TYPE type;
1194	SPINLOCK spinlock;
1195	struct netdata_ipmi_state state;
1196	};
1197
1198	void netdata_ipmi_collection_thread(void *ptr) {
1199	struct ipmi_collection_thread *t = ptr;
1200
1201	if(t->debug) fprintf(stderr, "%s: calling initialize_ipmi_config() for %s\n",
1202	program_name, netdata_collect_type_to_string(t->type));
1203
1204	initialize_ipmi_config(&t->ipmi_config);
1205
1206	if(t->debug) fprintf(stderr, "%s: detecting IPMI minimum update frequency for %s...\n",
1207	program_name, netdata_collect_type_to_string(t->type));
1208
1209	int freq_s = netdata_ipmi_detect_speed_secs(&t->ipmi_config, t->type, &t->state);
1210	if(!freq_s) {
1211	if(t->type & IPMI_COLLECT_TYPE_SENSORS) {
1212	t->state.sensors.status = ICS_INIT_FAILED;
1213	t->state.sensors.last_iteration_ut = 0;
1214	}
1215
1216	if(t->type & IPMI_COLLECT_TYPE_SEL) {
1217	t->state.sel.status = ICS_INIT_FAILED;
1218	t->state.sel.last_iteration_ut = 0;
1219	}
1220
1221	return;
1222	}
1223	else {
1224	if(t->type & IPMI_COLLECT_TYPE_SENSORS) {
1225	t->state.sensors.status = ICS_RUNNING;
1226	}
1227
1228	if(t->type & IPMI_COLLECT_TYPE_SEL) {
1229	t->state.sel.status = ICS_RUNNING;
1230	}
1231	}
1232
1233	t->freq_s = freq_s = MAX(t->freq_s, freq_s);
1234
1235	if(t->debug) {
1236	fprintf(stderr, "%s: IPMI minimum update frequency of %s was calculated to %d seconds.\n",
1237	program_name, netdata_collect_type_to_string(t->type), t->freq_s);
1238
1239	fprintf(stderr, "%s: starting data collection of %s\n",
1240	program_name, netdata_collect_type_to_string(t->type));
1241	}
1242
1243	size_t iteration = 0, failures = 0;
1244	usec_t step = t->freq_s * USEC_PER_SEC;
1245
1246	heartbeat_t hb;
1247	heartbeat_init(&hb, step);
1248	while(++iteration) {
1249	heartbeat_next(&hb);
1250
1251	if(t->debug)
1252	fprintf(stderr, "%s: calling netdata_ipmi_collect_data() for %s\n",
1253	program_name, netdata_collect_type_to_string(t->type));
1254
1255	struct netdata_ipmi_state tmp_state = t->state;
1256
1257	if(t->type & IPMI_COLLECT_TYPE_SENSORS) {
1258	tmp_state.sensors.last_iteration_ut = now_monotonic_usec();
1259	tmp_state.sensors.freq_ut = t->freq_s * USEC_PER_SEC;
1260	}
1261
1262	if(t->type & IPMI_COLLECT_TYPE_SEL) {
1263	tmp_state.sel.last_iteration_ut = now_monotonic_usec();
1264	tmp_state.sel.freq_ut = t->freq_s * USEC_PER_SEC;
1265	}
1266
1267	if(netdata_ipmi_collect_data(&t->ipmi_config, t->type, &tmp_state) != 0)
1268	failures++;
1269	else
1270	failures = 0;
1271
1272	if(failures > 10) {
1273	collector_error("%s() failed to collect %s data for %zu consecutive times, having made %zu iterations.",
1274	__FUNCTION__, netdata_collect_type_to_string(t->type), failures, iteration);
1275
1276	if(t->type & IPMI_COLLECT_TYPE_SENSORS) {
1277	t->state.sensors.status = ICS_FAILED;
1278	t->state.sensors.last_iteration_ut = 0;
1279	}
1280
1281	if(t->type & IPMI_COLLECT_TYPE_SEL) {
1282	t->state.sel.status = ICS_FAILED;
1283	t->state.sel.last_iteration_ut = 0;
1284	}
1285
1286	break;
1287	}
1288
1289	spinlock_lock(&t->spinlock);
1290	t->state = tmp_state;
1291	spinlock_unlock(&t->spinlock);
1292	}
1293	}
1294
1295	// ----------------------------------------------------------------------------
1296	// sending data to netdata
1297
1298	static inline bool is_sensor_updated(usec_t last_collected_ut, usec_t now_ut, usec_t freq) {
1299	return (now_ut - last_collected_ut < freq * 2) ? true : false;
1300	}
1301
1302	static size_t send_ipmi_sensor_metrics_to_netdata(struct netdata_ipmi_state *stt) {
1303	if(stt->sensors.status != ICS_RUNNING) {
1304	if(unlikely(stt->debug))
1305	fprintf(stderr, "%s: %s() sensors state is not RUNNING\n",
1306	program_name, __FUNCTION__ );
1307	return 0;
1308	}
1309
1310	size_t total_sensors_sent = 0;
1311	int update_every_s = (int)(stt->sensors.freq_ut / USEC_PER_SEC);
1312	struct sensor *sn;
1313
1314	netdata_mutex_lock(&stdout_mutex);
1315	// generate the CHART/DIMENSION lines, if we have to
1316	dfe_start_reentrant(stt->sensors.dict, sn) {
1317	if(unlikely(!sn->do_metric && !sn->do_state))
1318	continue;
1319
1320	bool did_metric = false, did_state = false;
1321
1322	if(likely(sn->do_metric)) {
1323	if(unlikely(!is_sensor_updated(sn->last_collected_metric_ut, stt->updates.now_ut, stt->sensors.freq_ut))) {
1324	if(unlikely(stt->debug))
1325	fprintf(stderr, "%s: %s() sensor '%s' metric is not UPDATED (last updated %"PRIu64", now %"PRIu64", freq %"PRIu64"\n",
1326	program_name, __FUNCTION__, sn->sensor_name, sn->last_collected_metric_ut,
1327	stt->updates.now_ut, stt->sensors.freq_ut);
1328	}
1329	else {
1330	if (unlikely(!sn->metric_chart_sent)) {
1331	sn->metric_chart_sent = true;
1332
1333	printf("CHART '%s_%s' '' '%s' '%s' '%s' '%s' '%s' %d %d '' '%s' '%s'\n",
1334	sn->context, sn_dfe.name, sn->title, sn->units, sn->family, sn->context,
1335	sn->chart_type, sn->priority + 1,
1336	update_every_s, program_name, "sensors");
1337
1338	printf("CLABEL 'sensor' '%s' 1\n", sn->sensor_name);
1339	printf("CLABEL 'type' '%s' 1\n", sn->type);
1340	printf("CLABEL 'component' '%s' 1\n", sn->component);
1341	printf("CLABEL_COMMIT\n");
1342
1343	printf("DIMENSION '%s' '' absolute 1 %d\n", sn->dimension, sn->multiplier);
1344	}
1345
1346	printf("BEGIN '%s_%s'\n", sn->context, sn_dfe.name);
1347
1348	switch (sn->sensor_reading_type) {
1349	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER32:
1350	printf("SET '%s' = %u\n", sn->dimension, sn->sensor_reading.uint32_value);
1351	break;
1352
1353	case IPMI_MONITORING_SENSOR_READING_TYPE_DOUBLE:
1354	printf("SET '%s' = %lld\n", sn->dimension,
1355	(long long int) (sn->sensor_reading.double_value * sn->multiplier));
1356	break;
1357
1358	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER8_BOOL:
1359	printf("SET '%s' = %u\n", sn->dimension, sn->sensor_reading.bool_value);
1360	break;
1361
1362	default:
1363	case IPMI_MONITORING_SENSOR_READING_TYPE_UNKNOWN:
1364	// this should never happen because we also do the same check at netdata_get_sensor()
1365	sn->do_metric = false;
1366	break;
1367	}
1368
1369	printf("END\n");
1370	did_metric = true;
1371	}
1372	}
1373
1374	if(likely(sn->do_state)) {
1375	if(unlikely(!is_sensor_updated(sn->last_collected_state_ut, stt->updates.now_ut, stt->sensors.freq_ut))) {
1376	if (unlikely(stt->debug))
1377	fprintf(stderr, "%s: %s() sensor '%s' state is not UPDATED (last updated %"PRIu64", now %"PRIu64", freq %"PRIu64"\n",
1378	program_name, __FUNCTION__, sn->sensor_name, sn->last_collected_state_ut,
1379	stt->updates.now_ut, stt->sensors.freq_ut);
1380	}
1381	else {
1382	if (unlikely(!sn->state_chart_sent)) {
1383	sn->state_chart_sent = true;
1384
1385	printf("CHART 'ipmi.sensor_state_%s' '' 'IPMI Sensor State' 'state' 'states' 'ipmi.sensor_state' 'line' %d %d '' '%s' '%s'\n",
1386	sn_dfe.name, sn->priority, update_every_s, program_name, "sensors");
1387
1388	printf("CLABEL 'sensor' '%s' 1\n", sn->sensor_name);
1389	printf("CLABEL 'type' '%s' 1\n", sn->type);
1390	printf("CLABEL 'component' '%s' 1\n", sn->component);
1391	printf("CLABEL_COMMIT\n");
1392
1393	printf("DIMENSION 'nominal' '' absolute 1 1\n");
1394	printf("DIMENSION 'warning' '' absolute 1 1\n");
1395	printf("DIMENSION 'critical' '' absolute 1 1\n");
1396	printf("DIMENSION 'unknown' '' absolute 1 1\n");
1397	}
1398
1399	printf("BEGIN 'ipmi.sensor_state_%s'\n", sn_dfe.name);
1400	printf("SET 'nominal' = %lld\n", sn->sensor_state == IPMI_MONITORING_STATE_NOMINAL ? 1LL : 0LL);
1401	printf("SET 'warning' = %lld\n", sn->sensor_state == IPMI_MONITORING_STATE_WARNING ? 1LL : 0LL);
1402	printf("SET 'critical' = %lld\n", sn->sensor_state == IPMI_MONITORING_STATE_CRITICAL ? 1LL : 0LL);
1403	printf("SET 'unknown' = %lld\n", sn->sensor_state == IPMI_MONITORING_STATE_UNKNOWN ? 1LL : 0LL);
1404	printf("END\n");
1405	did_state = true;
1406	}
1407	}
1408
1409	if(likely(did_metric \|\| did_state))
1410	total_sensors_sent++;
1411	}
1412	dfe_done(sn);
1413
1414	netdata_mutex_unlock(&stdout_mutex);
1415
1416	return total_sensors_sent;
1417	}
1418
1419	static size_t send_ipmi_sel_metrics_to_netdata(struct netdata_ipmi_state *stt) {
1420	static bool sel_chart_generated = false;
1421
1422	netdata_mutex_lock(&stdout_mutex);
1423
1424	if(likely(stt->sel.status == ICS_RUNNING)) {
1425	if(unlikely(!sel_chart_generated)) {
1426	sel_chart_generated = true;
1427	printf("CHART ipmi.events '' 'IPMI Events' 'events' 'events' ipmi.sel area %d %d '' '%s' '%s'\n"
1428	, stt->sel.priority + 2
1429	, (int)(stt->sel.freq_ut / USEC_PER_SEC)
1430	, program_name
1431	, "sel"
1432	);
1433	printf("DIMENSION events '' absolute 1 1\n");
1434	}
1435
1436	printf(
1437	"BEGIN ipmi.events\n"
1438	"SET events = %zu\n"
1439	"END\n"
1440	,
1441	stt->sel.events
1442	);
1443	}
1444
1445	netdata_mutex_unlock(&stdout_mutex);
1446
1447	return stt->sel.events;
1448	}
1449
1450	// ----------------------------------------------------------------------------
1451
1452	static const char get_sensor_state_string(struct sensor sn) {
1453	switch (sn->sensor_state) {
1454	case IPMI_MONITORING_STATE_NOMINAL:
1455	return "nominal";
1456	case IPMI_MONITORING_STATE_WARNING:
1457	return "warning";
1458	case IPMI_MONITORING_STATE_CRITICAL:
1459	return "critical";
1460	default:
1461	return "unknown";
1462	}
1463	}
1464
1465	static const char get_sensor_function_priority(struct sensor sn) {
1466	switch (sn->sensor_state) {
1467	case IPMI_MONITORING_STATE_WARNING:
1468	return "warning";
1469	case IPMI_MONITORING_STATE_CRITICAL:
1470	return "critical";
1471	default:
1472	return "normal";
1473	}
1474	}
1475
1476	static void freeimi_function_sensors(const char transaction, char function __maybe_unused,
1477	usec_t stop_monotonic_ut __maybe_unused, bool cancelled __maybe_unused,
1478	BUFFER *payload __maybe_unused, HTTP_ACCESS access __maybe_unused,
1479	const char source __maybe_unused, void data __maybe_unused) {
1480	time_t now_s = now_realtime_sec();
1481
1482	BUFFER *wb = buffer_create(4096, NULL);
1483	buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_NEWLINE_ON_ARRAY_ITEMS);
1484	buffer_json_member_add_uint64(wb, "status", HTTP_RESP_OK);
1485	buffer_json_member_add_string(wb, "type", "table");
1486	buffer_json_member_add_time_t(wb, "update_every", update_every);
1487	buffer_json_member_add_boolean(wb, "has_history", false);
1488	buffer_json_member_add_string(wb, "help", "View IPMI sensor readings and its state");
1489
1490	char *function_copy = strdupz(function);
1491	char *words[1024];
1492	size_t num_words = quoted_strings_splitter_whitespace(function_copy, words, 1024);
1493	for(size_t i = 1; i < num_words ;i++) {
1494	char *param = get_word(words, num_words, i);
1495	if(strcmp(param, "info") == 0) {
1496	buffer_json_member_add_array(wb, "accepted_params");
1497	buffer_json_array_close(wb); // accepted_params
1498	buffer_json_member_add_array(wb, "required_params");
1499	buffer_json_array_close(wb); // required_params
1500	freez(function_copy);
1501	goto close_and_send;
1502	}
1503	}
1504
1505	freez(function_copy);
1506
1507	buffer_json_member_add_array(wb, "data");
1508
1509	struct sensor *sn;
1510	dfe_start_reentrant(state.sensors.dict, sn) {
1511	if (unlikely(!sn->do_metric && !sn->do_state))
1512	continue;
1513
1514	double reading = NAN;
1515	switch (sn->sensor_reading_type) {
1516	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER32:
1517	reading = (double)sn->sensor_reading.uint32_value;
1518	break;
1519	case IPMI_MONITORING_SENSOR_READING_TYPE_DOUBLE:
1520	reading = (double)(sn->sensor_reading.double_value);
1521	break;
1522	case IPMI_MONITORING_SENSOR_READING_TYPE_UNSIGNED_INTEGER8_BOOL:
1523	reading = (double)sn->sensor_reading.bool_value;
1524	break;
1525	}
1526
1527	buffer_json_add_array_item_array(wb);
1528
1529	buffer_json_add_array_item_string(wb, sn->sensor_name);
1530	buffer_json_add_array_item_string(wb, sn->type);
1531	buffer_json_add_array_item_string(wb, sn->component);
1532	buffer_json_add_array_item_double(wb, reading);
1533	buffer_json_add_array_item_string(wb, sn->units);
1534	buffer_json_add_array_item_string(wb, get_sensor_state_string(sn));
1535
1536	buffer_json_add_array_item_object(wb);
1537	buffer_json_member_add_string(wb, "severity", get_sensor_function_priority(sn));
1538	buffer_json_object_close(wb);
1539
1540	buffer_json_array_close(wb);
1541	}
1542	dfe_done(sn);
1543
1544	buffer_json_array_close(wb); // data
1545	buffer_json_member_add_object(wb, "columns");
1546	{
1547	size_t field_id = 0;
1548
1549	buffer_rrdf_table_add_field(wb, field_id++, "Sensor", "Sensor Name",
1550	RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
1551	0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
1552	RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
1553	RRDF_FIELD_OPTS_VISIBLE \| RRDF_FIELD_OPTS_UNIQUE_KEY \| RRDF_FIELD_OPTS_STICKY \| RRDF_FIELD_OPTS_FULL_WIDTH,
1554	NULL);
1555	buffer_rrdf_table_add_field(wb, field_id++, "Type", "Sensor Type",
1556	RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
1557	0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
1558	RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
1559	RRDF_FIELD_OPTS_VISIBLE \| RRDF_FIELD_OPTS_UNIQUE_KEY,
1560	NULL);
1561	buffer_rrdf_table_add_field(wb, field_id++, "Component", "Sensor Component",
1562	RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
1563	0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
1564	RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
1565	RRDF_FIELD_OPTS_VISIBLE \| RRDF_FIELD_OPTS_UNIQUE_KEY,
1566	NULL);
1567	buffer_rrdf_table_add_field(wb, field_id++, "Reading", "Sensor Current Reading",
1568	RRDF_FIELD_TYPE_INTEGER, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER,
1569	2, NULL, 0, RRDF_FIELD_SORT_DESCENDING, NULL,
1570	RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
1571	RRDF_FIELD_OPTS_VISIBLE,
1572	NULL);
1573	buffer_rrdf_table_add_field(wb, field_id++, "Units", "Sensor Reading Units",
1574	RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
1575	0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
1576	RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
1577	RRDF_FIELD_OPTS_VISIBLE \| RRDF_FIELD_OPTS_UNIQUE_KEY,
1578	NULL);
1579	buffer_rrdf_table_add_field(wb, field_id++, "State", "Sensor State",
1580	RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
1581	0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
1582	RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
1583	RRDF_FIELD_OPTS_VISIBLE \| RRDF_FIELD_OPTS_UNIQUE_KEY,
1584	NULL);
1585	buffer_rrdf_table_add_field(
1586	wb, field_id++,
1587	"rowOptions", "rowOptions",
1588	RRDF_FIELD_TYPE_NONE,
1589	RRDR_FIELD_VISUAL_ROW_OPTIONS,
1590	RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,
1591	RRDF_FIELD_SORT_FIXED,
1592	NULL,
1593	RRDF_FIELD_SUMMARY_COUNT,
1594	RRDF_FIELD_FILTER_NONE,
1595	RRDF_FIELD_OPTS_DUMMY,
1596	NULL);
1597	}
1598
1599	buffer_json_object_close(wb); // columns
1600	buffer_json_member_add_string(wb, "default_sort_column", "Type");
1601
1602	buffer_json_member_add_object(wb, "charts");
1603	{
1604	buffer_json_member_add_object(wb, "Sensors");
1605	{
1606	buffer_json_member_add_string(wb, "name", "Sensors");
1607	buffer_json_member_add_string(wb, "type", "stacked-bar");
1608	buffer_json_member_add_array(wb, "columns");
1609	{
1610	buffer_json_add_array_item_string(wb, "Sensor");
1611	}
1612	buffer_json_array_close(wb);
1613	}
1614	buffer_json_object_close(wb);
1615	}
1616	buffer_json_object_close(wb); // charts
1617
1618	buffer_json_member_add_array(wb, "default_charts");
1619	{
1620	buffer_json_add_array_item_array(wb);
1621	buffer_json_add_array_item_string(wb, "Sensors");
1622	buffer_json_add_array_item_string(wb, "Component");
1623	buffer_json_array_close(wb);
1624
1625	buffer_json_add_array_item_array(wb);
1626	buffer_json_add_array_item_string(wb, "Sensors");
1627	buffer_json_add_array_item_string(wb, "State");
1628	buffer_json_array_close(wb);
1629	}
1630	buffer_json_array_close(wb);
1631
1632	close_and_send:
1633	buffer_json_member_add_time_t(wb, "expires", now_s + update_every);
1634	buffer_json_finalize(wb);
1635
1636	wb->response_code = HTTP_RESP_OK;
1637	wb->content_type = CT_APPLICATION_JSON;
1638	wb->expires = now_s + update_every;
1639	pluginsd_function_result_to_stdout(transaction, wb);
1640
1641	buffer_free(wb);
1642	}
1643
1644	// ----------------------------------------------------------------------------
1645	// main, command line arguments parsing
1646
1647	static void plugin_exit(int code) {
1648	fflush(stdout);
1649	__atomic_store_n(&function_plugin_should_exit, true, __ATOMIC_RELEASE);
1650	exit(code);
1651	}
1652
1653	int main (int argc, char **argv) {
1654	nd_log_initialize_for_external_plugins("freeipmi.plugin");
1655	netdata_threads_init_for_external_plugins(0); // set the default threads stack size here
1656
1657	bool netdata_do_sel = IPMI_ENABLE_SEL_BY_DEFAULT;
1658
1659	bool debug = false;
1660
1661	// TODO: Workaround for https://github.com/netdata/netdata/issues/17931
1662	// This variable will be removed once the issue is fixed.
1663	bool restart_every = true;
1664
1665	// ------------------------------------------------------------------------
1666	// parse command line parameters
1667
1668	int i, freq_s = 0;
1669	for(i = 1; i < argc ; i++) {
1670	if(isdigit(*argv[i]) && !freq_s) {
1671	int n = str2i(argv[i]);
1672	if(n > 0 && n < 86400) {
1673	freq_s = n;
1674	continue;
1675	}
1676	}
1677	else if(strcmp("version", argv[i]) == 0 \|\| strcmp("-version", argv[i]) == 0 \|\| strcmp("--version", argv[i]) == 0 \|\| strcmp("-v", argv[i]) == 0 \|\| strcmp("-V", argv[i]) == 0) {
1678	printf("%s %s\n", program_name, NETDATA_VERSION);
1679	exit(0);
1680	}
1681	else if(strcmp("debug", argv[i]) == 0) {
1682	debug = true;
1683	continue;
1684	}
1685	else if(strcmp("no-restart", argv[i]) == 0) {
1686	restart_every = false;
1687	continue;
1688	}
1689	else if(strcmp("sel", argv[i]) == 0) {
1690	netdata_do_sel = true;
1691	continue;
1692	}
1693	else if(strcmp("no-sel", argv[i]) == 0) {
1694	netdata_do_sel = false;
1695	continue;
1696	}
1697	else if(strcmp("reread-sdr-cache", argv[i]) == 0) {
1698	global_sel_flags \|= IPMI_MONITORING_SEL_FLAGS_REREAD_SDR_CACHE;
1699	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_REREAD_SDR_CACHE;
1700	remove_reread_sdr_after_first_use = false;
1701	if (debug) fprintf(stderr, "%s: reread-sdr-cache enabled for both sensors and SEL\n", program_name);
1702	}
1703	else if(strcmp("interpret-oem-data", argv[i]) == 0) {
1704	global_sel_flags \|= IPMI_MONITORING_SEL_FLAGS_INTERPRET_OEM_DATA;
1705	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_INTERPRET_OEM_DATA;
1706	if (debug) fprintf(stderr, "%s: interpret-oem-data enabled for both sensors and SEL\n", program_name);
1707	}
1708	else if(strcmp("assume-system-event-record", argv[i]) == 0) {
1709	global_sel_flags \|= IPMI_MONITORING_SEL_FLAGS_ASSUME_SYSTEM_EVENT_RECORD;
1710	if (debug) fprintf(stderr, "%s: assume-system-event-record enabled\n", program_name);
1711	}
1712	else if(strcmp("ignore-non-interpretable-sensors", argv[i]) == 0) {
1713	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_IGNORE_NON_INTERPRETABLE_SENSORS;
1714	if (debug) fprintf(stderr, "%s: ignore-non-interpretable-sensors enabled\n", program_name);
1715	}
1716	else if(strcmp("bridge-sensors", argv[i]) == 0) {
1717	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_BRIDGE_SENSORS;
1718	if (debug) fprintf(stderr, "%s: bridge-sensors enabled\n", program_name);
1719	}
1720	else if(strcmp("shared-sensors", argv[i]) == 0) {
1721	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_SHARED_SENSORS;
1722	if (debug) fprintf(stderr, "%s: shared-sensors enabled\n", program_name);
1723	}
1724	else if(strcmp("no-discrete-reading", argv[i]) == 0) {
1725	global_sensor_reading_flags &= ~(IPMI_MONITORING_SENSOR_READING_FLAGS_DISCRETE_READING);
1726	if (debug) fprintf(stderr, "%s: discrete-reading disabled\n", program_name);
1727	}
1728	else if(strcmp("ignore-scanning-disabled", argv[i]) == 0) {
1729	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_IGNORE_SCANNING_DISABLED;
1730	if (debug) fprintf(stderr, "%s: ignore-scanning-disabled enabled\n", program_name);
1731	}
1732	else if(strcmp("assume-bmc-owner", argv[i]) == 0) {
1733	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_ASSUME_BMC_OWNER;
1734	if (debug) fprintf(stderr, "%s: assume-bmc-owner enabled\n", program_name);
1735	}
1736	#if defined(IPMI_MONITORING_SEL_FLAGS_ENTITY_SENSOR_NAMES) && defined(IPMI_MONITORING_SENSOR_READING_FLAGS_ENTITY_SENSOR_NAMES)
1737	else if(strcmp("entity-sensor-names", argv[i]) == 0) {
1738	global_sel_flags \|= IPMI_MONITORING_SEL_FLAGS_ENTITY_SENSOR_NAMES;
1739	global_sensor_reading_flags \|= IPMI_MONITORING_SENSOR_READING_FLAGS_ENTITY_SENSOR_NAMES;
1740	if (debug) fprintf(stderr, "%s: entity-sensor-names enabled for both sensors and SEL\n", program_name);
1741	}
1742	#endif
1743	else if(strcmp("-h", argv[i]) == 0 \|\| strcmp("--help", argv[i]) == 0) {
1744	fprintf(stderr,
1745	"\n"
1746	" netdata %s %s\n"
1747	" Copyright 2018-2025 Netdata Inc.\n"
1748	" Released under GNU General Public License v3 or later.\n"
1749	"\n"
1750	" This program is a data collector plugin for netdata.\n"
1751	"\n"
1752	" Available command line options:\n"
1753	"\n"
1754	" SECONDS data collection frequency\n"
1755	" minimum: %d\n"
1756	"\n"
1757	" debug enable verbose output\n"
1758	" default: disabled\n"
1759	"\n"
1760	" sel\n"
1761	" no-sel enable/disable SEL collection\n"
1762	" default: %s\n"
1763	"\n"
1764	" reread-sdr-cache re-read SDR cache on every iteration\n"
1765	" default: disabled\n"
1766	"\n"
1767	" interpret-oem-data attempt to parse OEM data\n"
1768	" default: disabled\n"
1769	"\n"
1770	" assume-system-event-record \n"
1771	" tread illegal SEL events records as normal\n"
1772	" default: disabled\n"
1773	"\n"
1774	" ignore-non-interpretable-sensors \n"
1775	" do not read sensors that cannot be interpreted\n"
1776	" default: disabled\n"
1777	"\n"
1778	" bridge-sensors bridge sensors not owned by the BMC\n"
1779	" default: disabled\n"
1780	"\n"
1781	" shared-sensors enable shared sensors, if found\n"
1782	" default: disabled\n"
1783	"\n"
1784	" no-discrete-reading do not read sensors that their event/reading type code is invalid\n"
1785	" default: enabled\n"
1786	"\n"
1787	" ignore-scanning-disabled \n"
1788	" Ignore the scanning bit and read sensors no matter what\n"
1789	" default: disabled\n"
1790	"\n"
1791	" assume-bmc-owner assume the BMC is the sensor owner no matter what\n"
1792	" (usually bridging is required too)\n"
1793	" default: disabled\n"
1794	"\n"
1795	#if defined(IPMI_MONITORING_SEL_FLAGS_ENTITY_SENSOR_NAMES) && defined(IPMI_MONITORING_SENSOR_READING_FLAGS_ENTITY_SENSOR_NAMES)
1796	" entity-sensor-names sensor names prefixed with entity id and instance\n"
1797	" default: disabled\n"
1798	"\n"
1799	#endif
1800	" hostname HOST\n"
1801	" username USER\n"
1802	" password PASS connect to remote IPMI host\n"
1803	" default: local IPMI processor\n"
1804	"\n"
1805	" no-auth-code-check\n"
1806	" noauthcodecheck don't check the authentication codes returned\n"
1807	"\n"
1808	" driver-type IPMIDRIVER\n"
1809	" Specify the driver type to use instead of doing an auto selection. \n"
1810	" The currently available outofband drivers are LAN and LAN_2_0,\n"
1811	" which perform IPMI 1.5 and IPMI 2.0 respectively. \n"
1812	" The currently available inband drivers are KCS, SSIF, OPENIPMI and SUNBMC.\n"
1813	"\n"
1814	" sdr-cache-dir PATH directory for SDR cache files\n"
1815	" default: %s\n"
1816	"\n"
1817	" sensor-config-file FILE filename to read sensor configuration\n"
1818	" default: %s\n"
1819	"\n"
1820	" sel-config-file FILE filename to read sel configuration\n"
1821	" default: %s\n"
1822	"\n"
1823	" ignore N1,N2,N3,... sensor IDs to ignore\n"
1824	" default: none\n"
1825	"\n"
1826	" ignore-status N1,N2,N3,... sensor IDs to ignore status (nominal/warning/critical)\n"
1827	" default: none\n"
1828	"\n"
1829	" -v\n"
1830	" -V\n"
1831	" version print version and exit\n"
1832	"\n"
1833	" Linux kernel module for IPMI is CPU hungry.\n"
1834	" On Linux run this to lower kipmiN CPU utilization:\n"
1835	" # echo 10 > /sys/module/ipmi_si/parameters/kipmid_max_busy_us\n"
1836	"\n"
1837	" or create: /etc/modprobe.d/ipmi.conf with these contents:\n"
1838	" options ipmi_si kipmid_max_busy_us=10\n"
1839	"\n"
1840	" For more information:\n"
1841	" https://github.com/netdata/netdata/tree/master/src/collectors/freeipmi.plugin\n"
1842	"\n"
1843	, program_name, NETDATA_VERSION
1844	, update_every
1845	, netdata_do_sel?"enabled":"disabled"
1846	, sdr_cache_directory?sdr_cache_directory:"system default"
1847	, sensor_config_file?sensor_config_file:"system default"
1848	, sel_config_file?sel_config_file:"system default"
1849	);
1850	exit(1);
1851	}
1852	else if(i < argc && strcmp("hostname", argv[i]) == 0) {
1853	hostname = strdupz(argv[++i]);
1854	char *s = argv[i];
1855	// mask it be hidden from the process tree
1856	while(s) s++ = 'x';
1857	if(debug) fprintf(stderr, "%s: hostname set to '%s'\n", program_name, hostname);
1858	continue;
1859	}
1860	else if(i < argc && strcmp("username", argv[i]) == 0) {
1861	username = strdupz(argv[++i]);
1862	char *s = argv[i];
1863	// mask it be hidden from the process tree
1864	while(s) s++ = 'x';
1865	if(debug) fprintf(stderr, "%s: username set to '%s'\n", program_name, username);
1866	continue;
1867	}
1868	else if(i < argc && strcmp("password", argv[i]) == 0) {
1869	password = strdupz(argv[++i]);
1870	char *s = argv[i];
1871	// mask it be hidden from the process tree
1872	while(s) s++ = 'x';
1873	if(debug) fprintf(stderr, "%s: password set to '%s'\n", program_name, password);
1874	continue;
1875	}
1876	else if(strcmp("driver-type", argv[i]) == 0) {
1877	if (hostname) {
1878	freeimpi_protocol_version = netdata_parse_outofband_driver_type(argv[++i]);
1879	if(debug) fprintf(stderr, "%s: outband FreeIMPI protocol version set to '%d'\n",
1880	program_name, freeimpi_protocol_version);
1881	}
1882	else {
1883	driver_type = netdata_parse_inband_driver_type(argv[++i]);
1884	if(debug) fprintf(stderr, "%s: inband driver type set to '%d'\n",
1885	program_name, driver_type);
1886	}
1887	continue;
1888	} else if (i < argc && (strcmp("noauthcodecheck", argv[i]) == 0 \|\| strcmp("no-auth-code-check", argv[i]) == 0)) {
1889	if (!hostname \|\| netdata_host_is_localhost(hostname)) {
1890	if (debug)
1891	fprintf(stderr, "%s: noauthcodecheck workaround flag is ignored for inband configuration\n",
1892	program_name);
1893
1894	}
1895	else if (freeimpi_protocol_version < 0 \|\| freeimpi_protocol_version == IPMI_MONITORING_PROTOCOL_VERSION_1_5) {
1896	workaround_flags \|= IPMI_MONITORING_WORKAROUND_FLAGS_PROTOCOL_VERSION_1_5_NO_AUTH_CODE_CHECK;
1897
1898	if (debug)
1899	fprintf(stderr, "%s: noauthcodecheck workaround flag enabled\n", program_name);
1900	}
1901	else {
1902	if (debug)
1903	fprintf(stderr, "%s: noauthcodecheck workaround flag is ignored for protocol version 2.0\n",
1904	program_name);
1905	}
1906	continue;
1907	}
1908	else if(i < argc && strcmp("sdr-cache-dir", argv[i]) == 0) {
1909	sdr_cache_directory = argv[++i];
1910
1911	if(debug)
1912	fprintf(stderr, "%s: SDR cache directory set to '%s'\n", program_name, sdr_cache_directory);
1913
1914	continue;
1915	}
1916	else if(i < argc && strcmp("sensor-config-file", argv[i]) == 0) {
1917	sensor_config_file = argv[++i];
1918	if(debug) fprintf(stderr, "%s: sensor config file set to '%s'\n", program_name, sensor_config_file);
1919	continue;
1920	}
1921	else if(i < argc && strcmp("sel-config-file", argv[i]) == 0) {
1922	sel_config_file = argv[++i];
1923	if(debug) fprintf(stderr, "%s: sel config file set to '%s'\n", program_name, sel_config_file);
1924	continue;
1925	}
1926	else if(i < argc && strcmp("ignore", argv[i]) == 0) {
1927	excluded_record_ids_parse(argv[++i], debug);
1928	continue;
1929	}
1930	else if(i < argc && strcmp("ignore-status", argv[i]) == 0) {
1931	excluded_status_record_ids_parse(argv[++i], debug);
1932	continue;
1933	}
1934
1935	collector_error("%s(): ignoring parameter '%s'", __FUNCTION__, argv[i]);
1936	}
1937
1938	errno_clear();
1939
1940	if(freq_s && freq_s < update_every)
1941	collector_info("%s(): update frequency %d seconds is too small for IPMI. Using %d.",
1942	__FUNCTION__, freq_s, update_every);
1943
1944	update_every = freq_s = MAX(freq_s, update_every);
1945	update_every_sel = MAX(update_every, update_every_sel);
1946
1947	// ------------------------------------------------------------------------
1948	// initialize IPMI
1949
1950	if(debug) {
1951	fprintf(stderr, "%s: calling ipmi_monitoring_init()\n", program_name);
1952	ipmimonitoring_init_flags \|= IPMI_MONITORING_FLAGS_DEBUG\|IPMI_MONITORING_FLAGS_DEBUG_IPMI_PACKETS;
1953	}
1954
1955	int rc;
1956	if(ipmi_monitoring_init(ipmimonitoring_init_flags, &rc) < 0)
1957	fatal("ipmi_monitoring_init: %s", ipmi_monitoring_ctx_strerror(rc));
1958
1959	// ------------------------------------------------------------------------
1960	// create the data collection threads
1961
1962	struct ipmi_collection_thread sensors_data = {
1963	.type = IPMI_COLLECT_TYPE_SENSORS,
1964	.freq_s = update_every,
1965	.spinlock = SPINLOCK_INITIALIZER,
1966	.debug = debug,
1967	.state = {
1968	.debug = debug,
1969	.sensors = {
1970	.status = ICS_INIT,
1971	.last_iteration_ut = now_monotonic_usec(),
1972	.freq_ut = update_every * USEC_PER_SEC,
1973	.priority = IPMI_SENSORS_DASHBOARD_PRIORITY,
1974	.dict = dictionary_create_advanced(DICT_OPTION_DONT_OVERWRITE_VALUE\|DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct sensor)),
1975	},
1976	},
1977	}, sel_data = {
1978	.type = IPMI_COLLECT_TYPE_SEL,
1979	.freq_s = update_every_sel,
1980	.spinlock = SPINLOCK_INITIALIZER,
1981	.debug = debug,
1982	.state = {
1983	.debug = debug,
1984	.sel = {
1985	.status = ICS_INIT,
1986	.last_iteration_ut = now_monotonic_usec(),
1987	.freq_ut = update_every_sel * USEC_PER_SEC,
1988	.priority = IPMI_SEL_DASHBOARD_PRIORITY,
1989	},
1990	},
1991	};
1992
1993	nd_thread_create("IPMI[sensors]", NETDATA_THREAD_OPTION_DONT_LOG, netdata_ipmi_collection_thread, &sensors_data);
1994	if (netdata_do_sel)
1995	nd_thread_create("IPMI[sel]", NETDATA_THREAD_OPTION_DONT_LOG, netdata_ipmi_collection_thread, &sel_data);
1996
1997	// ------------------------------------------------------------------------
1998	// the main loop
1999
2000	if(debug) fprintf(stderr, "%s: starting data collection\n", program_name);
2001
2002	time_t started_t = now_monotonic_sec();
2003
2004	size_t iteration = 0;
2005	bool global_chart_created = false;
2006	bool tty = isatty(fileno(stdout)) == 1;
2007
2008	heartbeat_t hb;
2009	heartbeat_init(&hb, update_every * USEC_PER_SEC);
2010	for(iteration = 0; !__atomic_load_n(&function_plugin_should_exit, __ATOMIC_ACQUIRE) ; iteration++) {
2011	usec_t dt = heartbeat_next(&hb);
2012
2013	if (!tty) {
2014	netdata_mutex_lock(&stdout_mutex);
2015	fprintf(stdout, "\n"); // keepalive to avoid parser read timeout (2 minutes) during ipmi_detect_speed_secs()
2016	fflush(stdout);
2017	netdata_mutex_unlock(&stdout_mutex);
2018	}
2019
2020	spinlock_lock(&sensors_data.spinlock);
2021	state.sensors = sensors_data.state.sensors;
2022	spinlock_unlock(&sensors_data.spinlock);
2023
2024	spinlock_lock(&sel_data.spinlock);
2025	state.sel = sel_data.state.sel;
2026	spinlock_unlock(&sel_data.spinlock);
2027
2028	switch(state.sensors.status) {
2029	case ICS_RUNNING:
2030	if(now_monotonic_usec() > state.sensors.last_iteration_ut + IPMI_RESTART_IF_SENSORS_DONT_ITERATE_EVERY_SECONDS * USEC_PER_SEC) {
2031	collector_error("%s(): sensors have not be collected for %zu seconds. Exiting to restart.",
2032	__FUNCTION__, (size_t)((now_monotonic_usec() - state.sensors.last_iteration_ut) / USEC_PER_SEC));
2033
2034	fprintf(stdout, "EXIT\n");
2035	plugin_exit(0);
2036	}
2037	break;
2038
2039	case ICS_INIT:
2040	continue;
2041
2042	case ICS_INIT_FAILED:
2043	collector_error("%s(): sensors failed to initialize. Calling DISABLE.", __FUNCTION__);
2044	fprintf(stdout, "DISABLE\n");
2045	plugin_exit(0);
2046	break;
2047
2048	case ICS_FAILED:
2049	collector_error("%s(): sensors fails repeatedly to collect metrics. Exiting to restart.", __FUNCTION__);
2050	fprintf(stdout, "EXIT\n");
2051	plugin_exit(0);
2052	break;
2053	}
2054
2055	if(netdata_do_sel) {
2056	switch (state.sensors.status) {
2057	case ICS_RUNNING:
2058	case ICS_INIT:
2059	break;
2060
2061	case ICS_INIT_FAILED:
2062	case ICS_FAILED:
2063	collector_error("%s(): SEL fails to collect events. Disabling SEL collection.", __FUNCTION__);
2064	netdata_do_sel = false;
2065	break;
2066	}
2067	}
2068
2069	if(unlikely(debug))
2070	fprintf(stderr, "%s: calling send_ipmi_sensor_metrics_to_netdata()\n", program_name);
2071
2072	static bool add_func_sensors = true;
2073	if (add_func_sensors) {
2074	add_func_sensors = false;
2075	struct functions_evloop_globals *wg =
2076	functions_evloop_init(1, "FREEIPMI", &stdout_mutex, &function_plugin_should_exit, NULL);
2077	functions_evloop_add_function(
2078	wg, "ipmi-sensors", freeimi_function_sensors, PLUGINS_FUNCTIONS_TIMEOUT_DEFAULT, NULL);
2079	FREEIPMI_GLOBAL_FUNCTION_SENSORS();
2080	}
2081
2082	state.updates.now_ut = now_monotonic_usec();
2083	send_ipmi_sensor_metrics_to_netdata(&state);
2084
2085	if(netdata_do_sel)
2086	send_ipmi_sel_metrics_to_netdata(&state);
2087
2088	if(unlikely(debug))
2089	fprintf(stderr, "%s: iteration %zu, dt %"PRIu64" usec, sensors ever collected %zu, sensors last collected %zu \n"
2090	, program_name
2091	, iteration
2092	, dt
2093	, dictionary_entries(state.sensors.dict)
2094	, state.sensors.collected
2095	);
2096
2097	netdata_mutex_lock(&stdout_mutex);
2098
2099	if (!global_chart_created) {
2100	global_chart_created = true;
2101
2102	fprintf(stdout,
2103	"CHART netdata.freeipmi_availability_status '' 'Plugin availability status' 'status' "
2104	"plugins netdata.plugin_availability_status line 146000 %d '' '%s' '%s'\n"
2105	"DIMENSION available '' absolute 1 1\n",
2106	update_every, program_name, "");
2107	}
2108
2109	fprintf(stdout,
2110	"BEGIN netdata.freeipmi_availability_status\n"
2111	"SET available = 1\n"
2112	"END\n");
2113
2114	// restart check (14400 seconds)
2115	if (restart_every && (now_monotonic_sec() - started_t > IPMI_RESTART_EVERY_SECONDS)) {
2116	collector_info("%s(): reached my lifetime expectancy. Exiting to restart.", __FUNCTION__);
2117	fprintf(stdout, "EXIT\n");
2118	netdata_mutex_unlock(&stdout_mutex);
2119	plugin_exit(0);
2120	}
2121
2122	fflush(stdout);
2123
2124	netdata_mutex_unlock(&stdout_mutex);
2125	}
2126	}