get rid of lkmc package, move userland and kernel-modules to top

Rationale: we already had a non buildroot build system,
maintaining both will be hard, and having short paths is more awesome.

userland/Makefile

@@ -0,0 +1,49 @@
+.PHONY: all clean mkdir
+
+CFLAGS_EXTRA = -fopenmp -std=c99
+CXXFLAGS_EXTRA = -std=c++17
+CCFLAGS_EXTRA = -Wall -Werror -Wextra
+IN_EXT_C = .c
+IN_EXT_CXX = .cpp
+LIBS = -lm
+OUT_EXT = .out
+OUT_DIR = .
+
+OUTS := $(foreach IN_EXT,$(IN_EXT_C) $(IN_EXT_CXX),$(addsuffix $(OUT_EXT), $(basename $(wildcard *$(IN_EXT)))))
+ifeq ($(HAS_EIGEN),y)
+	CXXFLAGS_EXTRA += -I$(STAGING_DIR)/usr/include/eigen3
+	# TODO: was failing with:
+	# fatal error: Eigen/Dense: No such file or directory as of
+	# 975ce0723ee3fa1fea1766e6683e2f3acb8558d6
+	# http://lists.busybox.net/pipermail/buildroot/2018-June/222914.html
+	#CXXFLAGS_EXTRA += $(shell $(PKG_CONFIG) --cflags eigen3)
+else
+	OUTS := $(filter-out eigen_%$(OUT_EXT),$(OUTS))
+endif
+ifeq ($(HAS_LIBDRM),y)
+	LIBS += $(shell $(PKG_CONFIG) --libs libdrm)
+	CFLAGS_EXTRA += $(shell $(PKG_CONFIG) --cflags libdrm)
+else
+	OUTS := $(filter-out libdrm_%$(OUT_EXT),$(OUTS))
+endif
+ifeq ($(HAS_OPENBLAS),y)
+	LIBS += $(shell $(PKG_CONFIG) --libs openblas)
+	CFLAGS_EXTRA += $(shell $(PKG_CONFIG) --cflags openblas)
+else
+	OUTS := $(filter-out openblas_%$(OUT_EXT),$(OUTS))
+endif
+OUTS := $(addprefix $(OUT_DIR)/,$(OUTS))
+
+all: mkdir $(OUTS)
+
+$(OUT_DIR)/%$(OUT_EXT): %$(IN_EXT_C)
+	$(CC) $(CFLAGS) $(CCFLAGS) $(CFLAGS_EXTRA) -o '$@' '$<' $(LIBS)
+
+$(OUT_DIR)/%$(OUT_EXT): %$(IN_EXT_CXX)
+	$(CXX) $(CXXFLAGS) $(CCFLAGS) $(CXXFLAGS_EXTRA) -o '$@' '$<' $(LIBS)
+
+clean:
+	rm -f *'$(OUT_EXT)'
+
+mkdir:
+	mkdir -p '$(OUT_DIR)'

userland/anonymous_inode.c

@@ -0,0 +1,46 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#anonymous-inode */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h> /* sleep */
+
+#include "../include/anonymous_inode.h"
+
+int main(int argc, char **argv)
+{
+	char buf[1024];
+	int fd_ioctl, fd_ioctl_anon, ret;
+	size_t i, nreads;
+
+	if (argc < 2) {
+		puts("Usage: ./prog <ioctl-file> [<nreads>]");
+		return EXIT_FAILURE;
+	} else if (argc > 2) {
+		nreads = strtol(argv[2], NULL, 10);
+	} else {
+		nreads = 3;
+	}
+	fd_ioctl = open(argv[1], O_RDONLY);
+	if (fd_ioctl == -1) {
+		perror("open");
+		return EXIT_FAILURE;
+	}
+	ret = ioctl(fd_ioctl, LKMC_ANONYMOUS_INODE_GET_FD, &fd_ioctl_anon);
+	if (ret == -1) {
+		perror("ioctl");
+		return EXIT_FAILURE;
+	}
+	for (i = 0; i < nreads; ++i) {
+		ret = read(fd_ioctl_anon, buf, sizeof(buf));
+		printf("%.*s\n", ret, buf);
+	}
+	close(fd_ioctl_anon);
+	close(fd_ioctl);
+	return EXIT_SUCCESS;
+}

userland/bst_vs_heap.cpp

@@ -0,0 +1,44 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#bst-vs-heap */
+
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <random>
+#include <set>
+
+#include "m5ops.h"
+
+int main(int argc, char **argv) {
+    typedef uint64_t I;
+    std::vector<I> randoms;
+    size_t i, n;
+    std::priority_queue<I> heap;
+    std::set<I> bst;
+    unsigned int seed = std::random_device()();
+
+    // CLI arguments.
+    if (argc > 1) {
+        n = std::stoi(argv[1]);
+    } else {
+        n = 1000;
+    }
+
+    // Action.
+    for (i = 0; i < n; ++i) {
+        randoms.push_back(i);
+    }
+    std::shuffle(randoms.begin(), randoms.end(), std::mt19937(seed));
+    for (i = 0; i < n; ++i) {
+    	auto random = randoms[i];
+
+        // Heap.
+		m5_resetstats();
+		heap.emplace(random);
+		m5_dumpstats();
+
+        // BST.
+		m5_resetstats();
+		bst.insert(random);
+		m5_dumpstats();
+    }
+}

userland/common.h

@@ -0,0 +1,99 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+#define _XOPEN_SOURCE 700
+#include <fcntl.h> /* open */
+#include <math.h> /* fabs */
+#include <stdint.h> /* uint64_t  */
+#include <stdlib.h> /* size_t */
+#include <stdio.h> /* snprintf */
+#include <sys/types.h>
+#include <unistd.h> /* pread, sysconf */
+#include <stdbool.h>
+
+/* Format documented at:
+ * https://github.com/torvalds/linux/blob/v4.9/Documentation/vm/pagemap.txt
+ */
+typedef struct {
+	uint64_t pfn : 54;
+	unsigned int soft_dirty : 1;
+	unsigned int file_page : 1;
+	unsigned int swapped : 1;
+	unsigned int present : 1;
+} PagemapEntry;
+
+/* Parse the pagemap entry for the given virtual address.
+ *
+ * @param[out] entry      the parsed entry
+ * @param[in]  pagemap_fd file descriptor to an open /proc/pid/pagemap file
+ * @param[in]  vaddr      virtual address to get entry for
+ * @return                0 for success, 1 for failure
+ */
+int pagemap_get_entry(PagemapEntry *entry, int pagemap_fd, uintptr_t vaddr)
+{
+	size_t nread;
+	ssize_t ret;
+	uint64_t data;
+
+	nread = 0;
+	while (nread < sizeof(data)) {
+		ret = pread(
+			pagemap_fd,
+			&data,
+			sizeof(data),
+			(vaddr / sysconf(_SC_PAGE_SIZE)) * sizeof(data) + nread
+		);
+		nread += ret;
+		if (ret <= 0) {
+			return 1;
+		}
+	}
+	entry->pfn = data & (((uint64_t)1 << 54) - 1);
+	entry->soft_dirty = (data >> 54) & 1;
+	entry->file_page = (data >> 61) & 1;
+	entry->swapped = (data >> 62) & 1;
+	entry->present = (data >> 63) & 1;
+	return 0;
+}
+
+/* Convert the given virtual address to physical using /proc/PID/pagemap.
+ *
+ * @param[out] paddr physical address
+ * @param[in]  pid   process to convert for
+ * @param[in]  vaddr virtual address to get entry for
+ * @return  		 0 for success, 1 for failure
+ */
+int virt_to_phys_user(uintptr_t *paddr, pid_t pid, uintptr_t vaddr)
+{
+	char pagemap_file[BUFSIZ];
+	int pagemap_fd;
+
+	snprintf(pagemap_file, sizeof(pagemap_file), "/proc/%ju/pagemap", (uintmax_t)pid);
+	pagemap_fd = open(pagemap_file, O_RDONLY);
+	if (pagemap_fd < 0) {
+		return 1;
+	}
+	PagemapEntry entry;
+	if (pagemap_get_entry(&entry, pagemap_fd, vaddr)) {
+		return 1;
+	}
+	close(pagemap_fd);
+	*paddr = (entry.pfn * sysconf(_SC_PAGE_SIZE)) + (vaddr % sysconf(_SC_PAGE_SIZE));
+	return 0;
+}
+
+bool common_vector_equal(size_t n, double * v1, double * v2, double max_err)
+{
+	double sum = 0.0;
+	double diff;
+	size_t i;
+	for (i = 0; i < n; ++i) {
+		diff = v1[i] - v2[i];
+		sum += diff * diff;
+	}
+	if (sqrt(sum)/n > max_err)
+		return false;
+	return true;
+}
+
+#endif

userland/ctrl_alt_del.c

