Back to basic - removed volatile and atomic

Author: codepr

src/handlers.c

@@ -101,7 +101,7 @@ static void session_free(const struct ref *refcount)
 
 static void session_init(struct client_session *session, const char *session_id)
 {
-    session->inflights     = ATOMIC_VAR_INIT(0);
+    session->inflights     = 0;
     session->next_free_mid = 1;
     session->subscriptions = list_new(NULL);
     session->outgoing_msgs = list_new(NULL);

src/memory.c

@@ -26,11 +26,10 @@
  */
 
 #include "memory.h"
-#include <stdatomic.h>
 #include <stdlib.h>
 #include <string.h>
 
-static atomic_size_t memory = ATOMIC_VAR_INIT(0);
+static size_t memory = 0;
 
 /*
  * Custom malloc function, allocate a defined size of bytes plus

src/mqtt.c

@@ -687,6 +687,6 @@ struct mqtt_packet *mqtt_packet_alloc(u8 byte)
     struct mqtt_packet *packet = try_alloc(sizeof(*packet));
     packet->header             = (union mqtt_header){.byte = byte};
     packet->refcount           = (struct ref){mqtt_packet_free, 0};
-    packet->refcount.count     = ATOMIC_VAR_INIT(0);
+    packet->refcount.count     = 0;
     return packet;
 }

src/ref.h

@@ -35,11 +35,9 @@
 
 #pragma once
 
-#include <stdatomic.h>
-
 struct ref {
     void (*free)(const struct ref *);
-    volatile atomic_int count;
+    int count;
 };
 
 static inline void ref_inc(const struct ref *ref)

src/server.c

@@ -39,8 +39,6 @@
 #include <pthread.h>
 #include <unistd.h>
 
-pthread_mutex_t mutex;
-
 /*
  * Auxiliary structure to be used as init argument for eventloop, fd is the
  * listening socket we want to share between multiple instances, cronjobs is
@@ -49,7 +47,7 @@ pthread_mutex_t mutex;
  */
 struct listen_payload {
     int fd;
-    atomic_bool cronjobs;
+    bool cronjobs;
 };
 
 /* Seconds in a Sol, easter egg */
@@ -374,21 +372,20 @@ static void client_init(struct client *client)
     client->client_id[0]  = '\0';
     client->status        = WAITING_HEADER;
     client->rc            = 0;
-    client->rpos          = ATOMIC_VAR_INIT(0);
-    client->read          = ATOMIC_VAR_INIT(0);
-    client->toread        = ATOMIC_VAR_INIT(0);
+    client->rpos          = 0;
+    client->read          = 0;
+    client->toread        = 0;
     if (!client->rbuf)
         client->rbuf =
             try_calloc(conf->max_request_size, sizeof(unsigned char));
-    client->wrote   = ATOMIC_VAR_INIT(0);
-    client->towrite = ATOMIC_VAR_INIT(0);
+    client->wrote   = 0;
+    client->towrite = 0;
     if (!client->wbuf)
         client->wbuf =
             try_calloc(conf->max_request_size, sizeof(unsigned char));
     client->last_seen = time(NULL);
     client->has_lwt   = false;
     client->session   = NULL;
-    pthread_mutex_init(&client->mutex, NULL);
 }
 
 /*
@@ -930,7 +927,6 @@ int start_server(const char *addr, const char *port)
                   BASE_CLIENTS_NUM);
     server.clients_map = NULL;
     server.sessions    = NULL;
-    pthread_mutex_init(&mutex, NULL);
 
     if (conf->allow_anonymous == false)
         if (!config_read_passwd_file(conf->password_file, &server.auths))
@@ -958,7 +954,7 @@ int start_server(const char *addr, const char *port)
     log_info("Server start");
     info.start_time                  = time(NULL);
 
-    struct listen_payload loop_start = {sfd, ATOMIC_VAR_INIT(false)};
+    struct listen_payload loop_start = {sfd, false};
 
     loop_start.cronjobs              = true;
     // start eventloop, could be spread on multiple threads
@@ -973,8 +969,6 @@ int start_server(const char *addr, const char *port)
         SSL_CTX_free(server.ssl_ctx);
         openssl_cleanup();
     }
-    pthread_mutex_destroy(&mutex);
-
     log_info("Sol v%s exiting", VERSION);
 
     return SOL_OK;

src/server.h

@@ -58,33 +58,33 @@ struct io_event {
 /* Global informations statistics structure */
 struct sol_info {
     /* Number of clients currently connected */
-    atomic_size_t active_connections;
+    size_t active_connections;
     /* Total number of clients connected since the start */
-    atomic_size_t total_connections;
+    size_t total_connections;
     /* Total number of sent messages */
-    atomic_size_t messages_sent;
+    size_t messages_sent;
     /* Total number of received messages */
-    atomic_size_t messages_recv;
+    size_t messages_recv;
     /* Timestamp of the start time */
-    atomic_size_t start_time;
+    size_t start_time;
     /* Seconds passed since the start */
-    atomic_size_t uptime;
+    size_t uptime;
     /* Total number of bytes received */
-    atomic_size_t bytes_sent;
+    size_t bytes_sent;
     /* Total number of bytes sent out */
-    atomic_size_t bytes_recv;
+    size_t bytes_recv;
 };
 
 #define INIT_INFO                                                              \
     do {                                                                       \
-        info.active_connections = ATOMIC_VAR_INIT(0);                          \
-        info.total_connections  = ATOMIC_VAR_INIT(0);                          \
-        info.messages_sent      = ATOMIC_VAR_INIT(0);                          \
-        info.messages_recv      = ATOMIC_VAR_INIT(0);                          \
-        info.start_time         = ATOMIC_VAR_INIT(0);                          \
-        info.uptime             = ATOMIC_VAR_INIT(0);                          \
-        info.bytes_sent         = ATOMIC_VAR_INIT(0);                          \
-        info.bytes_recv         = ATOMIC_VAR_INIT(0);                          \
+        info.active_connections = 0;                                           \
+        info.total_connections  = 0;                                           \
+        info.messages_sent      = 0;                                           \
+        info.messages_recv      = 0;                                           \
+        info.start_time         = 0;                                           \
+        info.uptime             = 0;                                           \
+        info.bytes_sent         = 0;                                           \
+        info.bytes_recv         = 0;                                           \
     } while (0)
 
 /*

src/sol_internal.h

@@ -31,7 +31,6 @@
 #include "network.h"
 #include "trie.h"
 #include "uthash.h"
-#include <stdatomic.h>
 #include <time.h>
 
 /* Generic return codes without a defined purpose */
