Add posibility to run faultd in faultctl mode

faultctl is a symlink to faultd running in ctl mode.
It's main functionality for now is to show all events stored
in database.

Change-Id: Ic47c8f261fc50778a2514b6273885df8a9ca1824
Signed-off-by: Konrad Kuchciak <k.kuchciak@samsung.com>

diff --git a/packaging/faultd.spec b/packaging/faultd.spec
index e7c846fc2e267c51c136e3033f68e7c04abce8bf..7558ce35f58d37508d184804016a08d162f663c2 100644 (file)
--- a/packaging/faultd.spec
+++ b/packaging/faultd.spec
@@ -62,6 +62,8 @@ make check
 mkdir -p %{buildroot}/%{_unitdir}/basic.target.wants
 ln -s ../faultd.service %{buildroot}/%{_unitdir}/basic.target.wants
 
+ln -s %{_sbindir}/faultd %{buildroot}/%{_sbindir}/faultctl
+
 %define moduledir %{_libdir}/faultd/available-modules/
 %define moduleconfdir %{_sysconfdir}/faultd/available-modules/
 %define enabled_moduledir %{_sysconfdir}/faultd/enabled-modules/
@@ -109,6 +111,7 @@ echo %{enabled_moduledir}/%{database_module}.so >> faultd-extra-files;
 %manifest %{name}.manifest
 %{_localstatedir}/db/faultd
 %{_sbindir}/faultd
+%{_sbindir}/faultctl
 %{_prefix}/lib/faultd/faultd.conf
 %{_prefix}/lib/faultd/service.conf.d/dbus.service.conf.d/50-default.conf
 %{_prefix}/lib/faultd/service.conf.d/display-manager.service.conf.d/50-default.conf

diff --git a/src/core/database.c b/src/core/database.c
index 57a2061501c1d4d1b687ef587fcea0f8b2989c45..a8b7297999eba954b6e3de7f6b2557ecd03611ee 100644 (file)
--- a/src/core/database.c
+++ b/src/core/database.c
@@ -132,3 +132,61 @@ cleanup:
        faultd_object_unref(obj);
        return ret;
 }
+
+int database_dump(struct faultd_object **out)
+{
+       struct faultd_object *query, *query_child, *result;
+       uint32_t num;
+       int ret;
+
+       ret = faultd_object_new_flags(&query_child, FAULTD_FLAG_QUERY_MODE);
+       if (ret < 0) {
+               log_error("Unable to create faultd_object");
+               goto error;
+       }
+
+       ret = faultd_object_append_string(query_child, "$not", "magicstring");
+       if (ret < 0) {
+               log_error("Unable to append string to faultd_object");
+               goto unref_query_child;
+       }
+
+       ret = faultd_object_new_flags(&query, FAULTD_FLAG_QUERY_MODE);
+       if (ret < 0) {
+               log_error("Unable to create faultd_object");
+               goto unref_query_child;
+       }
+
+       ret = faultd_object_append_object(query, database_get_id_key(), query_child);
+       if (ret < 0) {
+               log_error("Unable to append string to faultd_object");
+               faultd_object_unref(query);
+               goto unref_query_child;
+       }
+
+       faultd_object_unref(query_child);
+
+       ret = faultd_object_new(&result);
+       if (ret < 0) {
+               log_error("Unable to create faultd_object");
+               faultd_object_unref(query);
+               goto error;
+       }
+
+       ret = database_load(query, NULL, result, &num);
+       faultd_object_unref(query);
+       if (ret < 0) {
+               log_error("Unable to load from database");
+               faultd_object_unref(result);
+               goto error;
+       }
+
+       *out = result;
+       return 0;
+
+unref_query_child:
+       faultd_object_unref(query_child);
+error:
+       *out = NULL;
+       return ret;
+}

diff --git a/src/core/database.h b/src/core/database.h
index 85c4a2bcf23b137257264eea6e1f9a3f65d1b19c..db7b9ce35761fec22e05f0190f3b3b7436b9344a 100644 (file)
--- a/src/core/database.h
+++ b/src/core/database.h
@@ -63,5 +63,6 @@ int database_get_well_known_oid(const char *name, faultd_oid_t *oid);
 bool database_is_oid_valid(faultd_oid_t *oid);
 const char *database_get_id_key(void);
 int database_get_event(faultd_oid_t *oid, struct faultd_event **ev);
+int database_dump(struct faultd_object **out);
 
 #endif /* _DATABASE_H_ */

diff --git a/src/faultd.c b/src/faultd.c
index 9d2c606f31515c838358891e26083cb766de2da9..43d57fda9234e6ed9abe2d3c6b2a9ea99de283c5 100644 (file)
--- a/src/faultd.c
+++ b/src/faultd.c
@@ -34,9 +34,17 @@
 #include "common.h"
 #include "faultd-glib.h"
 #include "json-config.h"
+#include "database.h"
 
 static int terminate = 0;
 
+enum faultd_running_modes {
+       FAULTD_MODE_NORMAL,
+       FAULTD_MODE_CTL,
+};
+
+static int running_mode = FAULTD_MODE_NORMAL;
+
 static int signal_handler(sd_event_source *s,
                                   const struct signalfd_siginfo *si,
                                   void *userdata)
