Merge branch 'libknot-cleanup' into 'master'

src/knot/ctl/estimator.c

@@ -52,7 +52,8 @@ static int find_in_list(list_t *node_list, uint16_t type)
 		}
 	}
 
-	type_list_item_t *new_entry = xmalloc(sizeof(type_list_item_t));
+	type_list_item_t *new_entry = malloc(sizeof(type_list_item_t));
+	assert(new_entry != NULL);
 	new_entry->type = type;
 
 	add_head(node_list, (node_t *)new_entry);
@@ -77,7 +78,8 @@ static int insert_dname_into_table(hattrie_t *table, const knot_dname_t *d,
 	value_t *val = hattrie_tryget(table, (char *)d, d_size);
 	if (val == NULL) {
 		// Create new dummy node to use for this dname
-		*dummy_node = xmalloc(sizeof(list_t));
+		*dummy_node = malloc(sizeof(list_t));
+		assert(dummy_node != NULL);
 		init_list(*dummy_node);
 		*hattrie_get(table, (char *)d, d_size) = *dummy_node;
 		return 0;
@@ -125,7 +127,7 @@ void *estimator_malloc(void *ctx, size_t len)
 {
 	size_t *count = (size_t *)ctx;
 	*count += add_overhead(len);
-	return xmalloc(len);
+	return malloc(len);
 }
 
 void estimator_free(void *p)

src/libknot/internal/mem.c

@@ -19,9 +19,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/resource.h>
 
-#include "libknot/internal/macros.h"
 #include "libknot/internal/mem.h"
 
 uint8_t *knot_memdup(const uint8_t *data, size_t data_size)
@@ -34,46 +32,6 @@ uint8_t *knot_memdup(const uint8_t *data, size_t data_size)
 	return memcpy(result, data, data_size);
 }
 
-void* xmalloc(size_t l)
-{
-	void *p = malloc(l);
-	if (p == NULL) {
-		abort();
-	}
-	return p;
-}
-
-void *xrealloc(void *p, size_t l)
-{
-	p = realloc(p, l);
-	if (p == NULL) {
-		abort();
-	}
-	return p;
-}
-
-int mreserve(char **p, size_t tlen, size_t min, size_t allow, size_t *reserved)
-{
-	/* Trim excessive memory if possible. */
-	size_t maxlen = min + allow;
-	if (maxlen < min) {
-		return -2; /* size_t overflow */
-	}
-
-	/* Meet target size but trim excessive amounts. */
-	if (*reserved < min || *reserved > maxlen) {
-		void *trimmed = realloc(*p, maxlen * tlen);
-		if (trimmed != NULL) {
-			*p = trimmed;
-			*reserved = maxlen;
-		} else {
-			return -1;
-		}
-	}
-
-	return 0;
-}
-
 char *sprintf_alloc(const char *fmt, ...)
 {
 	int size = 100;
@@ -156,37 +114,3 @@ char *strstrip(const char *str)
 
 	return trimmed;
 }
-
-#ifdef MEM_DEBUG
-/*
- * ((destructor)) attribute executes this function after main().
- * \see http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
- */
-void __attribute__ ((destructor)) usage_dump()
-#else
-void usage_dump()
-#endif
-{
-	/* Get resource usage. */
-	struct rusage usage;
-	if (getrusage(RUSAGE_SELF, &usage) < 0) {
-		memset(&usage, 0, sizeof(struct rusage));
-	}
-
-	fprintf(stderr, "\nMemory statistics:");
-	fprintf(stderr, "\n==================\n");
-
-	fprintf(stderr, "User time: %.03lf ms\nSystem time: %.03lf ms\n",
-	        usage.ru_utime.tv_sec * (double) 1000.0
-	        + usage.ru_utime.tv_usec / (double)1000.0,
-	        usage.ru_stime.tv_sec * (double) 1000.0
-	        + usage.ru_stime.tv_usec / (double)1000.0);
-	fprintf(stderr, "Major page faults: %lu (required I/O)\nMinor page faults: %lu\n",
-	        usage.ru_majflt, usage.ru_minflt);
-	fprintf(stderr, "Number of swaps: %lu\n",
-	        usage.ru_nswap);
-	fprintf(stderr, "Voluntary context switches: %lu\nInvoluntary context switches: %lu\n",
-	        usage.ru_nvcsw,
-	        usage.ru_nivcsw);
-	fprintf(stderr, "==================\n");
-}

src/libknot/internal/mem.h

@@ -17,8 +17,6 @@
 #pragma once
 
 #include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
 
 /*!
  * \brief Create a copy of a binary buffer.
@@ -27,39 +25,6 @@
  */
 uint8_t *knot_memdup(const uint8_t *data, size_t data_size);
 
-/*! \brief Allocate memory or die. */
-void* xmalloc(size_t l);
-
-/*! \brief Reallocate memory or die. */
-void *xrealloc(void *p, size_t l);
-
-/*!
- * \brief Reserve new or trim excessive memory.
- *
- * \param p Double-pointer to memory region.
- * \param tlen Memory unit (f.e. sizeof(int) for int* array)
- * \param min Minimum number of items required.
- * \param allow Maximum extra items to keep (for trimming).
- * \param reserved Pointer to number of already reserved items.
- *
- * \note Example usage:
- * char *buf = NULL; size_t len = 0;
- * if (mreserve(&buf, sizeof(char), 6, 0, &len) == 0) {
- *   memcpy(buf, "hello", strlen("hello");
- *   if (mreserve(&buf, sizeof(char), 20, 0, &len) == 0) {
- *     strncat(buf, "!", 1);
- *     mreserve(&buf, sizeof(char), strlen("hello!")+1, 0, &len);
- *   }
- * }
- * free(buf);
- *
- * \retval 0 on success.
- * \retval -1 on error.
- *
- * \note Memory region will be left untouched if function fails.
- */
-int mreserve(char **p, size_t tlen, size_t min, size_t allow, size_t *reserved);
-
 /*!
  * \brief Format string and take care of allocating memory.
  *

tests/hattrie.c

@@ -28,7 +28,7 @@
 static const char *alphabet = "abcdefghijklmn0123456789";
 static char *str_key_rand(size_t len)
 {
-	char *s = xmalloc(len);
+	char *s = malloc(len);
 	memset(s, 0, len);
 	for (unsigned i = 0; i < len - 1; ++i) {
 		s[i] = alphabet[rand() % strlen(alphabet)];
@@ -101,12 +101,12 @@ static bool str_key_find_leq(hattrie_t *trie, char **keys, size_t i, size_t size
 
 int main(int argc, char *argv[])
 {
-	plan(8);
+	plan_lazy();
 
 	/* Random keys. */
 	srand(time(NULL));
 	unsigned key_count = 100000;
-	char **keys = xmalloc(sizeof(char*) * key_count);
+	char **keys = malloc(sizeof(char*) * key_count);
 	for (unsigned i = 0; i < key_count; ++i) {
 		keys[i] = str_key_rand(KEY_MAXLEN);
 	}

tests/internal_mem.c

@@ -16,6 +16,8 @@
 
 #include <tap/basic.h>
 
+#include <stdlib.h>
+
 #include "libknot/internal/mem.h"
 
 static void test_strstrip(void)