@@ -174,22 +173,21 @@ struct client {
         *ctx;   /* An event context refrence mostly used to fire write events */
     int rc;     /* Return code of the message just handled */
     int status; /* Current status of the client (state machine) */
-    volatile atomic_int rpos;    /* The nr of bytes to skip after a complete
-                                  * packet has * been read. This because according
-                                  * to MQTT, length is encoded on multiple bytes
-                                  * according to it's size, using continuation bit
-                                  * as a technique to encode it. We don't want to
-                                  * decode the length two times when we already
-                                  * know it, so we need an offset to know where
-                                  * the actual packet will start
-                                  */
-    volatile atomic_size_t read; /* The number of bytes already read */
-    volatile atomic_size_t
-        toread;                   /* The number of bytes that have to be read */
-    unsigned char *rbuf;          /* The reading buffer */
-    volatile atomic_size_t wrote; /* The number of bytes already written */
-    volatile atomic_size_t towrite; /* The number of bytes we have to write */
-    unsigned char *wbuf;            /* The writing buffer */
+    int rpos;   /* The nr of bytes to skip after a complete
+                 * packet has * been read. This because for
+                 * MQTT, length is encoded on multiple bytes
+                 * according to it's size, using a continuation bit
+                 * as a technique to encode it. We don't want to
+                 * decode the length two times when we already
+                 * know it, so we need an offset to know where
+                 * the actual packet will start
+                 */
+    size_t read;         /* The number of bytes already read */
+    size_t toread;       /* The number of bytes that have to be read */
+    unsigned char *rbuf; /* The reading buffer */
+    size_t wrote;        /* The number of bytes already written */
+    size_t towrite;      /* The number of bytes we have to write */
+    unsigned char *wbuf; /* The writing buffer */
     char client_id[MQTT_CLIENT_ID_LEN]; /* The client ID according to MQTT specs
                                          */
     struct connection conn; /* A connection structure, takes care of plain or
@@ -201,11 +199,9 @@ struct client {
     bool connected;   /* States if the client has already processed a connection
                          packet */
     bool has_lwt; /* States if the connection packet carried a LWT message */
-    bool clean_session;    /* States if the connection packet was set to clean
-                              session */
-    pthread_mutex_t mutex; /* Inner lock for the client, this avoid
-                              race-conditions on shared parts */
-    UT_hash_handle hh;     /* UTHASH handle, needed to use UTHASH macros */
+    bool clean_session; /* States if the connection packet was set to clean
+                           session */
+    UT_hash_handle hh;  /* UTHASH handle, needed to use UTHASH macros */
 };
 
 /*
@@ -226,9 +222,9 @@ struct client_session {
                                structs */
     List *outgoing_msgs; /* Outgoing messages during disconnection time, stored
                             as mqtt_packet pointers */
-    volatile atomic_ushort inflights; /* Just a counter stating the presence of
-                                         inflight messages */
-    bool clean_session;               /* Clean session flag */
+    unsigned short inflights; /* Just a counter stating the presence of
+                                        inflight messages */
+    bool clean_session;       /* Clean session flag */
     char session_id[MQTT_CLIENT_ID_LEN]; /* The client_id the session refers to
                                           */
     struct mqtt_packet
@@ -241,13 +237,6 @@ struct client_session {
         refcount; /* Reference counting struct, to share the struct easily */
 };
 
-/*
- * Simple mutex for contexted critical areas, mainly used in the handlers
- * module, in server the only useful use are when creating and deactivating
- * clients
- */
-extern pthread_mutex_t mutex;
-
 struct server;
 
 /*

src/util.c

@@ -33,7 +33,6 @@
 // #include <crypt.h>
 #include <ctype.h>
 #include <stdarg.h>
-#include <stdatomic.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/time.h>