@@ -51,22 +59,41 @@ static int signal_handler(sd_event_source *s,
 static void print_help(const char *name)
 {
        printf("Usage: %s [OPTIONS]\n"
-                       "Options: \n"
-                       "  --log-level <level>            Set log level to <level>\n"
-                       "  -D                             Set log level to debug\n"
-                       "  -d, --disable-module <module>  Disable <module>\n"
-                       "  --no-action                    Do not execute any action\n"
-                       "  -c, --config-file <file>       Read faultd configuration from <file>\n"
-                       "  -h, --help                     Display this help and exit\n", name);
+                  "Options: \n"
+                  "  --log-level <level>            Set log level to <level>\n"
+                  "  -D                             Set log level to debug\n"
+                  "  -c, --config-file <file>       Read faultd configuration from <file>\n",
+                  name);
+
+       switch (running_mode) {
+       case FAULTD_MODE_NORMAL:
+               printf("  -d, --disable-module <module>  Disable <module>\n"
+                          "  --no-action                    Do not execute any action\n");
+               break;
+
+       case FAULTD_MODE_CTL:
+               /* No command line arguments for now */;
+               break;
+       }
+
+       printf("  -h, --help                     Display this help and exit\n");
 }
 
 static int parse_argv(int ac, char *av[])
 {
        int c, r;
+
+       #define CHECK_MODE(m) \
+               if (running_mode != m) { \
+                       print_help(av[0]); \
+                       return -EINVAL; \
+               }
+
        enum {
                ARG_LOG_LEVEL = 0x100,
                ARG_NO_ACTION,
        };
+
        static const struct option options[] = {
                {"log-level", required_argument, NULL, ARG_LOG_LEVEL},
                {"disable-module", required_argument, NULL, 'd'},
@@ -79,9 +106,11 @@ static int parse_argv(int ac, char *av[])
        struct faultd_module *module;
        const char *custom_config_file = FAULTD_CUSTOM_CONFIG_FILE;
 
+       if (strcmp(basename(av[0]), "faultctl") == 0)
+               running_mode = FAULTD_MODE_CTL;
+
        while ((c = getopt_long(ac, av, "Dc:d:h", options, NULL)) >= 0) {
                switch (c) {
-
                case ARG_LOG_LEVEL:
                        r = log_parse_level_name(optarg);
                        if (r < 0) {
@@ -102,7 +131,10 @@ static int parse_argv(int ac, char *av[])
                case 'h':
                        print_help(av[0]);
                        exit(0);
+
                case 'd':
+                       CHECK_MODE(FAULTD_MODE_NORMAL);
+
                        module = faultd_get_module_by_name(optarg);
                        if (module) {
                                module->disabled = 1;
@@ -114,6 +146,8 @@ static int parse_argv(int ac, char *av[])
                        break;
 
                case ARG_NO_ACTION:
+                       CHECK_MODE(FAULTD_MODE_NORMAL);
+
                        faultd_disable_module_category(FAULTD_MODULE_TYPE_ACTION);
                        break;
 
@@ -124,6 +158,7 @@ static int parse_argv(int ac, char *av[])
        }
 
        return faultd_load_config(custom_config_file);
+       #undef CHECK_MODE
 }
 
 int main(int ac, char *av[])
@@ -183,22 +218,63 @@ int main(int ac, char *av[])
 
        faultd_get_modules_config(&modules_config);
 
-       rc = faultd_modules_init(loop, modules_config);
-       if (rc < 0) {
-               log_error("Failed to initialize modules %d.", rc);
-               return -1;
-       }
+       switch (running_mode) {
+       case FAULTD_MODE_NORMAL:
+               rc = faultd_modules_init(loop, modules_config);
+               if (rc < 0) {
+                       log_error("Failed to initialize modules %d.", rc);
+                       return -1;
+               }
 
-       printf("Hello world!\n");
+               printf("Hello world!\n");
 
 #ifdef FAULTD_GLIB_MAINLOOP
-       rc = faultd_g_main_loop_wrapper(loop);
+               rc = faultd_g_main_loop_wrapper(loop);
 #else
-       rc = sd_event_loop(loop);
+               rc = sd_event_loop(loop);
 #endif /* FAULTD_GLIB_MAINLOOP */
 
-       if (rc < 0)
-               log_error_errno(rc, "Failed to run main loop: %m");
+               if (rc < 0)
+                       log_error_errno(rc, "Failed to run main loop: %m");
+               break;
+
+       case FAULTD_MODE_CTL:
+       {
+               struct faultd_object *result = NULL;
+               char *buf = NULL;
+
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_UNCATEGORIZED);
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_EVENT);
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_ACTION_EXECUTOR);
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_ACTION);
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_DECISION_MAKER);
+               faultd_disable_module_category(FAULTD_MODULE_TYPE_LISTENER);
+
+               rc = faultd_modules_init(loop, modules_config);
+               if (rc < 0) {
+                       log_error("Failed to initialize modules %d.", rc);
+                       return -1;
+               }
+
+               rc = database_dump(&result);
+               if (rc < 0) {
+                       log_error("Failed to dump database");
+                       return -1;
+               }
+
+               rc = faultd_object_to_string(&buf, result, 0);
+               faultd_object_unref(result);
+               if (rc < 0) {
+                       log_error("Unable to convert faultd object to string");
+                       return -1;
+               }
+
+               printf("%s\n", buf);
+
+               free(buf);
+               break;
+       }
+       }
 
        faultd_modules_cleanup();
        faultd_config_cleanup_global();