@@ -0,0 +1,26 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#ctrl-alt-del */
+
+#define _XOPEN_SOURCE 700
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/reboot.h>
+#include <unistd.h>
+
+void signal_handler(int sig) {
+	write(STDOUT_FILENO, "cad\n", 4);
+	signal(sig, signal_handler);
+}
+
+int main(void) {
+	int i = 0;
+	/* Disable the forced reboot, enable sending SIGINT to init. */
+	reboot(RB_DISABLE_CAD);
+    signal(SIGINT, signal_handler);
+	while (1) {
+		sleep(1);
+		printf("%d\n", i);
+		i++;
+	}
+    return EXIT_SUCCESS;
+}

userland/eigen_hello.cpp

@@ -0,0 +1,13 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#eigen
+ * Adapted from: https://eigen.tuxfamily.org/dox/GettingStarted.html
+ */
+#include <iostream>
+#include <Eigen/Dense>
+int main() {
+	Eigen::MatrixXd m(2,2);
+	m(0,0) = 3;
+	m(1,0) = 2.5;
+	m(0,1) = -1;
+	m(1,1) = m(1,0) + m(0,1);
+	std::cout << m << std::endl;
+}

userland/external.desc

@@ -0,0 +1 @@
+name: USERLAND

userland/hello.c

@@ -0,0 +1,9 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#sanity-checks */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) {
+	puts("hello");
+	return EXIT_SUCCESS;
+}

userland/hello_cpp.cpp

@@ -0,0 +1,7 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#sanity-checks */
+
+#include <iostream>
+
+int main() {
+    std::cout << "hello cpp" << std::endl;
+}

userland/init_env_poweroff.c

@@ -0,0 +1,26 @@
+#define _XOPEN_SOURCE 700
+#include <stdio.h>
+#include <sys/reboot.h>
+#include <unistd.h>
+
+int main(int argc, char **argv)
+{
+	int i;
+
+	puts("args:");
+	for (i = 0; i < argc; ++i)
+		puts(argv[i]);
+	puts("");
+
+	puts("env:");
+	extern char **environ;
+	char **env = environ;
+	while (*env) {
+		printf("%s\n", *env);
+		env++;
+	}
+	puts("");
+
+	/* Poweroff. */
+	reboot(RB_POWER_OFF);
+}

userland/ioctl.c

@@ -0,0 +1,67 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#ioctl */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "../include/ioctl.h"
+
+int main(int argc, char **argv)
+{
+	char *ioctl_path;
+	int fd, request, arg0, arg1, arg_int, ret;
+	lkmc_ioctl_struct arg_struct;
+
+	if (argc < 2) {
+		puts("Usage: ./prog <ioctl-file> <request> [<arg>...]");
+		return EXIT_FAILURE;
+	}
+	ioctl_path = argv[1];
+	request = strtol(argv[2], NULL, 10);
+	if (argc > 3) {
+		arg0 = strtol(argv[3], NULL, 10);
+	}
+	if (argc > 4) {
+		arg1 = strtol(argv[4], NULL, 10);
+	}
+
+	fd = open(ioctl_path, O_RDONLY);
+	if (fd == -1) {
+		perror("open");
+		return EXIT_FAILURE;
+	}
+	switch (request)
+	{
+		case 0:
+			arg_int = arg0;
+			ret = ioctl(fd, LKMC_IOCTL_INC, &arg_int);
+			if (ret != -1) {
+				printf("%d\n", arg_int);
+			}
+			break;
+		case 1:
+			arg_struct.i = arg0;
+			arg_struct.j = arg1;
+			ret = ioctl(fd, LKMC_IOCTL_INC_DEC, &arg_struct);
+			if (ret != -1) {
+				printf("%d %d\n", arg_struct.i, arg_struct.j);
+			}
+			break;
+		default:
+			puts("error: unknown request");
+			return EXIT_FAILURE;
+	}
+	if (ret == -1) {
+		perror("ioctl");
+		printf("errno = %d\n", errno);
+		return EXIT_FAILURE;
+	}
+	close(fd);
+	return EXIT_SUCCESS;
+}

userland/libdrm_modeset.c

