clang-tidy: add Chrome-inspired checks

[lttng-tools.git] / src / bin / lttng-sessiond / lttng-syscall.cpp

diff --git a/src/bin/lttng-sessiond/lttng-syscall.cpp b/src/bin/lttng-sessiond/lttng-syscall.cpp
index 7dae12d9f39ea0c9b7ce1c2a83637ff5feabfdfd..dd042fd361aa752862e9dba5bb0c75de569ee86d 100644 (file)
--- a/src/bin/lttng-sessiond/lttng-syscall.cpp
+++ b/src/bin/lttng-sessiond/lttng-syscall.cpp
@@ -6,15 +6,15 @@
  */
 
 #define _LGPL_SOURCE
-#include <stdbool.h>
+#include "kernel.hpp"
+#include "lttng-sessiond.hpp"
+#include "lttng-syscall.hpp"
+#include "utils.hpp"
 
-#include <common/common.h>
-#include <common/kernel-ctl/kernel-ctl.h>
+#include <common/common.hpp>
+#include <common/kernel-ctl/kernel-ctl.hpp>
 
-#include "lttng-sessiond.h"
-#include "kernel.h"
-#include "lttng-syscall.h"
-#include "utils.h"
+#include <stdbool.h>
 
 /* Global syscall table. */
 struct syscall *syscall_table;
@@ -40,7 +40,7 @@ int syscall_init_table(int tracer_fd)
        char name[SYSCALL_NAME_LEN];
 
 #if (SYSCALL_NAME_LEN == 255)
-#define SYSCALL_NAME_LEN_SCANF_IS_A_BROKEN_API "254"
+#define SYSCALL_NAME_LEN_SCANF_IS_A_BROKEN_API "254"
 #endif
 
        DBG3("Syscall init system call table");
@@ -60,7 +60,7 @@ int syscall_init_table(int tracer_fd)
        }
 
        nbmem = SYSCALL_TABLE_INIT_SIZE;
-       syscall_table = (struct syscall *) zmalloc(sizeof(struct syscall) * nbmem);
+       syscall_table = calloc<struct syscall>(nbmem);
        if (!syscall_table) {
                ret = -errno;
                PERROR("syscall list zmalloc");
@@ -68,10 +68,12 @@ int syscall_init_table(int tracer_fd)
        }
 
        while (fscanf(fp,
-                               "syscall { index = %zu; \
+                     "syscall { index = %zu; \
                                name = %" SYSCALL_NAME_LEN_SCANF_IS_A_BROKEN_API "[^;]; \
                                bitness = %u; };\n",
-                               &index, name, &bitness) == 3) {
+                     &index,
+                     name,
+                     &bitness) == 3) {
                at_least_one_syscall = true;
                if (index >= nbmem) {
                        struct syscall *new_list;
@@ -83,14 +85,14 @@ int syscall_init_table(int tracer_fd)
                                /* Overflow, stop everything, something went really wrong. */
                                ERR("Syscall listing memory size overflow. Stopping");
                                free(syscall_table);
-                               syscall_table = NULL;
+                               syscall_table = nullptr;
                                ret = -EINVAL;
                                goto error;
                        }
 
-                       DBG("Reallocating syscall table from %zu to %zu entries", nbmem,
-                                       new_nbmem);
-                       new_list = (struct syscall *) realloc(syscall_table, new_nbmem * sizeof(*new_list));
+                       DBG("Reallocating syscall table from %zu to %zu entries", nbmem, new_nbmem);
+                       new_list = (struct syscall *) realloc(syscall_table,
+                                                             new_nbmem * sizeof(*new_list));
                        if (!new_list) {
                                ret = -errno;
                                PERROR("syscall list realloc");
@@ -98,18 +100,17 @@ int syscall_init_table(int tracer_fd)
                        }
 
                        /* Zero out the new memory. */
-                       memset(new_list + nbmem, 0,
-                                       (new_nbmem - nbmem) * sizeof(*new_list));
+                       memset(new_list + nbmem, 0, (new_nbmem - nbmem) * sizeof(*new_list));
                        nbmem = new_nbmem;
                        syscall_table = new_list;
                }
                syscall_table[index].index = index;
                syscall_table[index].bitness = bitness;
