X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Flttng-syscall.cpp;h=dd042fd361aa752862e9dba5bb0c75de569ee86d;hb=cd9adb8b829564212158943a0d279bb35322ab30;hp=f14563457aeff498f1815d83c5725ce316febf76;hpb=7966af5763c4aaca39df9bbfa9277ff15715c720;p=lttng-tools.git

diff --git a/src/bin/lttng-sessiond/lttng-syscall.cpp b/src/bin/lttng-sessiond/lttng-syscall.cpp
index f14563457..dd042fd36 100644
--- 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,20 +157,22 @@ 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);
 		LTTNG_ASSERT(!ret);
 		free(ksyscall);
 	}
-	ht_cleanup_push(ht);
+	lttng_ht_destroy(ht);
 }
 
 /*
@@ -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. */