Become a memory accounting amateur

userland/c/hello.c

@@ -1,4 +1,6 @@
-/* Print hello to stdout ;-) */
+/* https://cirosantilli.com/linux-kernel-module-cheat#c
+ *
+ * Print hello to stdout ;-) */
 
 #include <stdio.h>
 #include <stdlib.h>

userland/c/malloc.c

@@ -4,22 +4,26 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+/* We do this in a separate function just to illustrate that
+ * this is allows for malloc memory! This is unlike regular stack
+ * variables which may be deallocated when the function returns. */
+void *allocate_bytes(size_t nbytes) {
+    return malloc(nbytes);
+}
+
 int main(int argc, char **argv) {
     int *is;
     size_t nbytes, nints;
 
-    /* Decide how many ints to allocate. */
+    /* Decide how many ints to allocate.
+     * Unlike usual non-VLA arrays, the size is determined dynamically at runtime! */
     if (argc < 2) {
         nints = 2;
     } else {
         nints = strtoull(argv[1], NULL, 0);
     }
     nbytes = nints * sizeof(*is);
-
-    /* Allocate the ints.
-     * Note that unlike traditional stack arrays (non-VLA)
-     * this value does not have to be determined at compile time! */
-    is = malloc(nbytes);
+    is = allocate_bytes(nbytes);
 
     /* This can happen for example if we ask for too much memory. */
     if (is == NULL) {

userland/c/malloc_max.c

@@ -1,18 +0,0 @@
-/* https://cirosantilli.com/linux-kernel-module-cheat#malloc-maximum-size */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-int main(void) {
-    char *ptr = NULL;
-    size_t size = 1;
-    while (1) {
-        printf("0x%zx\n", size);
-        ptr = realloc(ptr, size);
-        if (ptr == NULL) {
-            break;
-        } else {
-            size <<= 1;
-        }
-    }
-}

userland/c/malloc_size.c

@@ -0,0 +1,26 @@
+/* https://cirosantilli.com/linux-kernel-module-cheat#malloc
+ *
+ * Malloc n bytes as given from the command line.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+    char *chars;
+    size_t nbytes;
+
+    if (argc < 2) {
+        nbytes = 2;
+    } else {
+        nbytes = strtoull(argv[1], NULL, 0);
+    }
+    chars = malloc(nbytes);
+    if (chars == NULL) {
+        perror("malloc");
+        exit(EXIT_FAILURE);
+    }
+    free(chars);
+    return EXIT_SUCCESS;
+}

userland/c/snprintf.c

@@ -0,0 +1,54 @@
+/* https://cirosantilli.com/linux-kernel-module-cheat#c
+ *
+ *  Like `sprintf`, but writes at most n bytes, so it is safer,
+ *  because it may not be possible or easy to calculate the resulting
+ *  size of a formated string.
+ *
+ *  The size given includes the null terminator. */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void) {
+#if __STDC_VERSION__ >= 199901L
+    /* Common usage when string fits.
+     *
+     * Ensures that there will be no out or bounds access on out. */
+    {
+        int in = 1234;
+        char out[1024];
+        int snprintf_return;
+        snprintf_return = snprintf(out, sizeof(out), "ab%dcd", in);
+
+        /* The usual error checking. */
+        if (snprintf_return < 0) {
+            perror("snprintf");
+            exit(EXIT_FAILURE);
+        }
+        assert((size_t)snprintf_return < sizeof(out));
+
+        /* Assert because we know the return here.  */
+        assert(snprintf_return == 8);
+
+        /* What it actually copied. */
+        assert(strcmp(out, "ab1234cd") == 0);
+    }
+
+    /* Less common case where string does not fit. Error handling would
+     * normally follow in a real program. */
+    {
+        int in = 1234;
+        char out[6];
+        /* The return here is the same as before.
+         *
+         * Because it is >= than the imposed limit of 6, we know that
+         * the write failed to fully complete. */
+        assert(snprintf(out, sizeof(out), "ab%dcd", in) == 8);
+        assert(strcmp(out, "ab123") == 0);
+    }
+#endif
+    return EXIT_SUCCESS;
+}
+