-               if (lttng_strncpy(syscall_table[index].name, name,
-                               sizeof(syscall_table[index].name))) {
+               if (lttng_strncpy(
+                           syscall_table[index].name, name, sizeof(syscall_table[index].name))) {
                        ret = -EINVAL;
                        free(syscall_table);
-                       syscall_table = NULL;
+                       syscall_table = nullptr;
                        goto error;
                }
                /*
@@ -156,13 +157,15 @@ static void destroy_syscall_ht(struct lttng_ht *ht)
        struct lttng_ht_iter iter;
        struct syscall *ksyscall;
 
+       ASSERT_RCU_READ_LOCKED();
+
        DBG3("Destroying syscall hash table.");
 
        if (!ht) {
                return;
        }
 
-       cds_lfht_for_each_entry(ht->ht, &iter.iter, ksyscall, node.node) {
+       cds_lfht_for_each_entry (ht->ht, &iter.iter, ksyscall, node.node) {
                int ret;
 
                ret = lttng_ht_del(ht, &iter);
@@ -200,7 +203,7 @@ static struct syscall *lookup_syscall(struct lttng_ht *ht, const char *name)
 {
        struct lttng_ht_node_str *node;
        struct lttng_ht_iter iter;
-       struct syscall *ksyscall = NULL;
+       struct syscall *ksyscall = nullptr;
 
        LTTNG_ASSERT(ht);
        LTTNG_ASSERT(name);
@@ -208,7 +211,7 @@ static struct syscall *lookup_syscall(struct lttng_ht *ht, const char *name)
        lttng_ht_lookup(ht, (void *) name, &iter);
        node = lttng_ht_iter_get_node_str(&iter);
        if (node) {
-               ksyscall = caa_container_of(node, struct syscall, node);
+               ksyscall = lttng::utils::container_of(node, &syscall::node);
        }
 
        return ksyscall;
@@ -219,14 +222,17 @@ static struct syscall *lookup_syscall(struct lttng_ht *ht, const char *name)
  * syscall at index in the syscall table.
  */
 static void update_event_syscall_bitness(struct lttng_event *events,
-               unsigned int index, unsigned int syscall_index)
+                                        unsigned int index,
+                                        unsigned int syscall_index)
 {
        LTTNG_ASSERT(events);
 
        if (syscall_table[index].bitness == 32) {
-               events[syscall_index].flags = (lttng_event_flag) (events[syscall_index].flags | LTTNG_EVENT_FLAG_SYSCALL_32);
+               events[syscall_index].flags = (lttng_event_flag) (events[syscall_index].flags |
+                                                                 LTTNG_EVENT_FLAG_SYSCALL_32);
        } else {
-               events[syscall_index].flags = (lttng_event_flag) (events[syscall_index].flags | LTTNG_EVENT_FLAG_SYSCALL_64);
+               events[syscall_index].flags = (lttng_event_flag) (events[syscall_index].flags |
+                                                                 LTTNG_EVENT_FLAG_SYSCALL_64);
        }
 }
 
@@ -235,22 +241,20 @@ static void update_event_syscall_bitness(struct lttng_event *events,
  *
  * Return 0 on success else -LTTNG_ERR_NOMEM.
  */
-static int add_syscall_to_ht(struct lttng_ht *ht, unsigned int index,
-               unsigned int syscall_index)
+static int add_syscall_to_ht(struct lttng_ht *ht, unsigned int index, unsigned int syscall_index)
 {
        int ret;
        struct syscall *ksyscall;
 
        LTTNG_ASSERT(ht);
 
-       ksyscall = (struct syscall *) zmalloc(sizeof(*ksyscall));
+       ksyscall = zmalloc<struct syscall>();
        if (!ksyscall) {
                ret = -LTTNG_ERR_NOMEM;
                goto error;
        }
 
-       strncpy(ksyscall->name, syscall_table[index].name,
-                       sizeof(ksyscall->name));
+       strncpy(ksyscall->name, syscall_table[index].name, sizeof(ksyscall->name));
        ksyscall->bitness = syscall_table[index].bitness;
        ksyscall->index = syscall_index;
        lttng_ht_node_init_str(&ksyscall->node, ksyscall->name);
@@ -273,7 +277,7 @@ ssize_t syscall_table_list(struct lttng_event **_events)
        ssize_t ret;
        struct lttng_event *events;
        /* Hash table used to filter duplicate out. */
-       struct lttng_ht *syscalls_ht = NULL;
+       struct lttng_ht *syscalls_ht = nullptr;
 
        LTTNG_ASSERT(_events);
 
@@ -286,7 +290,7 @@ ssize_t syscall_table_list(struct lttng_event **_events)
         * them might not be valid. The count below will make sure to return the
         * right size of the events array.
         */
-       events = (lttng_event *) zmalloc(syscall_table_nb_entry * sizeof(*events));
+       events = calloc<lttng_event>(syscall_table_nb_entry);
        if (!events) {
                PERROR("syscall table list zmalloc");
                ret = -LTTNG_ERR_NOMEM;
@@ -318,8 +322,7 @@ ssize_t syscall_table_list(struct lttng_event **_events)
                }
 
                /* Copy the event information in the event's array. */
-               strncpy(events[index].name, syscall_table[i].name,
-                               sizeof(events[index].name));
+               strncpy(events[index].name, syscall_table[i].name, sizeof(events[index].name));
                update_event_syscall_bitness(events, i, index);
                events[index].type = LTTNG_EVENT_SYSCALL;
                /* This makes the command line not print the enabled/disabled field. */