@@ -0,0 +1,738 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#drm
+ * Adapted from: https://github.com/dvdhrm/docs/blob/fad7c3203b14e67053e0fc41d8490138b8ff47dd/drm-howto/modeset.c */
+
+/*
+ * modeset - DRM Modesetting Example
+ *
+ * Written 2012 by David Herrmann <dh.herrmann@googlemail.com>
+ * Dedicated to the Public Domain.
+ */
+
+/*
+ * DRM Modesetting Howto
+ * This document describes the DRM modesetting API. Before we can use the DRM
+ * API, we have to include xf86drm.h and xf86drmMode.h. Both are provided by
+ * libdrm which every major distribution ships by default. It has no other
+ * dependencies and is pretty small.
+ *
+ * Please ignore all forward-declarations of functions which are used later. I
+ * reordered the functions so you can read this document from top to bottom. If
+ * you reimplement it, you would probably reorder the functions to avoid all the
+ * nasty forward declarations.
+ *
+ * For easier reading, we ignore all memory-allocation errors of malloc() and
+ * friends here. However, we try to correctly handle all other kinds of errors
+ * that may occur.
+ *
+ * All functions and global variables are prefixed with "modeset_*" in this
+ * file. So it should be clear whether a function is a local helper or if it is
+ * provided by some external library.
+ */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <time.h>
+#include <unistd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+struct modeset_dev;
+static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn,
+			     struct modeset_dev *dev);
+static int modeset_create_fb(int fd, struct modeset_dev *dev);
+static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn,
+			     struct modeset_dev *dev);
+static int modeset_open(int *out, const char *node);
+static int modeset_prepare(int fd);
+static void modeset_draw(void);
+static void modeset_cleanup(int fd);
+
+/*
+ * When the linux kernel detects a graphics-card on your machine, it loads the
+ * correct device driver (located in kernel-tree at ./drivers/gpu/drm/<xy>) and
+ * provides two character-devices to control it. Udev (or whatever hotplugging
+ * application you use) will create them as:
+ *     /dev/dri/card0
+ *     /dev/dri/controlID64
+ * We only need the first one. You can hard-code this path into your application
+ * like we do here, but it is recommended to use libudev with real hotplugging
+ * and multi-seat support. However, this is beyond the scope of this document.
+ * Also note that if you have multiple graphics-cards, there may also be
+ * /dev/dri/card1, /dev/dri/card2, ...
+ *
+ * We simply use /dev/dri/card0 here but the user can specify another path on
+ * the command line.
+ *
+ * modeset_open(out, node): This small helper function opens the DRM device
+ * which is given as @node. The new fd is stored in @out on success. On failure,
+ * a negative error code is returned.
+ * After opening the file, we also check for the DRM_CAP_DUMB_BUFFER capability.
+ * If the driver supports this capability, we can create simple memory-mapped
+ * buffers without any driver-dependent code. As we want to avoid any radeon,
+ * nvidia, intel, etc. specific code, we depend on DUMB_BUFFERs here.
+ */
+
+static int modeset_open(int *out, const char *node)
+{
+	int fd, ret;
+	uint64_t has_dumb;
+
+	fd = open(node, O_RDWR | O_CLOEXEC);
+	if (fd < 0) {
+		ret = -errno;
+		fprintf(stderr, "cannot open '%s': %m\n", node);
+		return ret;
+	}
+
+	if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 ||
+	    !has_dumb) {
+		fprintf(stderr, "drm device '%s' does not support dumb buffers\n",
+			node);
+		close(fd);
+		return -EOPNOTSUPP;
+	}
+
+	*out = fd;
+	return 0;
+}
+
+/*
+ * As a next step we need to find our available display devices. libdrm provides
+ * a drmModeRes structure that contains all the needed information. We can
+ * retrieve it via drmModeGetResources(fd) and free it via
+ * drmModeFreeResources(res) again.
+ *
+ * A physical connector on your graphics card is called a "connector". You can
+ * plug a monitor into it and control what is displayed. We are definitely
+ * interested in what connectors are currently used, so we simply iterate
+ * through the list of connectors and try to display a test-picture on each
+ * available monitor.
+ * However, this isn't as easy as it sounds. First, we need to check whether the
+ * connector is actually used (a monitor is plugged in and turned on). Then we
+ * need to find a CRTC that can control this connector. CRTCs are described
+ * later on. After that we create a framebuffer object. If we have all this, we
+ * can mmap() the framebuffer and draw a test-picture into it. Then we can tell
+ * the DRM device to show the framebuffer on the given CRTC with the selected
+ * connector.
+ *
+ * As we want to draw moving pictures on the framebuffer, we actually have to
+ * remember all these settings. Therefore, we create one "struct modeset_dev"
+ * object for each connector+crtc+framebuffer pair that we successfully
+ * initialized and push it into the global device-list.
+ *
+ * Each field of this structure is described when it is first used. But as a
+ * summary:
+ * "struct modeset_dev" contains: {
+ *  - @next: points to the next device in the single-linked list
+ *
+ *  - @width: width of our buffer object
+ *  - @height: height of our buffer object
+ *  - @stride: stride value of our buffer object
+ *  - @size: size of the memory mapped buffer
+ *  - @handle: a DRM handle to the buffer object that we can draw into
+ *  - @map: pointer to the memory mapped buffer
+ *
+ *  - @mode: the display mode that we want to use
+ *  - @fb: a framebuffer handle with our buffer object as scanout buffer
+ *  - @conn: the connector ID that we want to use with this buffer
+ *  - @crtc: the crtc ID that we want to use with this connector
+ *  - @saved_crtc: the configuration of the crtc before we changed it. We use it
+ *                 so we can restore the same mode when we exit.
+ * }
+ */
+
+struct modeset_dev {
+	struct modeset_dev *next;
+
+	uint32_t width;
+	uint32_t height;
+	uint32_t stride;
+	uint32_t size;
+	uint32_t handle;
+	uint8_t *map;
+
+	drmModeModeInfo mode;
+	uint32_t fb;
+	uint32_t conn;
+	uint32_t crtc;
+	drmModeCrtc *saved_crtc;
+};
+
+static struct modeset_dev *modeset_list = NULL;
+
+/*
+ * So as next step we need to actually prepare all connectors that we find. We
+ * do this in this little helper function:
+ *
+ * modeset_prepare(fd): This helper function takes the DRM fd as argument and
+ * then simply retrieves the resource-info from the device. It then iterates
+ * through all connectors and calls other helper functions to initialize this
+ * connector (described later on).
+ * If the initialization was successful, we simply add this object as new device
+ * into the global modeset device list.
+ *
+ * The resource-structure contains a list of all connector-IDs. We use the
+ * helper function drmModeGetConnector() to retrieve more information on each
+ * connector. After we are done with it, we free it again with
+ * drmModeFreeConnector().
+ * Our helper modeset_setup_dev() returns -ENOENT if the connector is currently
+ * unused and no monitor is plugged in. So we can ignore this connector.
+ */
+
+static int modeset_prepare(int fd)
+{
+	drmModeRes *res;
+	drmModeConnector *conn;
+	unsigned int i;
+	struct modeset_dev *dev;
+	int ret;
+
+	/* retrieve resources */
+	res = drmModeGetResources(fd);
+	if (!res) {
+		fprintf(stderr, "cannot retrieve DRM resources (%d): %m\n",
+			errno);
+		return -errno;
+	}
+
+	/* iterate all connectors */
+	for (i = 0; i < (unsigned int)res->count_connectors; ++i) {
+		/* get information for each connector */
+		conn = drmModeGetConnector(fd, res->connectors[i]);
+		if (!conn) {
+			fprintf(stderr, "cannot retrieve DRM connector %u:%u (%d): %m\n",
+				i, res->connectors[i], errno);
+			continue;
+		}
+
+		/* create a device structure */
+		dev = malloc(sizeof(*dev));
+		memset(dev, 0, sizeof(*dev));
+		dev->conn = conn->connector_id;
+
+		/* call helper function to prepare this connector */
+		ret = modeset_setup_dev(fd, res, conn, dev);
+		if (ret) {
+			if (ret != -ENOENT) {
+				errno = -ret;
+				fprintf(stderr, "cannot setup device for connector %u:%u (%d): %m\n",
+					i, res->connectors[i], errno);
+			}
+			free(dev);
+			drmModeFreeConnector(conn);
+			continue;
+		}
+
+		/* free connector data and link device into global list */
+		drmModeFreeConnector(conn);
+		dev->next = modeset_list;
+		modeset_list = dev;
+	}
+
+	/* free resources again */
+	drmModeFreeResources(res);
+	return 0;
+}
+
+/*
+ * Now we dig deeper into setting up a single connector. As described earlier,
+ * we need to check several things first:
+ *   * If the connector is currently unused, that is, no monitor is plugged in,
+ *     then we can ignore it.
+ *   * We have to find a suitable resolution and refresh-rate. All this is
+ *     available in drmModeModeInfo structures saved for each crtc. We simply
+ *     use the first mode that is available. This is always the mode with the
+ *     highest resolution.
+ *     A more sophisticated mode-selection should be done in real applications,
+ *     though.
+ *   * Then we need to find an CRTC that can drive this connector. A CRTC is an
+ *     internal resource of each graphics-card. The number of CRTCs controls how
+ *     many connectors can be controlled indepedently. That is, a graphics-cards
+ *     may have more connectors than CRTCs, which means, not all monitors can be
+ *     controlled independently.
+ *     There is actually the possibility to control multiple connectors via a
+ *     single CRTC if the monitors should display the same content. However, we
+ *     do not make use of this here.
+ *     So think of connectors as pipelines to the connected monitors and the
+ *     CRTCs are the controllers that manage which data goes to which pipeline.
+ *     If there are more pipelines than CRTCs, then we cannot control all of
+ *     them at the same time.
+ *   * We need to create a framebuffer for this connector. A framebuffer is a
+ *     memory buffer that we can write XRGB32 data into. So we use this to
+ *     render our graphics and then the CRTC can scan-out this data from the
+ *     framebuffer onto the monitor.
+ */
+
+static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn,
+			     struct modeset_dev *dev)
+{
+	int ret;
+
+	/* check if a monitor is connected */
+	if (conn->connection != DRM_MODE_CONNECTED) {
+		fprintf(stderr, "ignoring unused connector %u\n",
+			conn->connector_id);
+		return -ENOENT;
+	}
+
+	/* check if there is at least one valid mode */
+	if (conn->count_modes == 0) {
+		fprintf(stderr, "no valid mode for connector %u\n",
+			conn->connector_id);
+		return -EFAULT;
+	}
+
+	/* copy the mode information into our device structure */
+	memcpy(&dev->mode, &conn->modes[0], sizeof(dev->mode));
+	dev->width = conn->modes[0].hdisplay;
+	dev->height = conn->modes[0].vdisplay;
+	fprintf(stderr, "mode for connector %u is %ux%u\n",
+		conn->connector_id, dev->width, dev->height);
+
+	/* find a crtc for this connector */
+	ret = modeset_find_crtc(fd, res, conn, dev);
+	if (ret) {
+		fprintf(stderr, "no valid crtc for connector %u\n",
+			conn->connector_id);
+		return ret;
+	}
+
+	/* create a framebuffer for this CRTC */
+	ret = modeset_create_fb(fd, dev);
+	if (ret) {
+		fprintf(stderr, "cannot create framebuffer for connector %u\n",
+			conn->connector_id);
+		return ret;
+	}
+
+	return 0;
+}
+
+/*
+ * modeset_find_crtc(fd, res, conn, dev): This small helper tries to find a
+ * suitable CRTC for the given connector. We have actually have to introduce one
+ * more DRM object to make this more clear: Encoders.
+ * Encoders help the CRTC to convert data from a framebuffer into the right
+ * format that can be used for the chosen connector. We do not have to
+ * understand any more of these conversions to make use of it. However, you must
+ * know that each connector has a limited list of encoders that it can use. And
+ * each encoder can only work with a limited list of CRTCs. So what we do is
+ * trying each encoder that is available and looking for a CRTC that this
+ * encoder can work with. If we find the first working combination, we are happy
+ * and write it into the @dev structure.
+ * But before iterating all available encoders, we first try the currently
+ * active encoder+crtc on a connector to avoid a full modeset.
+ *
+ * However, before we can use a CRTC we must make sure that no other device,
+ * that we setup previously, is already using this CRTC. Remember, we can only
+ * drive one connector per CRTC! So we simply iterate through the "modeset_list"
+ * of previously setup devices and check that this CRTC wasn't used before.
+ * Otherwise, we continue with the next CRTC/Encoder combination.
+ */
+
+static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn,
+			     struct modeset_dev *dev)
+{
+	drmModeEncoder *enc;
+	unsigned int i, j;
+	int32_t crtc;
+	struct modeset_dev *iter;
+
+	/* first try the currently conected encoder+crtc */
+	if (conn->encoder_id)
+		enc = drmModeGetEncoder(fd, conn->encoder_id);
+	else
+		enc = NULL;
+
+	if (enc) {
+		if (enc->crtc_id) {
+			crtc = enc->crtc_id;
+			for (iter = modeset_list; iter; iter = iter->next) {
+				if ((int32_t)iter->crtc == crtc) {
+					crtc = -1;
+					break;
+				}
+			}
+
+			if (crtc >= 0) {
+				drmModeFreeEncoder(enc);
+				dev->crtc = crtc;
+				return 0;
+			}
+		}
+
+		drmModeFreeEncoder(enc);
+	}
+
+	/* If the connector is not currently bound to an encoder or if the
+	 * encoder+crtc is already used by another connector (actually unlikely
+	 * but lets be safe), iterate all other available encoders to find a
+	 * matching CRTC. */
+	for (i = 0; i < (unsigned int)conn->count_encoders; ++i) {
+		enc = drmModeGetEncoder(fd, conn->encoders[i]);
+		if (!enc) {
+			fprintf(stderr, "cannot retrieve encoder %u:%u (%d): %m\n",
+				i, conn->encoders[i], errno);
+			continue;
+		}
+
+		/* iterate all global CRTCs */
+		for (j = 0; j < (unsigned int)res->count_crtcs; ++j) {
+			/* check whether this CRTC works with the encoder */
+			if (!(enc->possible_crtcs & (1 << j)))
+				continue;
+
+			/* check that no other device already uses this CRTC */
+			crtc = res->crtcs[j];
+			for (iter = modeset_list; iter; iter = iter->next) {
+				if ((int32_t)iter->crtc == crtc) {
+					crtc = -1;
+					break;
+				}
+			}
+
+			/* we have found a CRTC, so save it and return */
+			if (crtc >= 0) {
+				drmModeFreeEncoder(enc);
+				dev->crtc = crtc;
+				return 0;
+			}
+		}
+
+		drmModeFreeEncoder(enc);
+	}
+
+	fprintf(stderr, "cannot find suitable CRTC for connector %u\n",
+		conn->connector_id);
+	return -ENOENT;
+}
+
+/*
+ * modeset_create_fb(fd, dev): After we have found a crtc+connector+mode
+ * combination, we need to actually create a suitable framebuffer that we can
+ * use with it. There are actually two ways to do that:
+ *   * We can create a so called "dumb buffer". This is a buffer that we can
+ *     memory-map via mmap() and every driver supports this. We can use it for
+ *     unaccelerated software rendering on the CPU.
+ *   * We can use libgbm to create buffers available for hardware-acceleration.
+ *     libgbm is an abstraction layer that creates these buffers for each
+ *     available DRM driver. As there is no generic API for this, each driver
+ *     provides its own way to create these buffers.
+ *     We can then use such buffers to create OpenGL contexts with the mesa3D
+ *     library.
+ * We use the first solution here as it is much simpler and doesn't require any
+ * external libraries. However, if you want to use hardware-acceleration via
+ * OpenGL, it is actually pretty easy to create such buffers with libgbm and
+ * libEGL. But this is beyond the scope of this document.
+ *
+ * So what we do is requesting a new dumb-buffer from the driver. We specify the
+ * same size as the current mode that we selected for the connector.
+ * Then we request the driver to prepare this buffer for memory mapping. After
+ * that we perform the actual mmap() call. So we can now access the framebuffer
+ * memory directly via the dev->map memory map.
+ */
+
+static int modeset_create_fb(int fd, struct modeset_dev *dev)
+{
+	struct drm_mode_create_dumb creq;
+	struct drm_mode_destroy_dumb dreq;
+	struct drm_mode_map_dumb mreq;
+	int ret;
+
+	/* create dumb buffer */
+	memset(&creq, 0, sizeof(creq));
+	creq.width = dev->width;
+	creq.height = dev->height;
+	creq.bpp = 32;
+	ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
+	if (ret < 0) {
+		fprintf(stderr, "cannot create dumb buffer (%d): %m\n",
+			errno);
+		return -errno;
+	}
+	dev->stride = creq.pitch;
+	dev->size = creq.size;
+	dev->handle = creq.handle;
+
+	/* create framebuffer object for the dumb-buffer */
+	ret = drmModeAddFB(fd, dev->width, dev->height, 24, 32, dev->stride,
+			   dev->handle, &dev->fb);
+	if (ret) {
+		fprintf(stderr, "cannot create framebuffer (%d): %m\n",
+			errno);
+		ret = -errno;
+		goto err_destroy;
+	}
+
+	/* prepare buffer for memory mapping */
+	memset(&mreq, 0, sizeof(mreq));
+	mreq.handle = dev->handle;
+	ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
+	if (ret) {
+		fprintf(stderr, "cannot map dumb buffer (%d): %m\n",
+			errno);
+		ret = -errno;
+		goto err_fb;
+	}
+
+	/* perform actual memory mapping */
+	dev->map = mmap(0, dev->size, PROT_READ | PROT_WRITE, MAP_SHARED,
+		        fd, mreq.offset);
+	if (dev->map == MAP_FAILED) {
+		fprintf(stderr, "cannot mmap dumb buffer (%d): %m\n",
+			errno);
+		ret = -errno;
+		goto err_fb;
+	}
+
+	/* clear the framebuffer to 0 */
+	memset(dev->map, 0, dev->size);
+
+	return 0;
+
+err_fb:
+	drmModeRmFB(fd, dev->fb);
+err_destroy:
+	memset(&dreq, 0, sizeof(dreq));
+	dreq.handle = dev->handle;
+	drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
+	return ret;
+}
+
+/*
+ * Finally! We have a connector with a suitable CRTC. We know which mode we want
+ * to use and we have a framebuffer of the correct size that we can write to.
+ * There is nothing special left to do. We only have to program the CRTC to
+ * connect each new framebuffer to each selected connector for each combination
+ * that we saved in the global modeset_list.
+ * This is done with a call to drmModeSetCrtc().
+ *
+ * So we are ready for our main() function. First we check whether the user
+ * specified a DRM device on the command line, otherwise we use the default
+ * /dev/dri/card0. Then we open the device via modeset_open(). modeset_prepare()
+ * prepares all connectors and we can loop over "modeset_list" and call
+ * drmModeSetCrtc() on every CRTC/connector combination.
+ *
+ * But printing empty black pages is boring so we have another helper function
+ * modeset_draw() that draws some colors into the framebuffer for 5 seconds and
+ * then returns. And then we have all the cleanup functions which correctly free
+ * all devices again after we used them. All these functions are described below
+ * the main() function.
+ *
+ * As a side note: drmModeSetCrtc() actually takes a list of connectors that we
+ * want to control with this CRTC. We pass only one connector, though. As
+ * explained earlier, if we used multiple connectors, then all connectors would
+ * have the same controlling framebuffer so the output would be cloned. This is
+ * most often not what you want so we avoid explaining this feature here.
+ * Furthermore, all connectors will have to run with the same mode, which is
+ * also often not guaranteed. So instead, we only use one connector per CRTC.
+ *
+ * Before calling drmModeSetCrtc() we also save the current CRTC configuration.
+ * This is used in modeset_cleanup() to restore the CRTC to the same mode as was
+ * before we changed it.
+ * If we don't do this, the screen will stay blank after we exit until another
+ * application performs modesetting itself.
+ */
+
+int main(int argc, char **argv)
+{
+	int ret, fd;
+	const char *card;
+	struct modeset_dev *iter;
+
+	/* check which DRM device to open */
+	if (argc > 1)
+		card = argv[1];
+	else
+		card = "/dev/dri/card0";
+
+	fprintf(stderr, "using card '%s'\n", card);
+
+	/* open the DRM device */
+	ret = modeset_open(&fd, card);
+	if (ret)
+		goto out_return;
+
+	/* prepare all connectors and CRTCs */
+	ret = modeset_prepare(fd);
+	if (ret)
+		goto out_close;
+
+	/* perform actual modesetting on each found connector+CRTC */
+	for (iter = modeset_list; iter; iter = iter->next) {
+		iter->saved_crtc = drmModeGetCrtc(fd, iter->crtc);
+		ret = drmModeSetCrtc(fd, iter->crtc, iter->fb, 0, 0,
+				     &iter->conn, 1, &iter->mode);
+		if (ret)
+			fprintf(stderr, "cannot set CRTC for connector %u (%d): %m\n",
+				iter->conn, errno);
+	}
+
+	/* draw some colors for 5seconds */
+	modeset_draw();
+
+	/* cleanup everything */
+	modeset_cleanup(fd);
+
+	ret = 0;
+
+out_close:
+	close(fd);
+out_return:
+	if (ret) {
+		errno = -ret;
+		fprintf(stderr, "modeset failed with error %d: %m\n", errno);
+	} else {
+		fprintf(stderr, "exiting\n");
+	}
+	return ret;
+}
+
+/*
+ * A short helper function to compute a changing color value. No need to
+ * understand it.
+ */
+
+static uint8_t next_color(bool *up, uint8_t cur, unsigned int mod)
+{
+	uint8_t next;
+
+	next = cur + (*up ? 1 : -1) * (rand() % mod);
+	if ((*up && next < cur) || (!*up && next > cur)) {
+		*up = !*up;
+		next = cur;
+	}
+
+	return next;
+}
+
+/*
+ * modeset_draw(): This draws a solid color into all configured framebuffers.
+ * Every 100ms the color changes to a slightly different color so we get some
+ * kind of smoothly changing color-gradient.
+ *
+ * The color calculation can be ignored as it is pretty boring. So the
+ * interesting stuff is iterating over "modeset_list" and then through all lines
+ * and width. We then set each pixel individually to the current color.
+ *
+ * We do this 50 times as we sleep 100ms after each redraw round. This makes
+ * 50*100ms = 5000ms = 5s so it takes about 5seconds to finish this loop.
+ *
+ * Please note that we draw directly into the framebuffer. This means that you
+ * will see flickering as the monitor might refresh while we redraw the screen.
+ * To avoid this you would need to use two framebuffers and a call to
+ * drmModeSetCrtc() to switch between both buffers.
+ * You can also use drmModePageFlip() to do a vsync'ed pageflip. But this is
+ * beyond the scope of this document.
+ */
+
+static void modeset_draw(void)
+{
+	uint8_t r, g, b;
+	bool r_up, g_up, b_up;
+	unsigned int i, j, k, off;
+	struct modeset_dev *iter;
+
+	srand(time(NULL));
+	r = rand() % 0xff;
+	g = rand() % 0xff;
+	b = rand() % 0xff;
+	r_up = g_up = b_up = true;
+
+	for (i = 0; i < 50; ++i) {
+		r = next_color(&r_up, r, 20);
+		g = next_color(&g_up, g, 10);
+		b = next_color(&b_up, b, 5);
+
+		for (iter = modeset_list; iter; iter = iter->next) {
+			for (j = 0; j < iter->height; ++j) {
+				for (k = 0; k < iter->width; ++k) {
+					off = iter->stride * j + k * 4;
+					*(uint32_t*)&iter->map[off] =
+						     (r << 16) | (g << 8) | b;
+				}
+			}
+		}
+
+		usleep(100000);
+	}
+}
+
+/*
+ * modeset_cleanup(fd): This cleans up all the devices we created during
+ * modeset_prepare(). It resets the CRTCs to their saved states and deallocates
+ * all memory.
+ * It should be pretty obvious how all of this works.
+ */
+
+static void modeset_cleanup(int fd)
+{
+	struct modeset_dev *iter;
+	struct drm_mode_destroy_dumb dreq;
+
+	while (modeset_list) {
+		/* remove from global list */
+		iter = modeset_list;
+		modeset_list = iter->next;
+
+		/* restore saved CRTC configuration */
+		drmModeSetCrtc(fd,
+			       iter->saved_crtc->crtc_id,
+			       iter->saved_crtc->buffer_id,
+			       iter->saved_crtc->x,
+			       iter->saved_crtc->y,
+			       &iter->conn,
+			       1,
+			       &iter->saved_crtc->mode);
+		drmModeFreeCrtc(iter->saved_crtc);
+
+		/* unmap buffer */
+		munmap(iter->map, iter->size);
+
+		/* delete framebuffer */
+		drmModeRmFB(fd, iter->fb);
+
+		/* delete dumb buffer */
+		memset(&dreq, 0, sizeof(dreq));
+		dreq.handle = iter->handle;
+		drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
+
+		/* free allocated memory */
+		free(iter);
+	}
+}
+
+/*
+ * I hope this was a short but easy overview of the DRM modesetting API. The DRM
+ * API offers much more capabilities including:
+ *  - double-buffering or tripple-buffering (or whatever you want)
+ *  - vsync'ed page-flips
+ *  - hardware-accelerated rendering (for example via OpenGL)
+ *  - output cloning
+ *  - graphics-clients plus authentication
+ *  - DRM planes/overlays/sprites
+ *  - ...
+ * If you are interested in these topics, I can currently only redirect you to
+ * existing implementations, including:
+ *  - plymouth (which uses dumb-buffers like this example; very easy to understand)
+ *  - kmscon (which uses libuterm to do this)
+ *  - wayland (very sophisticated DRM renderer; hard to understand fully as it
+ *             uses more complicated techniques like DRM planes)
+ *  - xserver (very hard to understand as it is split across many files/projects)
+ *
+ * But understanding how modesetting (as described in this document) works, is
+ * essential to understand all further DRM topics.
+ *
+ * Any feedback is welcome. Feel free to use this code freely for your own
+ * documentation or projects.
+ *
+ *  - Hosted on http://github.com/dvdhrm/docs
+ *  - Written by David Herrmann <dh.herrmann@googlemail.com>
+ */

