Ndctl monitor is used for monitoring the smart events of nvdimm DIMMs. When a smart event fires, monitor will output the notifications which including dimm health status and event infomations to syslog, stderr or a logfile by setting [--logfile] option. The notifications follow json format and can be consumed by log collectors like Fluentd. DIMMsto monitor can be selected by [--dimm] [--region] [--namespace] [--bus] options, and event type can be filtered by [--dimm-event] option, these options support mutiple space-seperated arguments. Ndctl monitor can be forked as a daemon by using [--daemon] option, like: # ndctl monitor --daemon --logfile /var/log/ndctl/monitor.log Signed-off-by: QI Fuli <qi.fuli(a)jp.fujitsu.com&gt; --- builtin.h | 1 + ndctl/Makefile.am | 3 +- ndctl/monitor.c | 532 ++++++++++++++++++++++++++++++++++++++++++++++ ndctl/ndctl.c | 1 + 4 files changed, 536 insertions(+), 1 deletion(-) create mode 100644 ndctl/monitor.c diff --git a/builtin.h b/builtin.h index d3cc723..675a6ce 100644 --- a/builtin.h +++ b/builtin.h @@ -39,6 +39,7 @@ int cmd_inject_error(int argc, const char **argv, void *ctx); int cmd_wait_scrub(int argc, const char **argv, void *ctx); int cmd_start_scrub(int argc, const char **argv, void *ctx); int cmd_list(int argc, const char **argv, void *ctx); +int cmd_monitor(int argc, const char **argv, void *ctx); #ifdef ENABLE_TEST int cmd_test(int argc, const char **argv, void *ctx); #endif diff --git a/ndctl/Makefile.am b/ndctl/Makefile.am index d22a379..7dbf223 100644 --- a/ndctl/Makefile.am +++ b/ndctl/Makefile.am @@ -16,7 +16,8 @@ ndctl_SOURCES = ndctl.c \ util/json-smart.c \ util/json-firmware.c \ inject-error.c \ - inject-smart.c + inject-smart.c \ + monitor.c if ENABLE_DESTRUCTIVE ndctl_SOURCES += ../test/blk_namespaces.c \ diff --git a/ndctl/monitor.c b/ndctl/monitor.c new file mode 100644 index 0000000..12aa499 --- /dev/null +++ b/ndctl/monitor.c @@ -0,0 +1,532 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright(c) 2018, FUJITSU LIMITED. All rights reserved. */ + +#include <stdio.h> +#include <json-c/json.h> +#include <libgen.h> +#include <dirent.h> +#include <util/log.h> +#include <util/json.h> +#include <util/filter.h> +#include <util/util.h> +#include <util/parse-options.h> +#include <util/strbuf.h> +#include <ndctl/lib/private.h> +#include <ndctl/libndctl.h> +#include <sys/stat.h> +#include <sys/epoll.h> +#define BUF_SIZE 2048 + +#define DIMM_SPARES_REMAINING (1 << 0) +#define DIMM_MEDIA_TEMPERATURE (1 << 1) +#define DIMM_CTRL_TEMPERATURE (1 << 2) +#define DIMM_HEALTH_STATE (1 << 3) +#define DIMM_UNCLEAN_SHUTDOWN (1 << 4) + +static enum log_destination { + LOG_DESTINATION_STDERR = 1, + LOG_DESTINATION_SYSLOG = 2, + LOG_DESTINATION_FILE = 3, +} log_destination = LOG_DESTINATION_SYSLOG; + +static struct { + const char *logfile; + const char *dimm_event; + bool daemon; +} monitor; + +struct monitor_dimm { + struct ndctl_dimm *dimm; + int health_eventfd; + unsigned int health; + unsigned int event_flags; + struct list_node list; +}; + +struct monitor_filter_arg { + struct list_head dimms; + int maxfd_dimm; + int num_dimm; + unsigned long flags; +}; + +struct util_filter_params param; + +static int did_fail; + +#define fail(fmt, ...) \ +do { \ + did_fail = 1; \ + err((struct ndctl_ctx *)ctx, "ndctl-%s:%s:%d: " fmt, \ + VERSION, __func__, __LINE__, ##__VA_ARGS__); \ +} while (0) + +static bool is_dir(char *filepath) +{ + DIR *dir = opendir(filepath); + if (dir) { + closedir(dir); + return true; + } + return false; +} + +static void logreport(struct ndctl_ctx *ctx, int priority, const char *file, + int line, const char *fn, const char *format, va_list args) +{ + char *log_dir; + FILE *f; + char *buf = (char *)malloc(BUF_SIZE); + vsnprintf(buf, BUF_SIZE, format, args); + + switch (log_destination) { + case LOG_DESTINATION_STDERR: + fprintf(stderr, "%s\n", buf); + goto end; + + case LOG_DESTINATION_SYSLOG: + syslog(priority, "%s\n", buf); + goto end; + + case LOG_DESTINATION_FILE: + log_dir = dirname(strdup(monitor.logfile)); + if (!log_dir) { + log_destination = LOG_DESTINATION_SYSLOG; + fail("strdup %s failed\n%s", monitor.logfile, buf); + goto end; + } + if (!is_dir(log_dir)) { + log_destination = LOG_DESTINATION_SYSLOG; + fail("dir: %s is required\n%s", log_dir, buf); + free(log_dir); + goto end; + } + f = fopen(monitor.logfile, "a+"); + if (!f) { + log_destination = LOG_DESTINATION_SYSLOG; + fail("open logfile %s failed\n%s", monitor.logfile, buf); + free(log_dir); + goto end; + } + fprintf(f, "%s\n", buf); + fclose(f); + free(log_dir); + goto end; + } +end: + free(buf); + return; +} + +static int get_monitor_dimm_data(struct monitor_dimm *mdimm) +{ + struct ndctl_cmd *cmd; + unsigned int alarm_flags; + + cmd = ndctl_dimm_cmd_new_smart(mdimm->dimm); + if (!cmd) + goto out; + + if (ndctl_cmd_submit(cmd)) + goto out; + + mdimm->health_eventfd = ndctl_dimm_get_health_eventfd(mdimm->dimm); + + alarm_flags = ndctl_cmd_smart_get_alarm_flags(cmd); + if (alarm_flags & ND_SMART_SPARE_TRIP) + mdimm->event_flags |= DIMM_SPARES_REMAINING; + if (alarm_flags & ND_SMART_MTEMP_TRIP) + mdimm->event_flags |= DIMM_MEDIA_TEMPERATURE; + if (alarm_flags & ND_SMART_CTEMP_TRIP) + mdimm->event_flags |= DIMM_CTRL_TEMPERATURE; + + mdimm->health = ndctl_cmd_smart_get_health(cmd); + + if (ndctl_cmd_smart_get_shutdown_state(cmd)) + mdimm->event_flags |= DIMM_UNCLEAN_SHUTDOWN; + + ndctl_cmd_unref(cmd); + return 0; +out: + if (cmd) + ndctl_cmd_unref(cmd); + return 1; +} + +static struct json_object *dimm_event_to_json(struct monitor_dimm *mdimm) +{ + struct json_object *jevent, *jobj, *jdimm_health, *jdimm_detect; + struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(mdimm->dimm); + + jevent = json_object_new_object(); + if (!jevent) { + fail("\n"); + return NULL; + } + + jdimm_health = json_object_new_array(); + jdimm_detect = json_object_new_array(); + if (!jdimm_health || !jdimm_detect) { + fail("\n"); + goto out; + } + + if (mdimm->event_flags & DIMM_SPARES_REMAINING) { + jobj = json_object_new_string("dimm-spares-remaining"); + if (!jobj) + goto out; + json_object_array_add(jdimm_health, jobj); + } + if (mdimm->event_flags & DIMM_MEDIA_TEMPERATURE) { + jobj = json_object_new_string("dimm-media-temperature"); + if (!jobj) + goto out; + json_object_array_add(jdimm_health, jobj); + } + if (mdimm->event_flags & DIMM_CTRL_TEMPERATURE) { + jobj = json_object_new_string("dimm-controller-temperature"); + if (!jobj) + goto out; + json_object_array_add(jdimm_health, jobj); + } + if (mdimm->event_flags & DIMM_HEALTH_STATE) { + jobj = json_object_new_string("dimm-health-state"); + if (!jobj) + goto out; + json_object_array_add(jdimm_health, jobj); + } + if (mdimm->event_flags & DIMM_UNCLEAN_SHUTDOWN) { + jobj = json_object_new_string("dimm-unclean-shutdown"); + if (!jobj) + goto out; + json_object_array_add(jdimm_detect, jobj); + } + + if (json_object_array_length(jdimm_health) > 0) + json_object_object_add(jevent, "dimm-health", jdimm_health); + else + free (jdimm_health); + + if (json_object_array_length(jdimm_detect) > 0) + json_object_object_add(jevent, "dimm-detect", jdimm_detect); + else + free (jdimm_detect); + + return jevent; +out: + if (jdimm_health) + free(jdimm_health); + if (jdimm_detect) + free(jdimm_detect); + free(jevent); + return NULL; +} + +static int notify_dimm_event(struct monitor_dimm *mdimm) +{ + struct json_object *jmsg, *jdimm, *jobj; + struct timespec ts; + char timestamp[32]; + struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(mdimm->dimm); + + jmsg = json_object_new_object(); + if (!jmsg) { + fail("\n"); + return -1; + } + + clock_gettime(CLOCK_REALTIME, &ts); + sprintf(timestamp, "%10ld.%09ld", ts.tv_sec, ts.tv_nsec); + jobj = json_object_new_string(timestamp); + if (!jobj) { + fail("\n"); + return -1; + } + json_object_object_add(jmsg, "timestamp", jobj); + + jobj = json_object_new_int(getpid()); + if (!jobj) { + fail("\n"); + return -1; + } + json_object_object_add(jmsg, "pid", jobj); + + jobj = dimm_event_to_json(mdimm); + if (!jobj) { + fail("\n"); + return -1; + } + json_object_object_add(jmsg, "event", jobj); + + jdimm = util_dimm_to_json(mdimm->dimm, 0); + if (!jdimm) { + fail("\n"); + return -1; + } + json_object_object_add(jmsg, "dimm", jdimm); + + jobj = util_dimm_health_to_json(mdimm->dimm); + if (!jobj) { + fail("\n"); + return -1; + } + json_object_object_add(jdimm, "health", jobj); + + notice(ctx, "%s", + json_object_to_json_string_ext(jmsg, JSON_C_TO_STRING_PLAIN)); + return 0; +} + +static struct monitor_dimm *util_dimm_event_filter(struct monitor_dimm *mdimm, + const char *__ident) +{ + char *ident, *save; + const char *name; + struct monitor_dimm *__mdimm; + struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(mdimm->dimm); + + __mdimm = calloc(1, sizeof(struct monitor_dimm)); + if (!__mdimm) { + fail("\n"); + return NULL; + } + + __mdimm->dimm = mdimm->dimm; + if (get_monitor_dimm_data(__mdimm)) { + fail("\n"); + goto out; + } + if (mdimm->health != __mdimm->health) + __mdimm->event_flags |= DIMM_HEALTH_STATE; + + if (!__ident) + return __mdimm; + + ident = strdup(__ident); + if (!ident) + goto out; + + for (name = strtok_r(ident, " ", &save); name; + name = strtok_r(NULL, " ", &save)) { + if (strcmp(name, "all") == 0) + break; + + if (strcmp(name, "dimm-spares-remaining") == 0) { + if (__mdimm->event_flags & DIMM_SPARES_REMAINING) + break; + } else if (strcmp(name, "dimm-media-temperature") == 0) { + if (__mdimm->event_flags & DIMM_MEDIA_TEMPERATURE) + break; + } else if (strcmp(name, "dimm-controller-temperature") == 0) { + if (__mdimm->event_flags & DIMM_CTRL_TEMPERATURE) + break; + } else if (strcmp(name, "dimm-health-state") == 0) { + if (__mdimm->event_flags & DIMM_HEALTH_STATE) + break; + } else if (strcmp(name, "dimm-unclean-shutdown") == 0) { + if (__mdimm->event_flags & DIMM_UNCLEAN_SHUTDOWN) + break; + } + } + free(ident); + + if (name) + return __mdimm; +out: + free(__mdimm); + return NULL; +} + +static bool filter_region(struct ndctl_region *region, + struct util_filter_ctx *ctx) +{ + return true; +} + +static void filter_dimm(struct ndctl_dimm *dimm, struct util_filter_ctx *ctx) +{ + struct monitor_dimm *mdimm, *__mdimm; + struct monitor_filter_arg *mfa = (struct monitor_filter_arg *)ctx->arg; + + if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_SMART_THRESHOLD)) + return; + + if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_SMART)) + return; + + mdimm = calloc(1, sizeof(struct monitor_dimm)); + if (!mdimm) + return; + + mdimm->dimm = dimm; + if (get_monitor_dimm_data(mdimm)) + goto out; + + if (mdimm->event_flags) { + __mdimm = util_dimm_event_filter(mdimm, monitor.dimm_event); + if (__mdimm) { + if (notify_dimm_event(__mdimm)) + fail("notify dimm event failed\n"); + free(__mdimm); + } + } + + list_add_tail(&mfa->dimms, &mdimm->list); + if (mdimm->health_eventfd > mfa->maxfd_dimm) + mfa->maxfd_dimm = mdimm->health_eventfd; + mfa->num_dimm++; + return; +out: + free(mdimm); + return; +} + +static bool filter_bus(struct ndctl_bus *bus, struct util_filter_ctx *ctx) +{ + return true; +} + +static int monitor_event(struct ndctl_ctx *ctx, + struct monitor_filter_arg *mfa) +{ + struct epoll_event ev, *events; + int nfds, epollfd, i, rc; + struct monitor_dimm *mdimm, *__mdimm; + char buf; + + events = malloc(sizeof(struct epoll_event) * mfa->num_dimm); + if (!events) { + fail("malloc for events error\n"); + goto out; + } + epollfd = epoll_create1(0); + if (epollfd == -1) { + fail("epoll_create1 error\n"); + goto out; + } + list_for_each(&mfa->dimms, mdimm, list) { + memset(&ev, 0, sizeof(ev)); + rc = pread(mdimm->health_eventfd, &buf, sizeof(buf), 0); + if (rc < 0) { + fail("pread error\n"); + goto out; + } + ev.data.ptr = mdimm; + if (epoll_ctl(epollfd, EPOLL_CTL_ADD, + mdimm->health_eventfd, &ev) != 0) { + fail("epoll_ctl error\n"); + goto out; + } + } + + while (1) { + did_fail = 0; + nfds = epoll_wait(epollfd, events, mfa->num_dimm, -1); + if (nfds <= 0) { + fail("epoll_wait error\n"); + goto out; + } + for (i = 0; i < nfds; i++) { + mdimm = events[i].data.ptr; + __mdimm = util_dimm_event_filter(mdimm, + monitor.dimm_event); + if (__mdimm) { + if (notify_dimm_event(__mdimm)) + fail("notify dimm event failed\n"); + free(__mdimm); + } + rc = pread(mdimm->health_eventfd, &buf, sizeof(buf), 0); + if (rc < 0) { + fail("pread error\n"); + goto out; + } + } + if (did_fail) + goto out; + } + return 0; +out: + return 1; +} + +int cmd_monitor(int argc, const char **argv, void *ctx) +{ + int i; + const struct option options[] = { + OPT_STRING('b', "bus", &param.bus, "bus-id", "filter by bus"), + OPT_STRING('r', "region", &param.region, "region-id", + "filter by region"), + OPT_STRING('d', "dimm", &param.dimm, "dimm-id", + "filter by dimm"), + OPT_STRING('n', "namespace", &param.namespace, + "namespace-id", "filter by namespace id"), + OPT_FILENAME('l', "logfile", &monitor.logfile, + "file | syslog | stderr", + "where to output the monitor's notification"), + OPT_BOOLEAN('f', "daemon", &monitor.daemon, + "run ndctl monitor as a daemon"), + OPT_STRING('D', "dimm-event", &monitor.dimm_event, + "dimm-spares-remaining | dimm-media-temperature | dimm-controller-temperature | dimm-health-state | dimm-unclean-shutdown", + "filter by DIMM event type"), + OPT_END(), + }; + const char * const u[] = { + "ndctl monitor [<options>]", + NULL + }; + const char *prefix = "./"; + struct util_filter_ctx fctx = { 0 }; + struct monitor_filter_arg mfa = { 0 }; + + argc = parse_options_prefix(argc, argv, prefix, options, u, 0); + for (i = 0; i < argc; i++) { + error("unknown parameter \"%s\"\n", argv[i]); + } + if (argc) + usage_with_options(u, options); + + ndctl_set_log_fn((struct ndctl_ctx *)ctx, logreport); + ndctl_set_log_priority((struct ndctl_ctx *)ctx, LOG_INFO); + + if (monitor.logfile) { + if (strcmp(monitor.logfile, "./stderr") == 0) + log_destination = LOG_DESTINATION_STDERR; + else if (strcmp(monitor.logfile, "./syslog") == 0) + log_destination = LOG_DESTINATION_SYSLOG; + else + log_destination = LOG_DESTINATION_FILE; + } + + if (monitor.daemon) { + if (daemon(0, 0) != 0) { + fail("daemon start failed\n"); + goto out; + } + info((struct ndctl_ctx *)ctx, "ndctl monitor daemon started\n"); + } + + fctx.filter_bus = filter_bus; + fctx.filter_dimm = filter_dimm; + fctx.filter_region = filter_region; + fctx.filter_namespace = NULL; + fctx.arg = &mfa; + list_head_init(&mfa.dimms); + mfa.num_dimm = 0; + mfa.maxfd_dimm = -1; + mfa.flags = 0; + + if (util_filter_walk(ctx, &fctx, &param)) + goto out; + + if (!mfa.num_dimm) { + fail("no dimms can be monitored\n"); + goto out; + } + + if (monitor_event(ctx, &mfa)) + goto out; + + return 0; +out: + return 1; +} diff --git a/ndctl/ndctl.c b/ndctl/ndctl.c index 7daadeb..73dabfa 100644 --- a/ndctl/ndctl.c +++ b/ndctl/ndctl.c @@ -89,6 +89,7 @@ static struct cmd_struct commands[] = { { "wait-scrub", cmd_wait_scrub }, { "start-scrub", cmd_start_scrub }, { "list", cmd_list }, + { "monitor", cmd_monitor}, { "help", cmd_help }, #ifdef ENABLE_TEST { "test", cmd_test }, -- 2.17.1

