tools: labs: Add kernel profiling templates

Signed-off-by: Sergiu Weisz <sergiu121@gmail.com>

Author: sergiu121

tools/labs/templates/kernel_profiling/1-io/Kbuild

@@ -0,0 +1,3 @@
+ccflags-y = -Wno-unused-function -Wno-unused-label -Wno-unused-variable
+
+obj-m	:= io.o

tools/labs/templates/kernel_profiling/1-io/io.c

@@ -0,0 +1,57 @@
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/sched/task.h>
+
+#define MY_MAJOR		42
+#define MY_MINOR		0
+#define MODULE_NAME		"deferred"
+
+#define TIMER_TYPE_NONE		-1
+#define TIMER_TYPE_SET		0
+#define TIMER_TYPE_ALLOC	1
+#define TIMER_TYPE_MON		2
+
+MODULE_DESCRIPTION("Generate disruptive interrupts");
+MODULE_AUTHOR("SO2");
+MODULE_LICENSE("GPL");
+
+struct timer_list timer;
+
+static void timer_handler(struct timer_list *tl)
+{
+	unsigned long deadline = jiffies + HZ;
+
+	while (jiffies < deadline) {
+		(void)0;
+	}
+	mod_timer(&timer, jiffies + HZ);
+}
+
+static int deferred_init(void)
+{
+	int err;
+
+	pr_info("[deferred_init] Init module\n");
+
+	timer_setup(&timer, timer_handler, 0);
+	mod_timer(&timer, jiffies + 5 * HZ);
+
+	return 0;
+}
+
+static void deferred_exit(void)
+{
+	struct mon_proc *p, *n;
+
+	pr_info("[deferred_exit] Exit module\n" );
+
+	del_timer_sync(&timer);
+}
+
+module_init(deferred_init);
+module_exit(deferred_exit);

tools/labs/templates/kernel_profiling/2-scheduling/Makefile

@@ -0,0 +1,9 @@
+CFLAGS = -Wall -m32 -pthread -g
+LDFLAGS = -static -m32 -pthread
+
+scheduling: scheduling.o
+
+.PHONY: clean
+
+clean:
+	-rm -f *~ *.o scheduling

tools/labs/templates/kernel_profiling/2-scheduling/scheduling.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+void helper(int i) {
+	printf("%d\n", i);
+}
+
+void * thread_start(void *arg) {
+
+	helper((int) arg);
+	pthread_exit(NULL);
+}
+
+int main(int argc, char *argv[]) {
+
+	int pid = 0;
+	pthread_t tid[300];
+	struct timeval begin, end;
+
+	if (argc < 1) {
+		printf("./scheduling <mode>\n");
+		return -1;
+	}
+
+	gettimeofday(&begin, NULL);
+
+	for (int i = 0; i < 300; i++) {
+		if (atoi(argv[1]) == 0) {
+			pid = pthread_create(&tid[i], NULL, &thread_start, (void *) i);
+			if (pid != 0) {
+				break;
+			}
+		} else {
+			pid = fork();
+			if (pid == 0) {
+				helper(i);
+				break;
+			}
+		}
+	}
+
+	gettimeofday(&end, NULL);
+
+	return 0;
+}

tools/labs/templates/kernel_profiling/3-memory/Makefile

@@ -0,0 +1,9 @@
+CFLAGS=-Wall -m32
+LDFLAGS=-static -m32
+
+memory: memory.o
+
+.PHONY: clean
+
+clean:
+	-rm -f *~ *.o memory

tools/labs/templates/kernel_profiling/3-memory/memory.c