userland/m5ops.c

@@ -0,0 +1,36 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#m5ops-instructions */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "m5ops.h"
+
+int main(int argc, char **argv)
+{
+	char action;
+	if (argc > 1) {
+		action = argv[1][0];
+	} else {
+		action = 'e';
+	}
+	switch (action)
+	{
+		case 'c':
+			m5_checkpoint();
+			break;
+		case 'd':
+			m5_dumpstats();
+			break;
+		case 'e':
+			m5_exit();
+			break;
+		case 'f':
+			m5_fail_1();
+			break;
+		case 'r':
+			m5_resetstats();
+			break;
+	}
+	return EXIT_SUCCESS;
+}

userland/m5ops.h

@@ -0,0 +1,54 @@
+#ifndef M5OPS_H
+#define M5OPS_H
+
+#if defined(__arm__)
+static void m5_checkpoint(void)
+{
+	__asm__ __volatile__ ("mov r0, #0; mov r1, #0; mov r2, #0; mov r3, #0; .inst 0xEE000110 | (0x43 << 16);");
+};
+static void m5_dumpstats(void)
+{
+	__asm__ __volatile__ ("mov r0, #0; mov r1, #0; mov r2, #0; mov r3, #0; .inst 0xEE000110 | (0x41 << 16);");
+};
+static void m5_exit()
+{
+	__asm__ __volatile__ ("mov r0, #0; mov r1, #0; .inst 0xEE000110 | (0x21 << 16);");
+};
+static void m5_fail_1(void)
+{
+	__asm__ __volatile__ ("mov r0, #0; mov r1, #0; mov r2, #1; mov r3, #0; .inst 0xEE000110 | (0x22 << 16);");
+};
+static void m5_resetstats(void)
+{
+	__asm__ __volatile__ ("mov r0, #0; mov r1, #0; mov r2, #0; mov r3, #0; .inst 0xEE000110 | (0x40 << 16);");
+};
+#elif defined(__aarch64__)
+static void m5_checkpoint(void)
+{
+	__asm__ __volatile__ ("mov x0, #0; mov x1, #0; .inst 0xFF000110 | (0x43 << 16);");
+};
+static void m5_dumpstats(void)
+{
+	__asm__ __volatile__ ("mov x0, #0; mov x1, #0; .inst 0xFF000110 | (0x41 << 16);");
+};
+static void m5_exit(void)
+{
+	__asm__ __volatile__ ("mov x0, #0; .inst 0XFF000110 | (0x21 << 16);");
+};
+static void m5_fail_1(void)
+{
+	__asm__ __volatile__ ("mov x0, #0; mov x1, #1; .inst 0xFF000110 | (0x22 << 16);");
+};
+static void m5_resetstats(void)
+{
+	__asm__ __volatile__ ("mov x0, #0; mov x1, #0; .inst 0XFF000110 | (0x40 << 16);");
+};
+#else
+static void m5_checkpoint(void) {};
+static void m5_dumpstats(void) {};
+static void m5_exit(void) {};
+static void m5_fail_1(void) {};
+static void m5_resetstats(void) {};
+#endif
+
+#endif

