cleanup(core,tests,samples): completely drop m_ctx_t param from context API.

Moreover, avoid forward declaring the struct and exposing it to the user.
This enforces the law that context <-> thread, and users cannot escape this rule
(eg: by passing around a context handler between threads).

Signed-off-by: Federico Di Pierro <[email protected]>

Author: FedeDP

Lib/core/ctx.c

@@ -22,7 +22,7 @@ static int recv_events(m_ctx_t *c, int timeout);
 static int m_ctx_loop_events(m_ctx_t *c, int max_events);
 static int ctx_destroy_mods(void *data, const char *key, void *value);
 static ev_src_t *process_tick(ev_src_t *this, m_ctx_t *c, int idx, evt_priv_t *evt);
-static int ctx_new(const char *ctx_name, m_ctx_t **c, m_ctx_flags flags, const void *userdata);
+static int ctx_new(const char *ctx_name, m_ctx_flags flags, const void *userdata);
 
 static void make_key(void) {
     pthread_key_create(&key, NULL);
@@ -119,7 +119,7 @@ static uint8_t loop_stop(m_ctx_t *c) {
      * Gracefully deregister it now.
      */
     if (m_map_len(c->modules) == 0 && !(c->flags & M_CTX_PERSIST)) {
-        m_ctx_deregister(&c);
+        m_ctx_deregister();
     }
     return ret;
 }
@@ -317,7 +317,6 @@ static int recv_events(m_ctx_t *c, int timeout) {
 }
 
 static int m_ctx_loop_events(m_ctx_t *c, int max_events) {
-    M_CTX_ASSERT(c);
     M_PARAM_ASSERT(max_events > 0);
     M_LOG_ASSERT(c->state == M_CTX_IDLE, "Context already looping.", -EINVAL);
 
@@ -342,7 +341,7 @@ static ev_src_t *process_tick(ev_src_t *this, m_ctx_t *c, int idx, evt_priv_t *e
     return this;
 }
 
-static int ctx_new(const char *ctx_name, m_ctx_t **c, m_ctx_flags flags, const void *userdata) {
+static int ctx_new(const char *ctx_name, m_ctx_flags flags, const void *userdata) {
     M_DEBUG("Creating context '%s'.\n", ctx_name);
 
     m_ctx_t *new_ctx = m_mem_new(sizeof(m_ctx_t), ctx_dtor);
@@ -377,17 +376,22 @@ static int ctx_new(const char *ctx_name, m_ctx_t **c, m_ctx_flags flags, const v
         ret = pthread_setspecific(key, new_ctx);
     } while (false);
 
-    if (ret == 0) {
-        *c = new_ctx;
-    } else {
-        *c = NULL;
+    if (ret != 0) {
         m_mem_unref(new_ctx);
     }
     return ret;
 }
 
 /** Private API **/
 
+m_ctx_t *m_ctx(void) {
+    m_ctx_t *c = pthread_getspecific(key);
+    if (c && c->curr_mod) {
+        M_RET_ASSERT(!(c->curr_mod->flags & M_MOD_DENY_CTX), NULL);
+    }
+    return c;
+}
+
 void inline ctx_logger(const m_ctx_t *c, const m_mod_t *mod, const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
@@ -397,69 +401,56 @@ void inline ctx_logger(const m_ctx_t *c, const m_mod_t *mod, const char *fmt, ..
 
 /** Public API **/
 
-_public_ m_ctx_t *m_ctx(void) {
-    m_ctx_t *c = pthread_getspecific(key);
-    if (c && c->curr_mod) {
-        M_RET_ASSERT(!(c->curr_mod->flags & M_MOD_DENY_CTX), NULL);
-    }
-    return c;
-}
-
-_public_ int m_ctx_register(const char *ctx_name, OUT m_ctx_t **c, m_ctx_flags flags, const void *userdata) {
+_public_ int m_ctx_register(const char *ctx_name, m_ctx_flags flags, const void *userdata) {
     M_PARAM_ASSERT(str_not_empty(ctx_name));
-    M_PARAM_ASSERT(c);
-    M_PARAM_ASSERT(!*c);
 
     pthread_once(&key_once, make_key);
     if (pthread_getspecific(key)) {
         return -EEXIST;
     }
-    return ctx_new(ctx_name, c, flags, userdata);
+    return ctx_new(ctx_name, flags, userdata);
 }
 
-_public_ int m_ctx_deregister(OUT m_ctx_t **c) {
-    M_PARAM_ASSERT(c && *c && (*c)->state == M_CTX_IDLE);
-
-    int ret;
-    m_ctx_t *context = *c;
+_public_ int m_ctx_deregister(void) {
+    M_CTX_ASSERT();
+    M_PARAM_ASSERT(c->state == M_CTX_IDLE);
 
-    ret = pthread_setspecific(key, NULL);
+    int ret = pthread_setspecific(key, NULL);
     if (ret == 0) {
-        context->state = M_CTX_ZOMBIE;
-        m_iterate(context->modules, ctx_destroy_mods, NULL);
-        *c = NULL;
+        m_iterate(c->modules, ctx_destroy_mods, NULL);
+        m_mem_unref(c);
     }
-    m_mem_unref(context);
     return ret;
 }
 
-_public_ int m_ctx_set_logger(m_ctx_t *c, m_log_cb logger) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_set_logger(m_log_cb logger) {
+    M_CTX_ASSERT();
     M_PARAM_ASSERT(logger);
 
     c->logger = logger;
     return 0;
 }
 
-_public_ int m_ctx_loop(m_ctx_t *c) {
+_public_ int m_ctx_loop(void) {
+    M_CTX_ASSERT();
     return m_ctx_loop_events(c, M_CTX_DEFAULT_EVENTS);
 }
 
-_public_ int m_ctx_quit(m_ctx_t *c, uint8_t quit_code) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_quit(uint8_t quit_code) {
+    M_CTX_ASSERT();
     M_LOG_ASSERT(c->state == M_CTX_LOOPING, "Context not looping.", -EINVAL);
 
     return loop_quit(c, quit_code);
 }
 
-_public_ int m_ctx_fd(const m_ctx_t *c) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_fd(void) {
+    M_CTX_ASSERT();
 
     return dup(poll_get_fd(&c->ppriv));
 }
 
-_public_ int m_ctx_dispatch(m_ctx_t *c) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_dispatch(void) {
+    M_CTX_ASSERT();
 
     if (c->state == M_CTX_IDLE) {
         /* Ok, start now */
@@ -475,8 +466,8 @@ _public_ int m_ctx_dispatch(m_ctx_t *c) {
     return recv_events(c, 0);
 }
 
-_public_ int m_ctx_dump(const m_ctx_t *c) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_dump(void) {
+    M_CTX_ASSERT();
 
     ctx_logger(c, NULL, "{\n");
     ctx_logger(c, NULL, "\t\"Name\": \"%s\",\n", c->name);
@@ -499,7 +490,7 @@ _public_ int m_ctx_dump(const m_ctx_t *c) {
     ctx_logger(c, NULL, "\t\t\"Busy_time\": %" PRIu64 ",\n", total_busy_time);
     ctx_logger(c, NULL, "\t\t\"Recv_events\": %" PRIu64 ",\n", c->stats.recv_msgs);
     ctx_logger(c, NULL, "\t\t\"Action_freq\": %lf,\n", (double)c->stats.recv_msgs / total_looping_time);
-    ctx_logger(c, NULL, "\t\t\"Modules\": %lu,\n", m_ctx_len(c));
+    ctx_logger(c, NULL, "\t\t\"Modules\": %lu,\n", m_ctx_len());
     ctx_logger(c, NULL, "\t\t\"Running_modules\": %lu\n", c->stats.running_modules);
     ctx_logger(c, NULL, "\t},\n");
 
@@ -513,16 +504,16 @@ _public_ int m_ctx_dump(const m_ctx_t *c) {
     return 0;
 }
 
-_public_ int m_ctx_stats(const m_ctx_t *c, OUT m_ctx_stats_t *stats) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_stats(OUT m_ctx_stats_t *stats) {
+    M_CTX_ASSERT();
     M_PARAM_ASSERT(c->state == M_CTX_LOOPING);
     M_PARAM_ASSERT(stats);
 
     uint64_t now;
     fetch_ms(&now, NULL);
 
     stats->recv_msgs = c->stats.recv_msgs;
-    stats->num_modules = m_ctx_len(c);
+    stats->num_modules = m_ctx_len();
     stats->running_modules = c->stats.running_modules;
     stats->total_idle_time = c->stats.idle_time;
     stats->total_looping_time = now - c->stats.looping_start_time;
@@ -532,35 +523,35 @@ _public_ int m_ctx_stats(const m_ctx_t *c, OUT m_ctx_stats_t *stats) {
     return 0;
 }
 
-_public_ const char *m_ctx_name(const m_ctx_t *c) {
+_public_ const char *m_ctx_name(void) {
+    M_CTX();
     M_RET_ASSERT(c, NULL);
-    M_RET_ASSERT(c->state != M_CTX_ZOMBIE, NULL);
 
     return c->name;
 }
 
-_public_ const void *m_ctx_userdata(const m_ctx_t *c) {
+_public_ const void *m_ctx_userdata(void) {
+    M_CTX();
     M_RET_ASSERT(c, NULL);
-    M_RET_ASSERT(c->state != M_CTX_ZOMBIE, NULL);
 
     return c->userdata;
 }
 
-_public_ ssize_t m_ctx_len(const m_ctx_t *c) {
-    M_CTX_ASSERT(c);
+_public_ ssize_t m_ctx_len(void) {
+    M_CTX_ASSERT();
 
     return m_map_len(c->modules);
 }
 
-_public_ int m_ctx_finalize(m_ctx_t *c) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_finalize(void) {
+    M_CTX_ASSERT();
 
     c->finalized = true;
     return 0;
 }
 
-_public_ int m_ctx_set_tick(m_ctx_t *c, uint64_t ns) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_set_tick(uint64_t ns) {
+    M_CTX_ASSERT();
 
     deregister_ctx_src(c, &c->tick.src);
     if (ns != 0) {

Lib/core/ctx.h

@@ -4,19 +4,15 @@
 #include "public/module/structs/map.h"
 #include "public/module/thpool/thpool.h"
 #include "globals.h"
+#include "src.h"
 
 #define M_CTX_DEFAULT_EVENTS    64
 
-// #define M_CTX() m_ctx_t *c = m_ctx();
-// 
-// #define M_CTX_ASSERT(c) \
-// M_CTX(); \
-// M_RET_ASSERT(c, -EPIPE); \
-// M_RET_ASSERT(c->state != M_CTX_ZOMBIE, -EACCES)
+#define M_CTX() m_ctx_t *c = m_ctx();
 
-#define M_CTX_ASSERT(c) \
-    M_PARAM_ASSERT(c); \
-    M_RET_ASSERT(c->state != M_CTX_ZOMBIE, -EACCES)
+#define M_CTX_ASSERT() \
+    M_CTX(); \
+    M_RET_ASSERT(c, -EPIPE)
 
 typedef struct {
     void *data;                             // Context's poll priv data (depends upon poll_plugin)
@@ -34,7 +30,6 @@ typedef struct {
 typedef enum {
     M_CTX_IDLE,
     M_CTX_LOOPING,
-    M_CTX_ZOMBIE,
 } m_ctx_states;
 
 typedef struct {
@@ -67,4 +62,5 @@ struct _ctx {
     CONST const void *userdata;             // Context's user defined data
 };
 
+m_ctx_t *m_ctx(void);
 void ctx_logger(const m_ctx_t *c, const m_mod_t *mod, const char *fmt, ...);

Lib/core/fs/fs.c

@@ -412,8 +412,8 @@ int fs_destroy(m_ctx_t *c) {
 
 /** Public API **/
 
-_public_ int m_ctx_fs_set_root(m_ctx_t *c, const char *path) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_fs_set_root(const char *path) {
+    M_CTX_ASSERT();
     M_RET_ASSERT(c->state == M_CTX_IDLE, -EPERM);
     M_PARAM_ASSERT(str_not_empty(path));
     FS_PRIV();
@@ -423,8 +423,8 @@ _public_ int m_ctx_fs_set_root(m_ctx_t *c, const char *path) {
     return 0;
 }
 
-_public_ int m_ctx_fs_set_ops(m_ctx_t *c, const struct fuse_operations *ops) {
-    M_CTX_ASSERT(c);
+_public_ int m_ctx_fs_set_ops(const struct fuse_operations *ops) {
+    M_CTX_ASSERT();
     M_RET_ASSERT(c->state == M_CTX_IDLE, -EPERM);
     M_PARAM_ASSERT(ops);
     FS_PRIV();

Lib/core/fs/fs.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "public/module/mod.h"
-#include "public/module/ctx.h"
+#include "ctx.h"
 
 int fs_create(m_ctx_t *c);
 int fs_start(m_ctx_t *c);

Lib/core/main.c

@@ -7,11 +7,11 @@
  * Code related to main library ctor/dtor + main() symbol. *
  ***********************************************************/
 
-_public_ _weak_ void m_ctx_pre_loop(m_ctx_t *c, int argc, char *argv[]) {
+_public_ _weak_ void m_ctx_pre_loop(int argc, char *argv[]) {
     M_DEBUG("Pre-looping libmodule easy API.\n");
 }
 
-_public_ _weak_ void m_ctx_post_loop(m_ctx_t *c, int argc, char *argv[]) {
+_public_ _weak_ void m_ctx_post_loop(int argc, char *argv[]) {
     M_DEBUG("Post-looping libmodule easy API.\n");
 }
 
@@ -23,15 +23,10 @@ _public_ _weak_ void m_ctx_post_loop(m_ctx_t *c, int argc, char *argv[]) {
  * All it does is looping on default ctx.
  */
 _public_ _weak_ int main(int argc, char *argv[]) {
-    m_ctx_t *c = m_ctx();
-    if (!c) {
-        M_ERR("No context available.\n");
-        return EXIT_FAILURE;
-    }
-    m_ctx_pre_loop(c, argc, argv);
-    const int ret = m_ctx_loop(c);
-    m_ctx_post_loop(c, argc, argv);
-    m_ctx_deregister(&c); // default_ctx may be NULL here, if eg: all modules where deregistered. We don't care
+    m_ctx_pre_loop(argc, argv);
+    const int ret = m_ctx_loop();
+    m_ctx_post_loop(argc, argv);
+    m_ctx_deregister(); // default_ctx may be NULL here, if eg: all modules where deregistered. We don't care
     return ret;
 }
 

Lib/core/mod.c

@@ -328,7 +328,7 @@ int mod_deregister(m_mod_t **mod, bool from_user) {
              * it has no more modules in it and is not a persistent ctx
              */
             if (c->state == M_CTX_IDLE && m_map_len(c->modules) == 0 && !(c->flags & M_CTX_PERSIST)) {
-                ret = m_ctx_deregister(&c);
+                ret = m_ctx_deregister();
             }
         }
     });
@@ -429,12 +429,12 @@ void mod_dump(const m_mod_t *mod, bool log_mod, const char *indent) {
 
 /** Public API **/
 
-_public_ int m_mod_register(const char *name, m_ctx_t *c, m_mod_t **mod_ref, const m_mod_hook_t *hook,
+_public_ int m_mod_register(const char *name, m_mod_t **mod_ref, const m_mod_hook_t *hook,
                             m_mod_flags flags, const void *userdata) {
     M_PARAM_ASSERT(str_not_empty(name));
     /* Mandatory callback if hook is passed */
     M_PARAM_ASSERT(!hook || hook->on_evt);
-    M_PARAM_ASSERT(c);
+    M_CTX_ASSERT();
 
     if (c->finalized) {
         return -EPERM;

Lib/core/mod.h

@@ -43,6 +43,9 @@ typedef struct {
     m_src_tmr_t timer;
 } mod_tb_t;
 
+/* Forward declare ctx handler */
+typedef struct _ctx m_ctx_t;
+
 /* Struct that holds data for each module */
 /*
  * MEM-REFS for mod:
@@ -70,7 +73,7 @@ struct _mod {
     m_map_t *subscriptions;                 // module's subscriptions (map of ev_src_t*)
     m_queue_t *stashed;                     // module's stashed messages
     m_list_t *bound_mods;                   // modules that are bound to this module's state
-    CONST m_ctx_t *ctx;                     // Module's ctx
+    CONST m_ctx_t *ctx;                     // Module's ctx -> even if ctx is threadspecific data, we need to know the context a module was registered into, to avoid user passing modules around to another thread/context
 };
 
 int evaluate_module(void *data, const char *key, void *value);

Lib/core/public/module/cmn.h.in

@@ -21,9 +21,8 @@
 
 /** Structs types **/
 
-/* Incomplete structure declaration to mod and ctx handlers */
+/* Incomplete structure declaration to mod handler */
 typedef struct _mod m_mod_t;
-typedef struct _ctx m_ctx_t;
 
 /*
  * Common to any context; set this in m_on_boot(),