Compilation fixi

- Event FW added
- Audit listener reworked to generate suitable module
- Simple decision maker to always restart the service
- Compiled but not tested

Signed-off-by: Krzysztof Opasiak <k.opasiak@samsung.com>

diff --git a/Makefile.am b/Makefile.am
index 9cd7229d3c38cb1c6c1316fa9bdb3383f4dbf0ec..efd29802515c679c161eb6f746231e43b84c77e5 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -7,7 +7,10 @@ AM_CPPFLAGS = \
        -include $(top_builddir)/config.h \
        -DSYSCONFDIR=\""$(sysconfdir)"\" \
        -I${top_srcdir}/src \
-        -I${top_srcdir}/src/core
+        -I${top_srcdir}/src/core \
+        -I${top_srcdir}/src/event_types \
+        -I${top_srcdir}/src/listeners \
+        -I${top_srcdir}/src/decision_makers
 
 AM_CFLAGS = ${my_CFLAGS}
 

diff --git a/src/core/notify_queue.h b/src/core/notify_queue.h
index 43274fd41c63cc66d6f11358b398c06128ca8443..6bdfb8dd84aa390c95bd85bb70774e7db24e4ab0 100644 (file)
--- a/src/core/notify_queue.h
+++ b/src/core/notify_queue.h
@@ -67,7 +67,8 @@ static inline int nqueue_append(struct nqueue_head *head,
         ssize_t ret__;                                                  \
         uint64_t buf__;                                                 \
         ret__ = read((head)->fd, &buf__, sizeof(buf__));                \
-        return ret__ > 0 && buf__ > 0 ? queue_pop(&(head)->qhead) : NULL; \
+        ret__ > 0 && buf__ > 0 ?                                        \
+                queue_pop(&(head)->qhead, type, member) : NULL;         \
 })
 
 #define nqueue_empty(head) queue_empty(&(head)->qhead)

diff --git a/src/core/uref.h b/src/core/uref.h
index a68e7b305a890b0c2fe8aaa543dfec33a3b036d2..536b9e3488a156f6d4d2384f9a6e1f3a64e4fd17 100644 (file)
--- a/src/core/uref.h
+++ b/src/core/uref.h
@@ -17,6 +17,8 @@
 #ifndef FAULTD_UREF_H
 #define FAULTD_UREF_H
 