userland/mmap.c

@@ -0,0 +1,94 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#mmap */
+
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h> /* uintmax_t */
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h> /* sysconf */
+
+#include "common.h" /* virt_to_phys_user */
+
+enum { BUFFER_SIZE = 4 };
+
+int main(int argc, char **argv)
+{
+	int fd;
+	long page_size;
+	char *address1, *address2;
+	char buf[BUFFER_SIZE];
+	uintptr_t paddr;
+
+	if (argc < 2) {
+		printf("Usage: %s <mmap_file>\n", argv[0]);
+		return EXIT_FAILURE;
+	}
+	page_size = sysconf(_SC_PAGE_SIZE);
+	printf("open pathname = %s\n", argv[1]);
+	fd = open(argv[1], O_RDWR | O_SYNC);
+	if (fd < 0) {
+		perror("open");
+		assert(0);
+	}
+	printf("fd = %d\n", fd);
+
+    /* mmap twice for double fun. */
+	puts("mmap 1");
+	address1 = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if (address1 == MAP_FAILED) {
+		perror("mmap");
+		assert(0);
+	}
+	puts("mmap 2");
+	address2 = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if (address2 == MAP_FAILED) {
+		perror("mmap");
+		return EXIT_FAILURE;
+	}
+	assert(address1 != address2);
+
+    /* Read and modify memory. */
+	puts("access 1");
+	assert(!strcmp(address1, "asdf"));
+	/* vm_fault */
+	puts("access 2");
+	assert(!strcmp(address2, "asdf"));
+	/* vm_fault */
+	strcpy(address1, "qwer");
+	/* Also modified. So both virtual addresses point to the same physical address. */
+	assert(!strcmp(address2, "qwer"));
+
+	/* Check that the physical addresses are the same.
+	 * They are, but TODO why virt_to_phys on kernel gives a different value? */
+	assert(!virt_to_phys_user(&paddr, getpid(), (uintptr_t)address1));
+	printf("paddr1 = 0x%jx\n", (uintmax_t)paddr);
+	assert(!virt_to_phys_user(&paddr, getpid(), (uintptr_t)address2));
+	printf("paddr2 = 0x%jx\n", (uintmax_t)paddr);
+
+    /* Check that modifications made from userland are also visible from the kernel. */
+	read(fd, buf, BUFFER_SIZE);
+	assert(!memcmp(buf, "qwer", BUFFER_SIZE));
+
+	/* Modify the data from the kernel, and check that the change is visible from userland. */
+	write(fd, "zxcv", 4);
+	assert(!strcmp(address1, "zxcv"));
+	assert(!strcmp(address2, "zxcv"));
+
+    /* Cleanup. */
+    puts("munmap 1");
+	if (munmap(address1, page_size)) {
+		perror("munmap");
+		assert(0);
+	}
+    puts("munmap 2");
+	if (munmap(address2, page_size)) {
+		perror("munmap");
+		assert(0);
+	}
+    puts("close");
+	close(fd);
+	return EXIT_SUCCESS;
+}

