From 8146e336d7057d2064ed43e6684a11f601c84f47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C5=99emysl=20Janouch?= Date: Fri, 22 Jan 2016 08:56:34 +0100 Subject: Add fancontrol-ng --- fancontrol-ng.c | 680 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 680 insertions(+) create mode 100644 fancontrol-ng.c (limited to 'fancontrol-ng.c') diff --git a/fancontrol-ng.c b/fancontrol-ng.c new file mode 100644 index 0000000..d68f2f0 --- /dev/null +++ b/fancontrol-ng.c @@ -0,0 +1,680 @@ +/* + * fancontrol-ng.c: clone of fancontrol from lm_sensors + * + * Copyright (c) 2016, Přemysl Janouch + * All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#define LIBERTY_WANT_POLLER + +#include "config.h" +#undef PROGRAM_NAME +#define PROGRAM_NAME "fancontrol-ng" +#include "liberty/liberty.c" + +/// Shorthand to set an error and return failure from the function +#define FAIL(...) \ + BLOCK_START \ + error_set (e, __VA_ARGS__); \ + return false; \ + BLOCK_END + +// --- Main program ------------------------------------------------------------ + +struct device +{ + LIST_HEADER (struct device) + + struct app_context *ctx; ///< Application context + struct config_item *config; ///< Configuration root for the device + char *path; ///< Base path + + struct poller_timer timer; ///< Refresh timer +}; + +struct app_context +{ + struct poller poller; ///< Poller + bool polling; ///< The event loop is running + + struct config_item *config; ///< Program configuration + struct device *devices; ///< All devices +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +log_message_custom (void *user_data, const char *quote, const char *fmt, + va_list ap) +{ + (void) user_data; + FILE *stream = stdout; + + // TODO: sd-daemon.h log level prefixes? + fputs (quote, stream); + vfprintf (stream, fmt, ap); + fputs ("\n", stream); +} + +static char * +read_file_cstr (const char *path, struct error **e) +{ + struct str s; + str_init (&s); + if (read_file (path, &s, e)) + return str_steal (&s); + str_free (&s); + return NULL; +} + +static int64_t +read_file_unsigned (const char *path, struct error **e) +{ + char *s, *end; + if (!(s = read_file_cstr (path, e))) + return -1; + if ((end = strpbrk (s, "\r\n"))) + *end = 0; + + unsigned long num; + bool ok = xstrtoul (&num, s, 10); + free (s); + + if (!ok || num > INT64_MAX) + { + error_set (e, "error reading `%s': %s", path, "invalid integer value"); + return -1; + } + return num; +} + +static bool +write_file_printf (const char *path, struct error **e, const char *format, ...) + ATTRIBUTE_PRINTF (3, 4); + +static bool +write_file_printf (const char *path, struct error **e, const char *format, ...) +{ + struct str s; + str_init (&s); + + va_list ap; + va_start (ap, format); + str_append_vprintf (&s, format, ap); + va_end (ap); + + bool success = write_file (path, s.str, s.len, e); + str_free (&s); + return success; +} + +// --- Configuration ----------------------------------------------------------- + +static bool +config_validate_nonnegative (const struct config_item *item, struct error **e) +{ + if (item->type == CONFIG_ITEM_NULL) + return true; + + hard_assert (item->type == CONFIG_ITEM_INTEGER); + if (item->value.integer >= 0) + return true; + + error_set (e, "must be non-negative"); + return false; +} + +static struct config_schema g_config_device[] = +{ + { .name = "name", + .comment = "Device identifier", + .type = CONFIG_ITEM_STRING }, + { .name = "interval", + .comment = "Temperature checking interval", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative, + .default_ = "5" }, + {} +}; + +static struct config_schema g_config_pwm[] = +{ + { .name = "temp", + .comment = "Path to temperature sensor output", + .type = CONFIG_ITEM_STRING }, + { .name = "min_temp", + .comment = "Temperature for no fan operation", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative, + .default_ = "40" }, + { .name = "max_temp", + .comment = "Temperature for maximum fan operation", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative, + .default_ = "80" }, + { .name = "min_start", + .comment = "Minimum value for the fan to start spinning", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative, + .default_ = "0" }, + { .name = "min_stop", + .comment = "Mimimum value for the fan to stop spinning", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative, + .default_ = "0" }, + { .name = "pwm_min", + .comment = "Minimum PWM value to use", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative }, + { .name = "pwm_max", + .comment = "Maximum PWM value to use", + .type = CONFIG_ITEM_INTEGER, + .validate = config_validate_nonnegative }, + {} +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static int64_t +get_config_integer (struct config_item *root, const char *key) +{ + struct config_item *item = config_item_get (root, key, NULL); + hard_assert (item && item->type == CONFIG_ITEM_INTEGER); + return item->value.integer; +} + +static const char * +get_config_string (struct config_item *root, const char *key) +{ + struct config_item *item = config_item_get (root, key, NULL); + hard_assert (item); + if (item->type == CONFIG_ITEM_NULL) + return NULL; + hard_assert (config_item_type_is_string (item->type)); + return item->value.string.str; +} + +// --- Fan control ------------------------------------------------------------- + +// Consider this a failed attempt to avoid creating special PWM objects +// based on the configuration. The complexity just moved somewhere else. + +struct paths +{ + char *temp; ///< Current temperature + char *pwm; ///< Current PWM value + char *pwm_enable; ///< PWM control state + char *pwm_min; ///< Minimum PWM value + char *pwm_max; ///< Maximum PWM value +}; + +static struct paths * +paths_new (const char *device_path, const char *path, struct config_item *pwm) +{ + struct paths *self = xcalloc (1, sizeof *self); + self->temp = xstrdup_printf + ("%s/%s", device_path, get_config_string (pwm, "temp")); + + self->pwm = xstrdup_printf ("%s/%s", device_path, path); + self->pwm_enable = xstrdup_printf ("%s/%s_enable", device_path, path); + self->pwm_min = xstrdup_printf ("%s/%s_min", device_path, path); + self->pwm_max = xstrdup_printf ("%s/%s_max", device_path, path); + return self; +} + +static void +paths_destroy (struct paths *self) +{ + free (self->temp); + + free (self->pwm); + free (self->pwm_enable); + free (self->pwm_min); + free (self->pwm_max); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static bool +pwm_update (struct paths *paths, struct config_item *pwm, struct error **e) +{ + int64_t cur_enable, cur_temp, cur_pwm, pwm_min, pwm_max; + if ((cur_enable = read_file_unsigned (paths->pwm_enable, e)) < 0 + || (cur_temp = read_file_unsigned (paths->temp, e)) < 0 + || (cur_pwm = read_file_unsigned (paths->pwm, e)) < 0) + return false; + + struct config_item *pwm_min_item = config_item_get (pwm, "pwm_min", NULL); + if (pwm_min_item->type == CONFIG_ITEM_INTEGER) + pwm_min = pwm_min_item->value.integer; + else if ((pwm_min = read_file_unsigned (paths->pwm_min, NULL)) < 0) + pwm_min = 0; + + struct config_item *pwm_max_item = config_item_get (pwm, "pwm_max", NULL); + if (pwm_max_item->type == CONFIG_ITEM_INTEGER) + pwm_max = pwm_max_item->value.integer; + else if ((pwm_max = read_file_unsigned (paths->pwm_max, NULL)) < 0) + pwm_max = 255; + + int64_t min_temp = get_config_integer (pwm, "min_temp"); + int64_t max_temp = get_config_integer (pwm, "max_temp"); + int64_t min_start = get_config_integer (pwm, "min_start"); + int64_t min_stop = get_config_integer (pwm, "min_stop"); + + if (min_temp >= max_temp) FAIL ("min_temp must be less than max_temp"); + if (pwm_max > 255) FAIL ("pwm_max must be at most 255"); + if (min_stop >= pwm_max) FAIL ("min_stop must be less than pwm_max"); + if (min_stop < pwm_min) FAIL ("min_stop must be at least pwm_min"); + + // I'm not sure if this strangely complicated computation is justifiable + double where + = ((double) cur_temp / 1000 - min_temp) + / ((double) max_temp - min_temp); + + int64_t new_pwm; + if (where <= 0) new_pwm = pwm_min; + else if (where >= 1) new_pwm = pwm_max; + else + { + new_pwm = min_stop + where * (pwm_max - min_stop); + + // If needed, we start the fan until next iteration + if (cur_pwm <= min_stop) + new_pwm = MAX (new_pwm, min_start); + } + + new_pwm = MAX (new_pwm, pwm_min); + new_pwm = MIN (new_pwm, pwm_max); + + if (cur_enable != 1 && !write_file_printf (paths->pwm_enable, e, "1")) + return false; + if (!write_file_printf (paths->pwm, e, "%" PRId64, new_pwm)) + return false; + return true; +} + +static bool +pwm_set_enable (struct paths *paths, char value) +{ + struct error *e = NULL; + if (write_file (paths->pwm_enable, &value, 1, &e)) + return true; + + print_error ("failed to change PWM mode to %c: %s", + value, e->message); + error_free (e); + return false; +} + +static bool +pwm_give_up (struct paths *paths) +{ + // Try automatic control, and if that fails, go full speed + return pwm_set_enable (paths, '2') || pwm_set_enable (paths, '0'); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +struct pwm_iter +{ + struct str_map_iter object_iter; ///< Configuration iterator + struct device *device; ///< Device + + struct config_item *pwm; ///< PWM + const char *pwm_path; ///< PWM path + struct paths *paths; ///< Paths +}; + +static void +pwm_iter_init (struct pwm_iter *self, struct device *device) +{ + str_map_iter_init (&self->object_iter, + &config_item_get (device->config, "pwms", NULL)->value.object); + self->device = device; + self->paths = NULL; +} + +static void +pwm_iter_free (struct pwm_iter *self) +{ + if (self->paths) + { + paths_destroy (self->paths); + self->paths = NULL; + } +} + +static bool +pwm_iter_next (struct pwm_iter *self) +{ + pwm_iter_free (self); + if (!(self->pwm = str_map_iter_next (&self->object_iter))) + return false; + + self->pwm_path = self->object_iter.link->key; + self->paths = paths_new (self->device->path, self->pwm_path, self->pwm); + return true; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +device_run (struct device *self) +{ + struct pwm_iter iter; + pwm_iter_init (&iter, self); + + while (pwm_iter_next (&iter)) + { + struct error *e = NULL; + if (pwm_update (iter.paths, iter.pwm, &e)) + continue; + + print_error ("pwm `%s': %s", iter.pwm_path, e->message); + error_free (e); + pwm_give_up (iter.paths); + } + + pwm_iter_free (&iter); + + poller_timer_set (&self->timer, + 1000 * get_config_integer (self->config, "interval")); +} + +static void +device_stop (struct device *self) +{ + struct pwm_iter iter; + pwm_iter_init (&iter, self); + + while (pwm_iter_next (&iter)) + pwm_give_up (iter.paths); + + pwm_iter_free (&iter); +} + +static void +device_create (struct app_context *ctx, const char *path, + struct config_item *root) +{ + struct device *self = xcalloc (1, sizeof *self); + self->config = root; + self->path = xstrdup (path); + + poller_timer_init (&self->timer, &ctx->poller); + self->timer.dispatcher = (poller_timer_fn) device_run; + self->timer.user_data = self; + + LIST_PREPEND (ctx->devices, self); +} + +// --- Configuration ----------------------------------------------------------- + +// TODO: consider moving to liberty, +// degesch and json-rpc-shell have exactly the same function +static struct config_item * +load_configuration_file (const char *filename, struct error **e) +{ + struct config_item *root = NULL; + + struct str data; + str_init (&data); + if (!read_file (filename, &data, e)) + goto end; + + struct error *error = NULL; + if (!(root = config_item_parse (data.str, data.len, false, &error))) + { + error_set (e, "parse error: %s", error->message); + error_free (error); + } +end: + str_free (&data); + return root; +} + +// There is no room for errors in the configuration, everything must be valid. +// Thus the reset to defaults on invalid values is effectively disabled here. +static bool +apply_schema (struct config_schema *schema, struct config_item *object, + struct error **e) +{ + struct error *warning = NULL, *error = NULL; + config_schema_initialize_item (schema, object, NULL, &warning, &error); + + if (error && warning) + { + error_free (warning); + error_propagate (e, error); + return false; + } + if (error) + { + error_propagate (e, error); + return false; + } + if (warning) + { + // The standard warning is inappropriate here + error_free (warning); + FAIL ("invalid item `%s'", schema->name); + } + return true; +} + +static bool +check_device_configuration (struct config_item *subtree, struct error **e) +{ + // Check regular fields in the device object + for (struct config_schema *s = g_config_device; s->name; s++) + if (!apply_schema (s, subtree, e)) + return false; + + // Check for a subobject with PWMs to control + struct config_item *pwms; + if (!(pwms = config_item_get (subtree, "pwms", e))) + return false; + if (pwms->type != CONFIG_ITEM_OBJECT) + FAIL ("`%s' is not an object", "pwms"); + if (!pwms->value.object.len) + FAIL ("no PWMs defined"); + + // Check regular fields in all PWM subobjects + struct str_map_iter iter; + str_map_iter_init (&iter, &pwms->value.object); + + struct config_item *pwm; + struct error *error = NULL; + while ((pwm = str_map_iter_next (&iter))) + { + const char *subpath = iter.link->key; + for (struct config_schema *s = g_config_pwm; s->name; s++) + if (!apply_schema (s, pwm, &error)) + { + error_set (e, "PWM `%s': %s", subpath, error->message); + error_free (error); + return false; + } + if (!get_config_string (pwm, "temp")) + FAIL ("PWM `%s': %s", subpath, "`temp' cannot be null"); + } + return true; +} + +static void +load_configuration (struct app_context *ctx, const char *config_path) +{ + struct error *e = NULL; + struct config_item *root = load_configuration_file (config_path, &e); + + if (e) + { + print_error ("error loading configuration: %s", e->message); + error_free (e); + exit (EXIT_FAILURE); + } + + struct str_map_iter iter; + str_map_iter_init (&iter, &(ctx->config = root)->value.object); + + struct config_item *subtree; + while ((subtree = str_map_iter_next (&iter))) + { + const char *path = iter.link->key; + if (subtree->type != CONFIG_ITEM_OBJECT) + print_fatal ("device `%s' in configuration is not an object", path); + else if (!check_device_configuration (subtree, &e)) + print_fatal ("device `%s': %s", path, e->message); + else + device_create (ctx, path, subtree); + } +} + +// --- Signals ----------------------------------------------------------------- + +static int g_signal_pipe[2]; ///< A pipe used to signal... signals + +static void +sigterm_handler (int signum) +{ + (void) signum; + + int original_errno = errno; + if (write (g_signal_pipe[1], "", 1) == -1) + soft_assert (errno == EAGAIN); + errno = original_errno; +} + +static void +setup_signal_handlers (void) +{ + if (pipe (g_signal_pipe) == -1) + exit_fatal ("%s: %s", "pipe", strerror (errno)); + + set_cloexec (g_signal_pipe[0]); + set_cloexec (g_signal_pipe[1]); + + // So that the pipe cannot overflow; it would make write() block within + // the signal handler, which is something we really don't want to happen. + // The same holds true for read(). + set_blocking (g_signal_pipe[0], false); + set_blocking (g_signal_pipe[1], false); + + (void) signal (SIGPIPE, SIG_IGN); + + struct sigaction sa; + sa.sa_flags = SA_RESTART; + sa.sa_handler = sigterm_handler; + sigemptyset (&sa.sa_mask); + + if (sigaction (SIGINT, &sa, NULL) == -1 + || sigaction (SIGTERM, &sa, NULL) == -1) + exit_fatal ("sigaction: %s", strerror (errno)); +} + +// --- Main program ------------------------------------------------------------ + +static void +on_signal_pipe_readable (const struct pollfd *fd, struct app_context *ctx) +{ + char id = 0; + (void) read (fd->fd, &id, 1); + + ctx->polling = false; +} + +static const char * +parse_program_arguments (int argc, char **argv) +{ + static const struct opt opts[] = + { + { 'd', "debug", NULL, 0, "run in debug mode" }, + { 'h', "help", NULL, 0, "display this help and exit" }, + { 'V', "version", NULL, 0, "output version information and exit" }, + { 0, NULL, NULL, 0, NULL } + }; + + struct opt_handler oh; + opt_handler_init (&oh, argc, argv, opts, "CONFIG", "Fan controller."); + + int c; + while ((c = opt_handler_get (&oh)) != -1) + switch (c) + { + case 'd': + g_debug_mode = true; + break; + case 'h': + opt_handler_usage (&oh, stdout); + exit (EXIT_SUCCESS); + case 'V': + printf (PROGRAM_NAME " " PROGRAM_VERSION "\n"); + exit (EXIT_SUCCESS); + default: + print_error ("wrong options"); + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + + argc -= optind; + argv += optind; + + if (argc != 1) + { + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + + opt_handler_free (&oh); + return argv[0]; +} + +int +main (int argc, char *argv[]) +{ + g_log_message_real = log_message_custom; + const char *config_path = parse_program_arguments (argc, argv); + + struct app_context ctx; + memset (&ctx, 0, sizeof ctx); + poller_init (&ctx.poller); + + setup_signal_handlers (); + + struct poller_fd signal_event; + poller_fd_init (&signal_event, &ctx.poller, g_signal_pipe[0]); + signal_event.dispatcher = (poller_fd_fn) on_signal_pipe_readable; + signal_event.user_data = &ctx; + poller_fd_set (&signal_event, POLLIN); + + load_configuration (&ctx, config_path); + + if (!ctx.devices) + exit_fatal ("no devices present in configuration"); + LIST_FOR_EACH (struct device, iter, ctx.devices) + device_run (iter); + + ctx.polling = true; + while (ctx.polling) + poller_run (&ctx.poller); + + LIST_FOR_EACH (struct device, iter, ctx.devices) + device_stop (iter); + + config_item_destroy (ctx.config); + poller_free (&ctx.poller); + return EXIT_SUCCESS; +} -- cgit v1.2.3