+#include <assert.h>
+
 /* This is not thread safe! */
 struct uref {
        unsigned refcnt;

diff --git a/src/decision_makers/rv_dm.c b/src/decision_makers/rv_dm.c
index 87df85143efb405a398048459badd1562e5d2f68..468735bce8e3b03a5171112ed375970c439313cb 100644 (file)
--- a/src/decision_makers/rv_dm.c
+++ b/src/decision_makers/rv_dm.c
@@ -16,10 +16,13 @@
  * limitations under the License.
  */
 #include <malloc.h>
+#include <errno.h>
 
 #include "resource_violation_event.h"
 #include "decision_made_event.h"
 #include "action.h"
+#include "event_processor.h"
+#include "log.h"
 
 #define MODULE_NAME "resource_violation_decision_maker"
 
@@ -32,13 +35,13 @@ static int rv_event_match(struct faultd_event_handler *handler,
 
 static int rv_make_decision(struct faultd_event_handler *handler)
 {
-        struct faultd_event *ev = nqueue_pop(handler->evnet_queue,
+        struct faultd_event *ev = nqueue_pop(&handler->event_queue,
                                              struct faultd_event,
                                              nq_node);
         struct resource_violation_event *rv_ev = to_resource_violation_event(ev);
         struct faultd_event *new_ev;
         /* For now this is just hardcoded to restart the service */
-        struct dm_ev_data ev_data = {
+        struct dm_event_data ev_data = {
                 .reason = ev,
                 .who_made = MODULE_NAME,
                 .action = FAULTD_ACTION_SERVICE_RESTART_ID,
@@ -50,7 +53,7 @@ static int rv_make_decision(struct faultd_event_handler *handler)
         faultd_event_put(new_ev);
         if (!ev_data.action_data) {
                 log_error("Unable to duplicate service name");
-                goto cleanup;
+                return -ENOMEM;
         }
 
         ret = faultd_event_create(DECISION_MADE_EVENT_ID, &ev_data, &new_ev);
@@ -81,8 +84,9 @@ static struct faultd_event_handler resource_violation_event_handler = {
         .event_match = rv_event_match,
         .handle_event = rv_make_decision,
 
-        .node = LIST_HEAD_INIT(resource_violation_event_type.node),
+        .node = LIST_HEAD_INIT(resource_violation_event_handler.node),
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(resource_violation_event_handler,
-                           FAULTD_MODULE_TYPE_DECISION_MAKER)
+                              resource_violation_eh,
+                              FAULTD_MODULE_TYPE_DECISION_MAKER)

diff --git a/src/event.c b/src/event.c
index 1c52e9b06f7ad2f41e829d029c1be659fb824bfc..c82be7467c1307217a838adeff8d38d3e9776ca5 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -16,6 +16,8 @@
  * limitations under the License.
  */
 
+#include <errno.h>
+
 #include "event.h"
 #include "module.h"
 #include "common.h"
@@ -38,7 +40,7 @@ static void cleanup_event_factory(struct faultd_module *module)
 {
         struct event_factory *efactory = to_event_factory(module);
 
-        assert(list_is_empty(&efactory->types));
+        assert(list_empty(&efactory->types));
 }
 
 static struct event_factory event_factory = {
@@ -61,27 +63,28 @@ int faultd_event_type_register(struct faultd_event_type *new)
                 return -EINVAL;
 
         list_add_tail(&new->node, &event_factory.types);
+
+        return 0;
 }
 
 void faultd_event_type_unregister(struct faultd_event_type *type)
 {
-        if (list_is_empty(&type->node))
+        if (list_empty(&type->node))
                 return;
 
-        list_del_init(type->node);
+        list_del_init(&type->node);
 }
 
 int faultd_event_create(const char *type, void *data, struct faultd_event **ev)
 {
         struct faultd_event_type *ev_type;
-        struct faultd_event *ev;
         int ret;
 
         if (!type)
                 return -EINVAL;
 
         list_for_each_entry(ev_type, &event_factory.types, node)
-                if (strcmp(ev_type, type) == 0)
+                if (strcmp(ev_type->name, type) == 0)
                         break;
         if (&ev_type->node == &event_factory.types)
                 return -ENOENT;
@@ -95,12 +98,12 @@ static void release_faultd_event(struct uref *uref)
 {
         struct faultd_event *ev = container_of(uref, struct faultd_event, uref);
 
-        if (ev->ops->release)
-                ev->ops->release(ev);
+        if (ev->ops.release)
+                ev->ops.release(ev);
 }
 
-int faultd_event_init(struct faultd_event_type *ev_type, pid_t pid,
-                      char *service_name, struct faultd_event *ev)
+int faultd_event_init(struct faultd_event_type *ev_type,
+                      struct faultd_event *ev)
 {
         int ret;
 
@@ -108,8 +111,8 @@ int faultd_event_init(struct faultd_event_type *ev_type, pid_t pid,
         if (ret)
                 return ret;
 
-        ev->type = type;
-        ev->ops = type->default_ops;
+        ev->type = ev_type;
+        ev->ops = ev_type->default_ops;
 
         uref_init(&ev->uref, release_faultd_event);
         INIT_LIST_HEAD(&ev->node);

diff --git a/src/event.h b/src/event.h
index 63bf1f87c4ba261baa936cc4cf36a6934ec3dc6f..59846e0bc9747960c01e636009180695d0e02d86 100644 (file)
--- a/src/event.h
+++ b/src/event.h
@@ -20,16 +20,18 @@
 #define FAULTD_EVENT_H
 
 #include <time.h>
+#include <string.h>
 
 #include "uref.h"
 #include "list.h"
+#include "notify_queue.h"
 #include "module.h"
 
 struct faultd_event;
 
 struct faultd_event_ops {
         char *(*to_string)(struct faultd_event *);
-        void release(struct faultd_event *);
+        void (*release)(struct faultd_event *);
 };
 
 struct faultd_event_type {
@@ -44,7 +46,7 @@ struct faultd_event_type {
                               void *data, struct faultd_event **);
 
         /* To be used by event factory */
-        struct list_node node;
+        struct list_head node;
 };
 
 struct faultd_event {
@@ -65,26 +67,27 @@ struct faultd_event {
 int faultd_event_type_register(struct faultd_event_type *type);
 void faultd_event_type_unregister(struct faultd_event_type *type);
 
-#define FAULTD_EVENT_TYPE_REGISTER(EVENT_TYPE)                          \
-static int event_type_init(struct faultd_module *module, sd_event *event_loop) \
+#define FAULTD_EVENT_TYPE_REGISTER(EVENT_TYPE, NAME)                    \
+static int event_type_ ##NAME## _init(struct faultd_module *module,     \
+                                     sd_event *event_loop)              \
 {                                                                       \
         return faultd_event_type_register(&EVENT_TYPE);                 \
 }                                                                       \
                                                                         \
-static void event_type_cleanup(struct faultd_module *module)            \
+static void event_type_ ##NAME## _cleanup(struct faultd_module *module) \
 {                                                                       \
         faultd_event_type_unregister(&EVENT_TYPE);                      \
 }                                                                       \
                                                                         \
-static struct faultd_module event_type_module = {                       \
-        .name = EVENT_TYPE.name,                                        \
+static struct faultd_module event_type_ ##NAME## _module = {            \
+        .name = #NAME,                                                  \
         .type = FAULTD_MODULE_TYPE_EVENT,                               \
-        .init = event_type_init,                                        \
-        .cleanup = event_type_cleanup,                                  \
-        .node = LIST_HEAD_INIT(event_type_module.node),                 \
+        .init = event_type_ ##NAME## _init,                             \
+        .cleanup = event_type_ ##NAME## _cleanup,                       \
+        .node = LIST_HEAD_INIT(event_type_ ##NAME## _module.node),      \
 };                                                                      \
                                                                         \
-FAULTD_MODULE_REGISTER(&event_type_module)
+FAULTD_MODULE_REGISTER(&event_type_ ##NAME## _module)
 
 int faultd_event_create(const char *type, void *data, struct faultd_event **ev);
 
@@ -104,9 +107,14 @@ static inline int faultd_event_is_of_type(struct faultd_event *ev,
         return strcmp(ev->type->name, type) == 0;
 }
 
+static inline char *faultd_event_to_string(struct faultd_event *ev)
+{
+        return ev->ops.to_string(ev);
+}
+
 int faultd_event_init(struct faultd_event_type *ev_type,
                       struct faultd_event *ev);
 
-void faultd_event_cleanup(struct faultd_event *ev) {}
+static inline void faultd_event_cleanup(struct faultd_event *ev) {}
 
 #endif /* FAULTD_EVENT_H */

diff --git a/src/event_processor.c b/src/event_processor.c
index 2479818acd6985cf88a4eebbe57d815cb99f8d64..64a790629070d53ee569858532b2c1523f6e0a31 100644 (file)
--- a/src/event_processor.c
+++ b/src/event_processor.c
@@ -37,7 +37,7 @@ static int event_processor_callback(sd_event_source *s,
                                     int fd, uint32_t revents, void *userdata)
 {
         struct event_processor *eprocessor = userdata;
-        struct faultd_event *ev = nqueue_pop(eprocessor->pending_events,
+        struct faultd_event *ev = nqueue_pop(&eprocessor->pending_events,
                                              struct faultd_event, nq_node);
         struct faultd_event_handler *handler;
 
@@ -73,7 +73,7 @@ static int event_processor_init(struct faultd_module *module, sd_event *event)
                 return ret;
 
         ret = sd_event_add_io(event, &eprocessor->pending_events_sd_source,
-                              eprocessor->pending_events->fd, EPOLLIN,
+                              eprocessor->pending_events.fd, EPOLLIN,
                               event_processor_callback, eprocessor);
         if (ret)
                 goto cleanup_queue;
@@ -90,6 +90,7 @@ cleanup_queue:
 static void event_processor_cleanup(struct faultd_module *module)
 {
         struct event_processor *eprocessor = to_event_processor(module);
+        int ret;
 
         /* We log errors but go forward to cleanup everything we can */
         ret = sd_event_source_set_enabled(eprocessor->pending_events_sd_source,
@@ -100,8 +101,8 @@ static void event_processor_cleanup(struct faultd_module *module)
         sd_event_source_unref(eprocessor->pending_events_sd_source);
 
         /* TODO: What to do with unhandled events? */
-        while (!nqueue_empty(eprocessor->pending_events)) {
-                struct faultd_event *ev = nqueue_pop(eprocessor->pending_events,
+        while (!nqueue_empty(&eprocessor->pending_events)) {
+                struct faultd_event *ev = nqueue_pop(&eprocessor->pending_events,
                                                      struct faultd_event,
                                                      nq_node);
                 char *str = faultd_event_to_string(ev);
@@ -128,8 +129,8 @@ FAULTD_MODULE_REGISTER(&event_processor.module);
 
 int event_processor_report_event(struct faultd_event *ev)
 {
-        return nqueue_append(&event_processor->pending_events,
-                             ev->nq_node);
+        return nqueue_append(&event_processor.pending_events,
+                             &ev->nq_node);
 }
 
 static int event_processor_handler_callback(sd_event_source *s, int fd,
@@ -142,6 +143,8 @@ static int event_processor_handler_callback(sd_event_source *s, int fd,
 
 int event_processor_handler_register(struct faultd_event_handler *handler)
 {
+        int ret;
+
         if (!handler->event_match || handler->handle_event)
                 return -EINVAL;
 
@@ -149,14 +152,14 @@ int event_processor_handler_register(struct faultd_event_handler *handler)
         if (ret)
                 return ret;
 
-        ret = sd_event_add_io(event_processor->loop,
+        ret = sd_event_add_io(event_processor.loop,
                               &handler->event_queue_sd_source,
-                              handler->event_queue->fd, EPOLLIN,
+                              handler->event_queue.fd, EPOLLIN,
                               event_processor_handler_callback, handler);
         if (ret)
                 goto cleanup_queue;
 
-        list_add_tail(&handler->node, &event_processor->event_handlers);
+        list_add_tail(&handler->node, &event_processor.event_handlers);
         
         return 0;
 
@@ -166,7 +169,7 @@ cleanup_queue:
         return ret;
 }
 
-int event_processor_handler_unregister(struct faultd_event_handler *handler)
+void event_processor_handler_unregister(struct faultd_event_handler *handler)
 {
         int ret;
 
@@ -179,8 +182,8 @@ int event_processor_handler_unregister(struct faultd_event_handler *handler)
         sd_event_source_unref(handler->event_queue_sd_source);
 
         /* TODO: What to do with unhandled events? */
-        while (!nqueue_empty(handler->event_queue)) {
-                struct faultd_event *ev = nqueue_pop(eprocessor->pending_events,
+        while (!nqueue_empty(&handler->event_queue)) {
+                struct faultd_event *ev = nqueue_pop(&event_processor.pending_events,
                                                      struct faultd_event,
                                                      nq_node);
                 char *str = faultd_event_to_string(ev);

diff --git a/src/event_processor.h b/src/event_processor.h
index 875c7802348d8607611ef6c31a019c732bcf793b..392dea5b033e28cf28ddcb83bff29add2ef8164c 100644 (file)
--- a/src/event_processor.h
+++ b/src/event_processor.h
@@ -43,28 +43,28 @@ struct faultd_event_handler {
 int event_processor_report_event(struct faultd_event *ev);
 
 int event_processor_handler_register(struct faultd_event_handler *handler);
-int event_processor_handler_unregister(struct faultd_event_handler *handler);
+void event_processor_handler_unregister(struct faultd_event_handler *handler);
 
-#define FAULTD_EVENT_HANDLER_REGISTER(EVENT_HANDLER, TYPE)              \
-static int event_handler_init(struct faultd_module *module,             \
+#define FAULTD_EVENT_HANDLER_REGISTER(EVENT_HANDLER, NAME, TYPE)        \
+static int event_handler_ ##NAME## _init(struct faultd_module *module,  \
                               sd_event *event_loop)                     \
 {                                                                       \
         return event_processor_handler_register(&EVENT_HANDLER);        \
 }                                                                       \
                                                                         \
-static void event_handler_cleanup(struct faultd_module *module)         \
+static void event_handler_ ##NAME## _cleanup(struct faultd_module *module) \
 {                                                                       \
         event_processor_handler_unregister(&EVENT_HANDLER);             \
 }                                                                       \
                                                                         \
-static struct faultd_module event_handler_module = {                    \
-        .name = EVENT_HANDLER.name,                                     \
+static struct faultd_module event_handler_ ##NAME## _module = {         \
+        .name = #NAME,                                                   \
         .type = TYPE,                                                   \
-        .init = event_handler_init,                                     \
-        .cleanup = event_handler_cleanup,                               \
-        .node = LIST_HEAD_INIT(event_handler_module.node),              \
+        .init = event_handler_ ##NAME## _init,                          \
+        .cleanup = event_handler_ ##NAME## _cleanup,                    \
+        .node = LIST_HEAD_INIT(event_handler_ ##NAME## _module.node),   \
 };                                                                      \
                                                                         \
-FAULTD_MODULE_REGISTER(&event_type_module)
+FAULTD_MODULE_REGISTER(&event_handler_ ##NAME## _module)
 
 #endif /* FAULTD_EVENT_PROCESSOR_H */

diff --git a/src/event_types/decision_made_event.c b/src/event_types/decision_made_event.c
index 2057a9301df963440421e27ff793237d11f22e5e..c14ca9e2b60cbcc78f1f19eae1f9754e653c18aa 100644 (file)
--- a/src/event_types/decision_made_event.c
+++ b/src/event_types/decision_made_event.c
@@ -16,9 +16,10 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
+#define _GNU_SOURCE 1
 #include <stdio.h>
 #include <errno.h>
+#include <malloc.h>
 
 #include "decision_made_event.h"
 
@@ -69,11 +70,11 @@ static void dm_event_release(struct faultd_event *ev)
                 to_decision_made_event(ev);
 
         free(dm_ev->who_made);
-        free(action);
-        if (action_data_release)
-                action_data_release(dm_ev->action_data);
+        free(dm_ev->action);
+        if (dm_ev->action_data_release)
+               dm_ev->action_data_release(dm_ev->action_data);
         faultd_event_put(dm_ev->reason);
-        faultd_event_cleanup(dm_ev->ev);
+        faultd_event_cleanup(&dm_ev->event);
         free(dm_ev);
 }
 
@@ -82,11 +83,12 @@ static char *dm_event_to_string(struct faultd_event *ev)
         struct decision_made_event *dm_ev =
                 to_decision_made_event(ev);
         char *str;
+        int ret;
 
         /* TODO print action data? */
         ret = asprintf(&str, "Decision Made Event:"
                        " Who made: %s"
-                       " Action: %s"
+                       " Action: %s",
                        dm_ev->who_made,
                        dm_ev->action);
 
@@ -103,4 +105,4 @@ static struct faultd_event_type decision_made_event_type = {
         .node = LIST_HEAD_INIT(decision_made_event_type.node),
 };
 
-FAULTD_EVENT_TYPE_REGISTER(decision_made_event_type)
+FAULTD_EVENT_TYPE_REGISTER(decision_made_event_type, decision_made_et)

diff --git a/src/event_types/decision_made_event.h b/src/event_types/decision_made_event.h
index 3a35d9744d30e18c1946cf27d184b9c25ff1f726..c6fd8271f5d6ddb0a5e7264a189474b009721865 100644 (file)
--- a/src/event_types/decision_made_event.h
+++ b/src/event_types/decision_made_event.h
@@ -44,11 +44,11 @@ struct dm_event_data {
         char *who_made;
         char *action;
         /* Action data is shallow copied */
-        void *action_data
+        void *action_data;
         void (*action_data_release)(void *);        
 };
         
 #define to_decision_made_event(EVENT)      \
-        container_of(EVENT, struct resource_decision_made_event, event)
+        container_of(EVENT, struct decision_made_event, event)
 
 #endif /* FAULTD_DECISION_MADE_EVENT_H */

diff --git a/src/event_types/resource_violation_event.c b/src/event_types/resource_violation_event.c
index fca58c782ed351be94f3361c498f6673daab0347..90deeb1a9dcc8127263fc59927b830a8120bf036 100644 (file)
--- a/src/event_types/resource_violation_event.c
+++ b/src/event_types/resource_violation_event.c
@@ -16,9 +16,10 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
+#define _GNU_SOURCE 1
 #include <stdio.h>
 #include <errno.h>
+#include <malloc.h>
 
 #include "resource_violation_event.h"
 
@@ -26,7 +27,7 @@ static int allocate_rv_event(struct faultd_event_type *type,
                              void *data, struct faultd_event **ev)
 {
         struct resource_violation_event *rv_ev;
-        struct rv_event_data rv_ev_data = data;
+        struct rv_event_data *rv_ev_data = data;
         int ret;
 
         rv_ev = malloc(sizeof(*rv_ev));
@@ -38,7 +39,7 @@ static int allocate_rv_event(struct faultd_event_type *type,
                 goto free_rv_ev;
 
         rv_ev->service = rv_ev_data->service;
-        rv_ev->detection_time = rv_ev_data->detection_type;
+        rv_ev->detection_time = rv_ev_data->detection_time;
         rv_ev->resource_type = rv_ev_data->resource_type;
 
         return 0;
@@ -48,13 +49,13 @@ free_rv_ev:
         return ret;
 }
 
-void rv_event_release(struct faultd_event *ev)
+static void rv_event_release(struct faultd_event *ev)
 {
         struct resource_violation_event *rv_ev =
                 to_resource_violation_event(ev);
 
-        system_service_cleanup(rv_ev->service);
-        faultd_event_cleanup(rv_ev->ev);
+        system_service_cleanup(&rv_ev->service);
+        faultd_event_cleanup(&rv_ev->event);
         free(rv_ev);
 }
 
@@ -63,14 +64,15 @@ static char *rv_event_to_string(struct faultd_event *ev)
         struct resource_violation_event *rv_ev =
                 to_resource_violation_event(ev);
         char *str;
+        int ret;
 
         /* TODO print other fields */
         ret = asprintf(&str, "Resource Violation Event:"
                        " Time: %lld.%.9ld"
                        " Service: pid: %d, name %s"
                        " Resource type: %d",
-                       (long long)rv_ev->event->timestamp.tv_sec,
-                       rv_ev->event->timestamp.tv_nsec,
+                       (long long)rv_ev->event.timestamp.tv_sec,
+                       rv_ev->event.timestamp.tv_nsec,
                        rv_ev->service.pid,
                        rv_ev->service.name,
                        rv_ev->resource_type);
@@ -89,4 +91,4 @@ static struct faultd_event_type resource_violation_event_type = {
         .node = LIST_HEAD_INIT(resource_violation_event_type.node),
 };
 
-FAULTD_EVENT_TYPE_REGISTER(resource_violation_event_type)
+FAULTD_EVENT_TYPE_REGISTER(resource_violation_event_type, resource_violation_et)

diff --git a/src/event_types/resource_violation_event.h b/src/event_types/resource_violation_event.h
index 9a3c7ce6243e0774cc3886ef7f213a035e9864a9..5632c4d78a342e5d8768d50888b05f3c3bf76b80 100644 (file)
--- a/src/event_types/resource_violation_event.h
+++ b/src/event_types/resource_violation_event.h
@@ -23,6 +23,7 @@
 
 #include "event.h"
 #include "common.h"
+#include "service.h"
 
 #define RESOURCE_VIOLATION_EVENT_ID "resource_violation"
 
@@ -34,14 +35,14 @@ enum resource_type {
 struct resource_violation_event {
         struct faultd_event event;
         struct system_service service;
-        struct time_t detection_time;
+        time_t detection_time;
         enum resource_type resource_type;
         /* TODO: what more do we need? */
 };
 
 struct rv_event_data {
         struct system_service service;
-        struct time_t detection_time;
+        time_t detection_time;
         enum resource_type resource_type;
 };
         

diff --git a/src/listeners/audit.c b/src/listeners/audit.c
index dc58342c7bcbde23c0c571a00d268c7e5cc253d3..a00eff35206130210345e799287759e2c2fa0b89 100644 (file)
--- a/src/listeners/audit.c
+++ b/src/listeners/audit.c
@@ -65,8 +65,7 @@ static int str2key(char *p, int len)
        return KEY_UNKNOWN;
 }
 
-static int parse_event(char *message, int len,
-                       struct resource_violation_event *event)
+static int parse_event(char *message, int len, struct rv_event_data *ev_data)
 {
        char *p = message;
        char *e;
@@ -77,8 +76,8 @@ static int parse_event(char *message, int len,
                return -1;
 
        ++p;
-       event->detection_time = strtol(p, &p, 10);
-        event->service.pid = 0;
+       ev_data->detection_time = strtol(p, &p, 10);
+        ev_data->service.pid = 0;
 
        while ((p = strchr(p, ' ')) != 0) {
                ++p;
@@ -90,7 +89,7 @@ static int parse_event(char *message, int len,
 
                switch (key) {
                case KEY_PID:
-                       event->service.pid = strtol(p, &p, 10);
+                       ev_data->service.pid = strtol(p, &p, 10);
                        break;
                default:
                        break;
@@ -104,7 +103,7 @@ static int audit_handler(sd_event_source *s, int fd, uint32_t revents, void *use
 {
        struct audit_reply reply;
        int ret;
-        struct rv_ev_data rv_ev_data = {
+        struct rv_event_data rv_ev_data = {
                 .resource_type = FAULTD_RESOURCE_FD,
         };
         struct faultd_event *ev;

diff --git a/src/service.c b/src/service.c
index abf6364bf499d92655c92c8073764dc107a9fd68..c5dce60226ea14e3b0ff0f2bccd317b91b6e4294 100644 (file)
--- a/src/service.c
+++ b/src/service.c
@@ -16,6 +16,8 @@
  * limitations under the License.
  */
 
+#include <malloc.h>
+
 #include "service.h"
 
 int system_service_init(pid_t pid, char *name, struct system_service *s)
@@ -26,6 +28,8 @@ int system_service_init(pid_t pid, char *name, struct system_service *s)
         
         /* TODO: Get real service name if NULL */
         s->name = name;
+
+        return 0;
 }
 
 void system_service_cleanup(struct system_service *s)