userland/myinsmod.c

@@ -0,0 +1,61 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#myinsmod */
+
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#define init_module(module_image, len, param_values) syscall(__NR_init_module, module_image, len, param_values)
+#define finit_module(fd, param_values, flags) syscall(__NR_finit_module, fd, param_values, flags)
+
+int main(int argc, char **argv) {
+	const char *params;
+	int fd, use_finit;
+	size_t image_size;
+	struct stat st;
+	void *image;
+
+	/* CLI handling. */
+	if (argc < 2) {
+		puts("Usage ./prog mymodule.ko [args="" [use_finit=0]");
+		return EXIT_FAILURE;
+	}
+	if (argc < 3) {
+		params = "";
+	} else {
+		params = argv[2];
+	}
+	if (argc < 4) {
+		use_finit = 0;
+	} else {
+		use_finit = (argv[3][0] != '0');
+	}
+
+	/* Action. */
+	fd = open(argv[1], O_RDONLY);
+	if (use_finit) {
+		puts("finit");
+		if (finit_module(fd, params, 0) != 0) {
+			perror("finit_module");
+			return EXIT_FAILURE;
+		}
+		close(fd);
+	} else {
+		puts("init");
+		fstat(fd, &st);
+		image_size = st.st_size;
+		image = malloc(image_size);
+		read(fd, image, image_size);
+		close(fd);
+		if (init_module(image, image_size, params) != 0) {
+			perror("init_module");
+			return EXIT_FAILURE;
+		}
+		free(image);
+	}
+	return EXIT_SUCCESS;
+}

userland/myrmmod.c

@@ -0,0 +1,24 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#myinsmod */
+
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#define delete_module(name, flags) syscall(__NR_delete_module, name, flags)
+
+int main(int argc, char **argv) {
+	if (argc != 2) {
+		puts("Usage ./prog mymodule");
+		return EXIT_FAILURE;
+	}
+	if (delete_module(argv[1], O_NONBLOCK) != 0) {
+		perror("delete_module");
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
+}

userland/netlink.c

@@ -0,0 +1,52 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#netlink-sockets */
+
+#include <linux/netlink.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "../include/netlink.h"
+
+#define MAX_PAYLOAD 1024
+
+/* Some of these structs fields must be zeroed.
+ * We could brute force memset them, but
+ * TODO determine exactly which, and move into main. */
+int sock_fd;
+struct iovec iov;
+struct msghdr msg;
+struct nlmsghdr *nlh;
+struct sockaddr_nl src_addr, dest_addr;
+
+int main(void)
+{
+	sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_USER);
+	if (sock_fd < 0) {
+		perror("socket");
+		return EXIT_FAILURE;
+	}
+	src_addr.nl_family = AF_NETLINK;
+	src_addr.nl_pid = getpid();
+	bind(sock_fd, (struct sockaddr *)&src_addr, sizeof(src_addr));
+	dest_addr.nl_family = AF_NETLINK;
+	nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
+	memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
+	nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
+	nlh->nlmsg_pid = getpid();
+	nlh->nlmsg_flags = 0;
+	strcpy(NLMSG_DATA(nlh), "user request");
+	iov.iov_base = (void *)nlh;
+	iov.iov_len = nlh->nlmsg_len;
+	msg.msg_name = (void *)&dest_addr;
+	msg.msg_namelen = sizeof(dest_addr);
+	msg.msg_iov = &iov;
+	msg.msg_iovlen = 1;
+	fprintf(stderr, "before sendmsg\n");
+	sendmsg(sock_fd, &msg, 0);
+	fprintf(stderr, "after sendmsg\n");
+	recvmsg(sock_fd, &msg, 0);
+	printf("%s\n", (char *)NLMSG_DATA(nlh));
+	close(sock_fd);
+}

userland/openblas_hello.c

@@ -0,0 +1,16 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#blas
+ * Adapted from: https://github.com/xianyi/OpenBLAS/wiki/User-Manual/59b62f98e7400270fb03ad1d85fba5b64ebbff2b#call-cblas-interface */
+
+#include "common.h"
+
+#include <assert.h>
+#include <cblas.h>
+
+int main(void)
+{
+	double A[6] = {1.0, 2.0, 1.0, -3.0, 4.0, -1.0};
+	double B[6] = {1.0, 2.0, 1.0, -3.0, 4.0, -1.0};
+	double C[9] = {0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5};
+	cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans, 3, 3, 2, 1, A, 3, B, 3, 2, C, 3);
+	assert(common_vector_equal(9, C, (double[]){11.0, -9.0, 5.0, -9.0, 21.0, -1.0, 5.0, -1.0, 3.0}, 1e-6));
+}

userland/openmp.c

@@ -0,0 +1,19 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#openmp */
+
+#include <omp.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main () {
+	int nthreads, tid;
+#pragma omp parallel private(nthreads, tid)
+	{
+		tid = omp_get_thread_num();
+		printf("Hello World from thread = %d\n", tid);
+		if (tid == 0) {
+			nthreads = omp_get_num_threads();
+			printf("Number of threads = %d\n", nthreads);
+		}
+	}
+	return EXIT_SUCCESS;
+}

userland/pagemap_dump.c

@@ -0,0 +1,116 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#pagemap_dump-out */
+
+#define _XOPEN_SOURCE 700
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "common.h" /* pagemap_get_entry */
+
+int main(int argc, char **argv)
+{
+	char buffer[BUFSIZ];
+	char maps_file[BUFSIZ];
+	char pagemap_file[BUFSIZ];
+	int maps_fd;
+	int offset = 0;
+	int pagemap_fd;
+	pid_t pid;
+
+	if (argc < 2) {
+		printf("Usage: %s pid\n", argv[0]);
+		return EXIT_FAILURE;
+	}
+	pid = strtoull(argv[1], NULL, 0);
+	snprintf(maps_file, sizeof(maps_file), "/proc/%ju/maps", (uintmax_t)pid);
+	snprintf(pagemap_file, sizeof(pagemap_file), "/proc/%ju/pagemap", (uintmax_t)pid);
+	maps_fd = open(maps_file, O_RDONLY);
+	if (maps_fd < 0) {
+		perror("open maps");
+		return EXIT_FAILURE;
+	}
+	pagemap_fd = open(pagemap_file, O_RDONLY);
+	if (pagemap_fd < 0) {
+		perror("open pagemap");
+		return EXIT_FAILURE;
+	}
+	printf("vaddr pfn soft-dirty file/shared swapped present library\n");
+	for (;;) {
+		ssize_t length = read(maps_fd, buffer + offset, sizeof buffer - offset);
+		if (length <= 0) break;
+		length += offset;
+		for (size_t i = offset; i < (size_t)length; i++) {
+			uintptr_t low = 0, high = 0;
+			if (buffer[i] == '\n' && i) {
+				const char *lib_name;
+				size_t y;
+				/* Parse a line from maps. Each line contains a range that contains many pages. */
+				{
+					size_t x = i - 1;
+					while (x && buffer[x] != '\n') x--;
+					if (buffer[x] == '\n') x++;
+					while (buffer[x] != '-' && x < sizeof buffer) {
+						char c = buffer[x++];
+						low *= 16;
+						if (c >= '0' && c <= '9') {
+							low += c - '0';
+						} else if (c >= 'a' && c <= 'f') {
+							low += c - 'a' + 10;
+						} else {
+						    break;
+						}
+					}
+					while (buffer[x] != '-' && x < sizeof buffer) x++;
+					if (buffer[x] == '-') x++;
+					while (buffer[x] != ' ' && x < sizeof buffer) {
+						char c = buffer[x++];
+						high *= 16;
+						if (c >= '0' && c <= '9') {
+							high += c - '0';
+						} else if (c >= 'a' && c <= 'f') {
+							high += c - 'a' + 10;
+						} else {
+							break;
+						}
+					}
+					lib_name = 0;
+					for (int field = 0; field < 4; field++) {
+						x++;
+						while(buffer[x] != ' ' && x < sizeof buffer) x++;
+					}
+					while (buffer[x] == ' ' && x < sizeof buffer) x++;
+					y = x;
+					while (buffer[y] != '\n' && y < sizeof buffer) y++;
+					buffer[y] = 0;
+					lib_name = buffer + x;
+				}
+				/* Get info about all pages in this page range with pagemap. */
+				{
+					PagemapEntry entry;
+					for (uintptr_t vaddr = low; vaddr < high; vaddr += sysconf(_SC_PAGE_SIZE)) {
+						/* TODO always fails for the last page (vsyscall), why? pread returns 0. */
+						if (!pagemap_get_entry(&entry, pagemap_fd, vaddr)) {
+							printf("%jx %jx %u %u %u %u %s\n",
+								(uintmax_t)vaddr,
+								(uintmax_t)entry.pfn,
+								entry.soft_dirty,
+								entry.file_page,
+								entry.swapped,
+								entry.present,
+								lib_name
+							);
+						}
+					}
+				}
+				buffer[y] = '\n';
+			}
+		}
+	}
+	close(maps_fd);
+	close(pagemap_fd);
+	return EXIT_SUCCESS;
+}