This patch adds the main configuration file(/etc/ndctl/monitor.conf) of ndctl monitor. It contains the configuration directives that give ndctl monitor instructions. Users can change the configuration by editing this file or by using [--config-file=<file>] option to override this file. The changed value will work after resetart ndctl monitor service. Signed-off-by: QI Fuli <qi.fuli(a)jp.fujitsu.com&gt; --- ndctl/Makefile.am | 5 ++ ndctl/monitor.c | 115 +++++++++++++++++++++++++++++++++++++++++++++ ndctl/monitor.conf | 42 +++++++++++++++++ 3 files changed, 162 insertions(+) create mode 100644 ndctl/monitor.conf diff --git a/ndctl/Makefile.am b/ndctl/Makefile.am index 7dbf223..ae3d894 100644 --- a/ndctl/Makefile.am +++ b/ndctl/Makefile.am @@ -42,3 +42,8 @@ ndctl_SOURCES += ../test/libndctl.c \ ../test/multi-pmem.c \ ../test/core.c endif + +monitor_config_file = monitor.conf +monitor_configdir = /etc/ndctl/ +monitor_config_DATA = $(monitor_config_file) +EXTRA_DIST += $(monitor_config_file) diff --git a/ndctl/monitor.c b/ndctl/monitor.c index 12aa499..8ac20ac 100644 --- a/ndctl/monitor.c +++ b/ndctl/monitor.c @@ -31,6 +31,7 @@ static enum log_destination { static struct { const char *logfile; + const char *config_file; const char *dimm_event; bool daemon; } monitor; @@ -71,6 +72,19 @@ static bool is_dir(char *filepath) return false; } +static void set_config(const char **arg, char *val) +{ + struct strbuf value = STRBUF_INIT; + size_t arg_len = *arg ? strlen(*arg) : 0; + + if (arg_len) { + strbuf_add(&value, *arg, arg_len); + strbuf_addstr(&value, " "); + } + strbuf_addstr(&value, val); + *arg = strbuf_detach(&value, NULL); +} + static void logreport(struct ndctl_ctx *ctx, int priority, const char *file, int line, const char *fn, const char *format, va_list args) { @@ -449,6 +463,102 @@ out: return 1; } +static int read_config_file(struct ndctl_ctx *ctx, const char *prefix) +{ + FILE *f; + int line = 0; + size_t len = 0; + char *buf, *value; + char *config_file = "/etc/ndctl/monitor.conf"; + + buf = (char *)malloc(BUF_SIZE); + if (!buf) { + fail("malloc read config-file buf error\n"); + goto out; + } + if (monitor.config_file) { + fix_filename(prefix, (const char **)&monitor.config_file); + config_file = (char *)monitor.config_file; + } + + f = fopen(config_file, "r"); + if (!f) { + fail("config-file: %s cannot be opened\n", config_file); + goto out; + } + + while (fgets(buf, BUF_SIZE, f)) { + value = NULL; + line++; + + while (isspace(*buf)) + buf++; + + if (*buf == '#' || *buf == '\0') + continue; + + value = strchr(buf, '='); + if (!value) { + fail("config-file syntax error, skip line[%i]\n", line); + continue; + } + + value[0] = '\0'; + value++; + + while (isspace(value[0])) + value++; + + len = strlen(buf); + if (len == 0) + continue; + while (isspace(buf[len-1])) + len--; + buf[len] = '\0'; + + len = strlen(value); + if (len == 0) + continue; + while (isspace(value[len-1])) + len--; + value[len] = '\0'; + + if (len == 0) + continue; + + if (strcmp(buf, "bus") == 0) { + set_config((const char **)&param.bus, value); + continue; + } + if (strcmp(buf, "dimm") == 0) { + set_config((const char **)&param.dimm, value); + continue; + } + if (strcmp(buf, "region") == 0) { + set_config((const char **)&param.region, value); + continue; + } + if (strcmp(buf, "namespace") == 0) { + set_config((const char **)&param.namespace, value); + continue; + } + if (strcmp(buf, "dimm-event") == 0) { + set_config((const char **)&monitor.dimm_event, value); + continue; + } + if (strcmp(buf, "logfile") == 0) { + if (monitor.logfile) + continue; + set_config((const char **)&monitor.logfile, value); + fix_filename(prefix, (const char **)&monitor.logfile); + } + } + fclose(f); + return 0; +out: + return 1; +} + int cmd_monitor(int argc, const char **argv, void *ctx) { int i; @@ -463,6 +573,8 @@ int cmd_monitor(int argc, const char **argv, void *ctx) OPT_FILENAME('l', "logfile", &monitor.logfile, "file | syslog | stderr", "where to output the monitor's notification"), + OPT_FILENAME('c', "config-file", &monitor.config_file, + "config-file", "override the default config"), OPT_BOOLEAN('f', "daemon", &monitor.daemon, "run ndctl monitor as a daemon"), OPT_STRING('D', "dimm-event", &monitor.dimm_event, @@ -488,6 +600,9 @@ int cmd_monitor(int argc, const char **argv, void *ctx) ndctl_set_log_fn((struct ndctl_ctx *)ctx, logreport); ndctl_set_log_priority((struct ndctl_ctx *)ctx, LOG_INFO); + if (read_config_file((struct ndctl_ctx *)ctx, prefix)) + goto out; + if (monitor.logfile) { if (strcmp(monitor.logfile, "./stderr") == 0) log_destination = LOG_DESTINATION_STDERR; diff --git a/ndctl/monitor.conf b/ndctl/monitor.conf new file mode 100644 index 0000000..590f1c4 --- /dev/null +++ b/ndctl/monitor.conf @@ -0,0 +1,42 @@ +# This is the main ndctl monitor configuration file. It contains the +# configuration directives that give ndctl monitor instructions. +# You can change the configuration of ndctl monitor by editing this +# file or by using [--config-file=<file>] option to override this one. +# The changed value will work after restart ndctl monitor service. + +# In this file, lines starting with a hash (#) are comments. +# The configurations shold follow <key> = <value> style. +# Multiple space-seperated values are allowed, but except the following +# charecters: : # ? / \ % " ' + +# The dimms to monitor are filtered via dimm's name by setting key "dimm". +# If this value is different from the value of [--dimm=<value>] option, +# both of the values will work. +# dimm = all + +# The dimms to monitor are filtered via its parent bus by setting key "bus". +# If this value is different from the value of [--bus=<value>] option, +# both of the values will work. +# bus = all + +# The dimms to monitor are filtered via region by setting key "region". +# If this value is different from the value of [--region=<value>] option, +# both of the values will work. +# region = all + +# The dimms to monitor are filtered via namespace by setting key "namespace". +# If this value is different from the value of [--namespace=<value>] option, +# both of the values will work. +# namespace = all + +# The DIMM events to monitor are filtered via event type by setting key +# "dimm-event". If this value is different from the value of +# [--dimm-event=<value>] option, both of the values will work. +# dimm-event = all + +# Users can choose to output the notifications to syslog (logfile=syslog), +# stderr (logfile=stderr) or to write into a special file (logfile=<file>) +# by setting key "logfile". +# If this value is in conflict with the value of [--logfile=<value>] option, +# this value will be ignored. +# logfile = /var/log/ndctl/monitor.log -- 2.17.1

Hi Dan, Thanks for your comments. Ok, I will add it in the second implementation. Ok, I will refactor it. Ok, I see. Could you please tell me more about the helper which do the strcmp() and return the value? I think the helper should return a flag, because we need to use continue statement to cause a jump in the while loop.

This patch adds the systemd unit file for ndctl-monitor service. The systemd unit directory can be configured by setting environment variable "--with-systemd-unit-dir[=DIR]". A monitor daemon can be started as a system service: # systemctl start ndctl-monitor.service Signed-off-by: QI Fuli <qi.fuli(a)jp.fujitsu.com&gt; --- autogen.sh | 3 ++- configure.ac | 22 ++++++++++++++++++++++ ndctl/Makefile.am | 4 ++++ ndctl/ndctl-monitor.service | 7 +++++++ 4 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 ndctl/ndctl-monitor.service diff --git a/autogen.sh b/autogen.sh index 2a52688..21b0e25 100755 --- a/autogen.sh +++ b/autogen.sh @@ -17,7 +17,8 @@ libdir() { args="--prefix=/usr \ --sysconfdir=/etc \ ---libdir=$(libdir /usr/lib)" +--libdir=$(libdir /usr/lib) \ +--with-systemd-unit-dir" echo echo "----------------------------------------------------------------" diff --git a/configure.ac b/configure.ac index 17b5a65..4013599 100644 --- a/configure.ac +++ b/configure.ac @@ -140,6 +140,27 @@ AC_CHECK_FUNCS([ \ secure_getenv\ ]) +PKG_PROG_PKG_CONFIG +AC_ARG_WITH([systemd-unit-dir], + AS_HELP_STRING([--with-systemd-unit-dir[=DIR]], + [Directory for systemd service files]), + [], + [with_systemd_unit_dir=yes]) + +if test "x$with_systemd_unit_dir" = "xyes"; then + def_systemd_unit_dir=$($PKG_CONFIG --variable=systemdsystemunitdir systemd) + if test "x$def_systemd_unit_dir" = "x"; then + AC_MSG_ERROR([systemd support requested but pkg-config unable to query systemd package]) + with_systemd_unit_dir=no + else + with_systemd_unit_dir="$def_systemd_unit_dir" + fi +fi + +AS_IF([test "x$with_systemd_unit_dir" != "xno"], + [AC_SUBST([systemd_unitdir], [$with_systemd_unit_dir])]) +AM_CONDITIONAL([ENABLE_SYSTEMD_UNIT_DIR], [test "x$with_systemd_unit_dir" != "xno"]) + my_CFLAGS="\ -Wall \ -Wchar-subscripts \ @@ -181,6 +202,7 @@ AC_MSG_RESULT([ sysconfdir: ${sysconfdir} libdir: ${libdir} includedir: ${includedir} + systemd-unit-dir: ${systemd_unitdir} compiler: ${CC} cflags: ${CFLAGS} diff --git a/ndctl/Makefile.am b/ndctl/Makefile.am index ae3d894..9d008d5 100644 --- a/ndctl/Makefile.am +++ b/ndctl/Makefile.am @@ -47,3 +47,7 @@ monitor_config_file = monitor.conf monitor_configdir = /etc/ndctl/ monitor_config_DATA = $(monitor_config_file) EXTRA_DIST += $(monitor_config_file) + +if ENABLE_SYSTEMD_UNIT_DIR +systemd_unit_DATA = ndctl-monitor.service +endif diff --git a/ndctl/ndctl-monitor.service b/ndctl/ndctl-monitor.service new file mode 100644 index 0000000..44f9326 --- /dev/null +++ b/ndctl/ndctl-monitor.service @@ -0,0 +1,7 @@ +[Unit] +Description=Ndctl Monitor Daemon + +[Service] +Type=forking +ExecStart=/usr/bin/ndctl monitor --daemon +ExecStop=/bin/kill ${MAINPID} -- 2.17.1