@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+int main(int argc, char *argv[]) {
+
+	int src_fd, dst_fd, mode;
+	struct stat st;
+	unsigned long to_write, size, blk_size;
+	char *src_p, *dst_p, *buf;
+
+	if (argc < 3) {
+		printf("./memory <mode> <blk_size> <src> <dst>\n");
+		return -1;
+	}
+
+	mode = atoi(argv[1]);
+	blk_size = atoi(argv[2]);
+
+	printf("mode %d blk_size %ld src %s dst %s\n",
+		mode, blk_size, argv[3], argv[4]);
+
+	src_fd = open(argv[3], O_RDONLY);
+	if (src_fd < 0)
+		return src_fd;
+
+	stat(argv[3], &st);
+	size = to_write = st.st_size;
+
+	if (mode == 0) {
+		src_p = mmap(NULL, size, PROT_READ, MAP_SHARED, src_fd, 0);
+		if (src_p < 0)
+			return -1;
+	}
+
+	dst_fd = open(argv[4], O_CREAT | O_RDWR | O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+	if (dst_fd < 0)
+		return -1;
+
+	ftruncate(dst_fd, size);
+
+	if (mode == 0) {
+		dst_p = mmap(NULL, size, PROT_WRITE | PROT_READ, MAP_SHARED, dst_fd, 0);
+		if (dst_p < 0)
+			return -1;
+	}
+
+	buf = malloc(blk_size);
+
+	while (to_write > blk_size) {
+		if (mode == 0) {
+			memcpy(dst_p, src_p, blk_size);
+		} else {
+			pread(src_fd, buf, blk_size, size - to_write);
+			pwrite(dst_fd, buf, blk_size, size - to_write);
+		}
+
+		to_write -= blk_size;
+		dst_p += blk_size;
+		src_p += blk_size;
+	}
+
+	if (mode == 0) {
+		memcpy(dst_p, src_p, to_write);
+		msync(dst_p - size, size, MS_SYNC);
+	} else {
+		pread(src_fd, buf, to_write, to_write);
+		pwrite(dst_fd, buf, blk_size, to_write);
+	}
+
+
+	close(src_fd);
+	close(dst_fd);
+
+	return 0;
+}

tools/labs/templates/kernel_profiling/4-bio/Kbuild

@@ -0,0 +1,3 @@
+EXTRA_CFLAGS = -Wall -g -Wno-unused
+
+obj-m = bio.o

tools/labs/templates/kernel_profiling/4-bio/bio.c

@@ -0,0 +1,110 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+#include <linux/genhd.h>
+#include <linux/blkdev.h>
+#include <linux/kthread.h>
+#include <linux/delay.h>
+
+MODULE_AUTHOR("SO2");
+MODULE_DESCRIPTION("Relay disk");
+MODULE_LICENSE("GPL");
+
+#define KERN_LOG_LEVEL		KERN_ALERT
+
+#define PHYSICAL_DISK_NAME	"/dev/vdb"
+#define KERNEL_SECTOR_SIZE	512
+
+#define MAX_BIO 30000
+#define MAX_THREAD 20
+#define MAX_RUNS 40
+
+
+/* pointer to physical device structure */
+static struct block_device *phys_bdev;
+
+struct bio *bio[MAX_BIO];
+struct page *page[MAX_BIO];
+
+static void alloc_io(struct block_device *bdev)
+{
+	int i;
+
+	for (i = 0; i < MAX_BIO; i++) {
+		bio[i] = bio_alloc(GFP_NOIO, 1);
+		bio[i]->bi_disk = bdev->bd_disk;
+		bio[i]->bi_opf = REQ_OP_READ;
+
+		bio[i]->bi_iter.bi_sector = i;
+		page[i] = alloc_page(GFP_NOIO);
+		bio_add_page(bio[i], page[i], KERNEL_SECTOR_SIZE, 0);
+	}
+}
+
+static struct block_device *open_disk(char *name)
+{
+	struct block_device *bdev;
+
+	bdev = blkdev_get_by_path(name, FMODE_READ | FMODE_WRITE | FMODE_EXCL, THIS_MODULE);
+	if (IS_ERR(bdev)) {
+		printk(KERN_ERR "blkdev_get_by_path\n");
+		return NULL;
+	}
+
+	return bdev;
+}
+
+int my_thread_f(void *data)
+{
+	int part, sec, i, run;
+
+	part = (int) data;
+	sec = MAX_BIO / MAX_THREAD;
+
+	for (run = 0; run < MAX_RUNS; run++) {
+		for (i = sec * part; i < (part + 1) * sec; i++)
+			submit_bio_wait(bio[i]);
+		msleep(30 * 1000);
+	}
+
+	do_exit(0);
+}
+
+static int __init relay_init(void)
+{
+	int i = 0;
+
+	phys_bdev = open_disk(PHYSICAL_DISK_NAME);
+	if (phys_bdev == NULL) {
+		printk(KERN_ERR "[relay_init] No such device\n");
+		return -EINVAL;
+	}
+
+	alloc_io(phys_bdev);
+
+	for (i = 0; i < MAX_THREAD; i++)
+		kthread_run(my_thread_f, i, "%skwriterd%d", "my", (void *)i);
+
+	return 0;
+}
+
+static void close_disk(struct block_device *bdev)
+{
+	blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
+}
+
+static void __exit relay_exit(void)
+{
+	int i;
+
+	for (i = 0; i < MAX_BIO; i++) {
+		bio_put(bio[i]);
+		__free_page(page[i]);
+	}
+	close_disk(phys_bdev);
+}
+
+module_init(relay_init);
+module_exit(relay_exit);