userland/poll.c

@@ -0,0 +1,41 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#poll */
+
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h> /* creat, O_CREAT */
+#include <poll.h> /* poll */
+#include <stdio.h> /* printf, puts, snprintf */
+#include <stdlib.h> /* EXIT_FAILURE, EXIT_SUCCESS */
+#include <unistd.h> /* read */
+
+int main(int argc, char **argv) {
+	char buf[1024];
+	int fd, i, n;
+	short revents;
+	struct pollfd pfd;
+
+	if (argc < 2) {
+		fprintf(stderr, "usage: %s <poll-device>\n", argv[0]);
+		exit(EXIT_FAILURE);
+	}
+	fd = open(argv[1], O_RDONLY | O_NONBLOCK);
+	if (fd == -1) {
+		perror("open");
+		exit(EXIT_FAILURE);
+	}
+	pfd.fd = fd;
+	pfd.events = POLLIN;
+	while (1) {
+		puts("loop");
+		i = poll(&pfd, 1, -1);
+		if (i == -1) {
+			perror("poll");
+			assert(0);
+		}
+		revents = pfd.revents;
+		if (revents & POLLIN) {
+			n = read(pfd.fd, buf, sizeof(buf));
+			printf("POLLIN n=%d buf=%.*s\n", n, n, buf);
+		}
+	}
+}

userland/poweroff.c

@@ -0,0 +1,9 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#poweroff-out */
+
+#define _XOPEN_SOURCE 700
+#include <sys/reboot.h>
+#include <unistd.h>
+
+int main(void) {
+	reboot(RB_POWER_OFF);
+}

userland/proc_events.c

@@ -0,0 +1,176 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#config_proc_events
+ *
+ * Adapted from: https://stackoverflow.com/questions/6075013/detect-launching-of-programs-on-linux-platform/8255487#8255487
+ */
+
+#if defined(__aarch64__)
+
+int main(void) {}
+
+#else
+
+#define _XOPEN_SOURCE 700
+#include <errno.h>
+#include <linux/cn_proc.h>
+#include <linux/connector.h>
+#include <linux/netlink.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+static volatile bool need_exit = false;
+
+static int nl_connect()
+{
+	int rc;
+	int nl_sock;
+	struct sockaddr_nl sa_nl;
+
+	nl_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+	if (nl_sock == -1) {
+		perror("socket");
+		return -1;
+	}
+	sa_nl.nl_family = AF_NETLINK;
+	sa_nl.nl_groups = CN_IDX_PROC;
+	sa_nl.nl_pid = getpid();
+	rc = bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+	if (rc == -1) {
+		perror("bind");
+		close(nl_sock);
+		return -1;
+	}
+	return nl_sock;
+}
+
+static int set_proc_ev_listen(int nl_sock, bool enable)
+{
+	int rc;
+	struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
+		struct nlmsghdr nl_hdr;
+		struct __attribute__ ((__packed__)) {
+			struct cn_msg cn_msg;
+			enum proc_cn_mcast_op cn_mcast;
+		};
+	} nlcn_msg;
+
+	memset(&nlcn_msg, 0, sizeof(nlcn_msg));
+	nlcn_msg.nl_hdr.nlmsg_len = sizeof(nlcn_msg);
+	nlcn_msg.nl_hdr.nlmsg_pid = getpid();
+	nlcn_msg.nl_hdr.nlmsg_type = NLMSG_DONE;
+
+	nlcn_msg.cn_msg.id.idx = CN_IDX_PROC;
+	nlcn_msg.cn_msg.id.val = CN_VAL_PROC;
+	nlcn_msg.cn_msg.len = sizeof(enum proc_cn_mcast_op);
+
+	nlcn_msg.cn_mcast = enable ? PROC_CN_MCAST_LISTEN : PROC_CN_MCAST_IGNORE;
+
+	rc = send(nl_sock, &nlcn_msg, sizeof(nlcn_msg), 0);
+	if (rc == -1) {
+		perror("netlink send");
+		return -1;
+	}
+
+	return 0;
+}
+
+static int handle_proc_ev(int nl_sock)
+{
+	int rc;
+	struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
+		struct nlmsghdr nl_hdr;
+		struct __attribute__ ((__packed__)) {
+			struct cn_msg cn_msg;
+			struct proc_event proc_ev;
+		};
+	} nlcn_msg;
+	while (!need_exit) {
+		rc = recv(nl_sock, &nlcn_msg, sizeof(nlcn_msg), 0);
+		if (rc == 0) {
+			return 0;
+		} else if (rc == -1) {
+			if (errno == EINTR) continue;
+			perror("netlink recv");
+			return -1;
+		}
+		switch (nlcn_msg.proc_ev.what) {
+			case PROC_EVENT_NONE:
+				printf("set mcast listen ok\n");
+				break;
+			case PROC_EVENT_FORK:
+				printf("fork: parent tid=%d pid=%d -> child tid=%d pid=%d\n",
+						nlcn_msg.proc_ev.event_data.fork.parent_pid,
+						nlcn_msg.proc_ev.event_data.fork.parent_tgid,
+						nlcn_msg.proc_ev.event_data.fork.child_pid,
+						nlcn_msg.proc_ev.event_data.fork.child_tgid);
+				break;
+			case PROC_EVENT_EXEC:
+				printf("exec: tid=%d pid=%d\n",
+						nlcn_msg.proc_ev.event_data.exec.process_pid,
+						nlcn_msg.proc_ev.event_data.exec.process_tgid);
+				break;
+			case PROC_EVENT_UID:
+				printf("uid change: tid=%d pid=%d from %d to %d\n",
+						nlcn_msg.proc_ev.event_data.id.process_pid,
+						nlcn_msg.proc_ev.event_data.id.process_tgid,
+						nlcn_msg.proc_ev.event_data.id.r.ruid,
+						nlcn_msg.proc_ev.event_data.id.e.euid);
+				break;
+			case PROC_EVENT_GID:
+				printf("gid change: tid=%d pid=%d from %d to %d\n",
+						nlcn_msg.proc_ev.event_data.id.process_pid,
+						nlcn_msg.proc_ev.event_data.id.process_tgid,
+						nlcn_msg.proc_ev.event_data.id.r.rgid,
+						nlcn_msg.proc_ev.event_data.id.e.egid);
+				break;
+			case PROC_EVENT_EXIT:
+				printf("exit: tid=%d pid=%d exit_code=%d\n",
+						nlcn_msg.proc_ev.event_data.exit.process_pid,
+						nlcn_msg.proc_ev.event_data.exit.process_tgid,
+						nlcn_msg.proc_ev.event_data.exit.exit_code);
+				break;
+			default:
+				printf("unhandled proc event\n");
+				break;
+		}
+	}
+
+	return 0;
+}
+
+static void on_sigint(__attribute__ ((unused)) int unused)
+{
+	need_exit = true;
+}
+
+int main(void)
+{
+	int nl_sock;
+	int rc = EXIT_SUCCESS;
+
+	signal(SIGINT, &on_sigint);
+	siginterrupt(SIGINT, true);
+	nl_sock = nl_connect();
+	if (nl_sock == -1)
+		exit(EXIT_FAILURE);
+	rc = set_proc_ev_listen(nl_sock, true);
+	if (rc == -1) {
+		rc = EXIT_FAILURE;
+		goto out;
+	}
+	rc = handle_proc_ev(nl_sock);
+	if (rc == -1) {
+		rc = EXIT_FAILURE;
+		goto out;
+	}
+	set_proc_ev_listen(nl_sock, false);
+out:
+	close(nl_sock);
+	exit(rc);
+}
+
+#endif

userland/rand_check.c

@@ -0,0 +1,41 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#rand_check-out */
+
+#include <inttypes.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+int bss = 0;
+int data = 1;
+
+int main(__attribute__((unused)) int argc, char **argv) {
+	int i, *ip;
+	uint64_t uint64;
+	FILE *fp;
+
+	/* Loaded addresses. */
+	printf("&i         = %p\n", (void *)&i);
+	printf("&argv[0]   = %p\n", (void *)&argv[0]);
+	printf("&main      = %p\n", (void *)(intptr_t)main);
+	printf("&bss       = %p\n", (void *)&bss);
+	printf("&data      = %p\n", (void *)&data);
+
+	/* Misc syscalls. */
+	printf("time(NULL) = %ju\n", (uintmax_t)time(NULL));
+	printf("pid = %ju\n", (uintmax_t)getpid());
+
+	/* malloc */
+	ip = malloc(sizeof(*ip));
+	printf("&malloc    = %p\n", (void *)ip);
+	free(ip);
+
+	/* /dev/urandom */
+	fp = fopen("/dev/urandom", "rb");
+	fread(&uint64, sizeof(uint64), 1, fp);
+	printf("/dev/urandom = %" PRIx64 "\n", uint64);
+	fclose(fp);
+}

userland/rdtsc.c

@@ -0,0 +1,20 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#rdtsc */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(__i386__) || defined(__x86_64__)
+#include <x86intrin.h>
+#endif
+
+int main(void) {
+	uintmax_t val;
+#if defined(__i386__) || defined(__x86_64__)
+	val = __rdtsc();
+#else
+	val = 0;
+#endif
+	printf("%ju\n", val);
+	return EXIT_SUCCESS;
+}

userland/ring0.c

@@ -0,0 +1,14 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#ring0 */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "../include/ring0.h"
+
+int main(void) {
+#if defined(__x86_64__) || defined(__i386__)
+	Ring0Regs ring0_regs;
+	ring0_get_control_regs(&ring0_regs);
+#endif
+	return EXIT_SUCCESS;
+}

userland/sched_getaffinity.c

@@ -0,0 +1,42 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#gdb-step-debug-multicore */
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <sched.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void print_affinity() {
+    cpu_set_t mask;
+    long nproc, i;
+
+    if (sched_getaffinity(0, sizeof(cpu_set_t), &mask) == -1) {
+        perror("sched_getaffinity");
+        assert(false);
+    } else {
+        nproc = sysconf(_SC_NPROCESSORS_ONLN);
+        printf("sched_getaffinity = ");
+        for (i = 0; i < nproc; i++) {
+            printf("%d ", CPU_ISSET(i, &mask));
+        }
+        printf("\n");
+    }
+}
+
+int main(void) {
+    cpu_set_t mask;
+
+    print_affinity();
+    printf("sched_getcpu = %d\n", sched_getcpu());
+    CPU_ZERO(&mask);
+    CPU_SET(0, &mask);
+    if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) == -1) {
+        perror("sched_setaffinity");
+        assert(false);
+    }
+    print_affinity();
+    printf("sched_getcpu = %d\n", sched_getcpu());
+    return EXIT_SUCCESS;
+}

userland/sched_getaffinity_threads.c

@@ -0,0 +1,51 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#gdb-step-debug-multicore */
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void* main_thread_0(void *arg) {
+	int i;
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    CPU_SET(*((int*)arg), &mask);
+    sched_setaffinity(0, sizeof(cpu_set_t), &mask);
+    i = 0;
+    while (true) {
+    	printf("0 %d\n", i);
+    	sleep(1);
+    	i++;
+    }
+    return NULL;
+}
+
+void* main_thread_1(void *arg) {
+	int i;
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    CPU_SET(*((int*)arg), &mask);
+    sched_setaffinity(1, sizeof(cpu_set_t), &mask);
+    i = 0;
+    while (true) {
+    	printf("1 %d\n", i);
+    	sleep(1);
+    	i++;
+    }
+    return NULL;
+}
+
+int main(void) {
+    enum NUM_THREADS {NUM_THREADS = 2};
+    pthread_t threads[NUM_THREADS];
+    int thread_args[NUM_THREADS];
+	pthread_create(&threads[0], NULL, main_thread_0, (void*)&thread_args[0]);
+	pthread_create(&threads[1], NULL, main_thread_1, (void*)&thread_args[1]);
+    pthread_join(threads[0], NULL);
+    pthread_join(threads[1], NULL);
+    return EXIT_SUCCESS;
+}

userland/sleep_forever.c

@@ -0,0 +1,10 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#sleep_forever-out */
+
+#include <stdio.h>
+#include <unistd.h>
+
+int main(void) {
+	puts(__FILE__);
+	while (1)
+		sleep(0xFFFFFFFF);
+}

userland/time_boot.c

@@ -0,0 +1,13 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#time_boot-out */
+
+#include <stdio.h>
+#include <unistd.h>
+
+int main(void) {
+    FILE *fp;
+    fp = fopen("/dev/kmsg", "w");
+	fputs(__FILE__ "\n", fp);
+	fclose(fp);
+	while (1)
+		sleep(0xFFFFFFFF);
+}

userland/uio_read.c

@@ -0,0 +1,111 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#uio */
+
+#if 1
+
+/* Adapted from: https://yurovsky.github.io/2014/10/10/linux-uio-gpio-interrupt */
+
+#define _XOPEN_SOURCE 700
+#include <fcntl.h> /* open */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h> /* write */
+
+#include <assert.h>
+#include <sys/mman.h>
+
+int main(int argc, char **argv)
+{
+    char *dev = "/dev/uio0";
+    if (argc > 1) {
+        dev = argv[1];
+        exit(EXIT_FAILURE);
+    }
+    int fd = open(dev, O_RDWR);
+    if (fd < 0) {
+        perror("open");
+        exit(EXIT_FAILURE);
+    }
+
+    /* TODO not supported by this kernel module? */
+	/*int *addr = mmap(NULL, sysconf(_SC_PAGE_SIZE), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);*/
+	/*if (addr == MAP_FAILED) {*/
+		/*perror("mmap");*/
+		/*assert(0);*/
+	/*}*/
+	/**addr = 0x12345678;*/
+
+    while (1) {
+        uint32_t info = 1;
+        size_t nb = write(fd, &info, sizeof(info));
+        if (nb < sizeof(info)) {
+            perror("write");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+        nb = read(fd, &info, sizeof(info));
+        if (nb == sizeof(info)) {
+            printf(__FILE__ " read = %u\n", info);
+        }
+    }
+}
+
+#else
+
+/* Ripped from the kernel docs. */
+
+#define _XOPEN_SOURCE 700
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <unistd.h>
+
+int main(void)
+{
+    int uiofd;
+    int configfd;
+    int err;
+    int i;
+    unsigned icount;
+    unsigned char command_high;
+
+    uiofd = open("/dev/uio0", O_RDONLY);
+    if (uiofd < 0) {
+        perror("uio open:");
+        return errno;
+    }
+    configfd = open("/sys/class/uio/uio0/device/config", O_RDWR);
+    if (configfd < 0) {
+        perror("config open:");
+        return errno;
+    }
+    err = pread(configfd, &command_high, 1, 5);
+    if (err != 1) {
+        perror("command config read:");
+        return errno;
+    }
+    command_high &= ~0x4;
+    for(i = 0;; ++i) {
+        fprintf(stderr, "Interrupts: %d\n", icount);
+        err = pwrite(configfd, &command_high, 1, 5);
+        if (err != 1) {
+            perror("config write:");
+            break;
+        }
+        err = read(uiofd, &icount, 4);
+        if (err != 4) {
+            perror("uio read:");
+            break;
+        }
+
+    }
+    return errno;
+}
+
+#endif

userland/virt_to_phys_test.c

@@ -0,0 +1,21 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#userland-physical-address-experiments */
+
+#define _XOPEN_SOURCE 700
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+enum { I0 = 0x12345678 };
+
+static volatile uint32_t i = I0;
+
+int main(void) {
+	printf("vaddr %p\n", (void *)&i);
+	printf("pid %ju\n", (uintmax_t)getpid());
+	while (i == I0) {
+		sleep(1);
+	}
+	printf("i %jx\n", (uintmax_t)i);
+	return EXIT_SUCCESS;
+}

userland/virt_to_phys_user.c

@@ -0,0 +1,26 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#userland-physical-address-experiments */
+
+#define _XOPEN_SOURCE 700
+#include <stdio.h> /* printf */
+#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE, strtoull */
+
+#include "common.h" /* virt_to_phys_user */
+
+int main(int argc, char **argv)
+{
+	pid_t pid;
+	uintptr_t vaddr, paddr = 0;
+
+	if (argc < 3) {
+		printf("Usage: %s pid vaddr\n", argv[0]);
+		return EXIT_FAILURE;
+	}
+	pid = strtoull(argv[1], NULL, 0);
+	vaddr = strtoull(argv[2], NULL, 0);
+	if (virt_to_phys_user(&paddr, pid, vaddr)) {
+		fprintf(stderr, "error: virt_to_phys_user\n");
+		return EXIT_FAILURE;
+	};
+	printf("0x%jx\n", (uintmax_t)paddr);
+	return EXIT_SUCCESS;
+}