Abdelrahman Ahmed

Writing Simple Linux Kernel Modules

Sat, 04 Apr 2020 19:00:00 +0000

Linux Kernel Modules (LKM) (called kernel extension in other operating systems) are pieces of code that can be loaded and unloaded into the kernel upon demand. Here I’m going to guide you write your first linux kernel module.

Through modules you can extend kernel functionalities without rebooting the system. This is powerful as you don’t have to rebuild and reboot the kernel to add new functionalities.

What are LKMs used for?

LKMs give you accessibility to system hardware since your code will be part of the kernel and that enables you to do a lot (be careful as you can crash the system easily). For example

Device Drivers
Network Drivers
File System Drivers
System Calls

Write Hello World Kernel Module

Now, we are going to write a simple kernel module that prints a Hello World! message when it’s loaded and Good Bye World! when it’s unloaded.

Installing the linux headers

Debian based distributions (Debian / Ubuntu / Linux Mint / elementary OS)

sudo apt install -y build-essential linux-headers-$(uname -r) make libelf-dev

$(uname -r) gets current kernel release

Module Source Code

Create file hello-world.c

/*  
 *  hello-world.c
 */
#include <linux/module.h>	/* Needed by all modules */
#include <linux/kernel.h>	/* Needed for KERN_INFO */

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Abdelrahman Ahmed");
MODULE_DESCRIPTION("Hello World module");

int init_module(void)
{
	printk(KERN_INFO "Hello World!\n");

	/* 
	 * On success, return 0.
	 * On error, return -1 and errno is set according to error
	 */
	return 0;
}

void cleanup_module(void)
{
	printk(KERN_INFO "Good Bye World!\n");
}

printk (defined in kernel) prints messages to the kernel log and has an optional prefix string Loglevel indicates priority of that message. In previous example we set logging level to KERN_INFO (Normal information)

Compile Kernel Module

Kernel modules is compiled differently from usual programs. You need to create a Makefile(case sensitive) in the same directory of our module hello-world.c

obj-m += hello-world.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

This file simply compiles hello-world module and this is a simple explanation for this file

Targets all and clean are required for makefiles to build and clean your module
$(shell uname -r) gets current kernel release
$(PWD) gets current directory
Make calls Makefile of kernel’s builder (-C changes to that path) and sets a variable M to return to your current directory after processing it

ab@ubuntu:~/hello-world$ make 
make -C /lib/modules/4.15.0/build M=/home/ab/hello-world modules
make[1]: Entering directory '/usr/src/linux-headers-4.15.0'
  CC [M]  /home/ab/hello-world/hello-world.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/ab/hello-world/hello-world.mod.o
  LD [M]  /home/ab/hello-world/hello-world.ko
make[1]: Leaving directory '/usr/src/linux-headers-4.15.0'

Now, we have built our first kernel module. you will find it in current directory with name hello-world.ko. Let’s get more info about this module by executing modinfo hello-world.ko

ab@ubuntu:~/hello-world$ modinfo hello-world.ko
filename:       /home/ab/hello-world/hello-world.ko
description:    Hello World module
author:         Abdelrahman Ahmed
license:        GPL
srcversion:     5A77F42048F97F6D685FF74
depends:        
retpoline:      Y
name:           hello_world
vermagic:       4.15.0 SMP mod_unload 

Load Kernel Module

To load kernel module, you just need to execute command sudo insmod hello-world.ko.

When module is inserted into kernel, the init_module will be invoked

After loading Hello World module, let’s check our loading message in kernel log by executing dmesg | tail -1 (getting only last message)

ab@ubuntu:~/hello-world$ dmesg | tail -1
[2753755.444706] Hello World!

Unload Kernel Module

To unload kernel module, you just need to execute command sudo rmmod hello-world.ko.

when the module is removed from kernel, the cleanup_module will be invoked

After unloading it, let’s check our unloading message in kernel log by executing dmesg | tail -1 again

ab@ubuntu:~/hello-world$ dmesg | tail -1
[2753926.708205] Good Bye World!

Finally, you wrote your first Linux Kernel Module :tada: and be able to load and unload it. Hopefully, this article is helpful for you. If you have any question ask in comments. Thanks for reading :heart:

Version Control Systems

Sun, 29 Mar 2020 16:00:00 +0000

Version Control Systems (VCS) is a category of software that records changes to a file or set of files over time so that you can recall specific versions later. We are going to talk about the need for VCS, its types and available tools

Why do I need something like that?

Scenario 1
- You are asked to do a software project with a team and you will split the project into tasks to work on it in parallel
- After finishing part of the project, you will test what you achieved through integrating parts
- Usually, the project does not work
- You will solve issues to be able to test their project, then update your local copies of code
Scenario 2
- You have a file changes frequently and at some point you want to get back to a specific version
- You will create a numbered versions of same file

Let’s disccuss these scenarios,

First scenario, when project getting larger, or expanding team, it will be difficult to maintain project (cases like, you forget to share fix, when you add fix a file contains a new code you added is overwritten, etc.)
Second scenario, you will have a directory for each file contains all versions of that file and this will make structure of files complex in technical and non-technical projects

Let’s think what we need to solve these kind of issues. We need a solution that

Keeps the code or file
Keeps a history of the code or file
Merges files and handle conflicts (e.g. integrating project for testing)

That’s what Version Control System (VCS) does :tada:

Version Control System Types

Local VCS
Centralized VCS
Distributed VCS

Let’s discuss each type of these types

Local VCS

Here, this focused about the second scenario. It keeps a snapshot for each version in a linear history of your files, so when you change file, it creates a new version of it.

Centralized VCS

Here, this focused about the first scenario. Files are saved in a server containing all versions history. To make edits, you need to get a local copy of latest version and then update server with your edits to create a new version. Server will maintain a linear history of your files. This type will guarantee that there is no conflicts could happen since there is one maintainer (the server) and it makes sure that will not happen

Distributed / Decentralized VCS

Here, this focused about the first scenario too. Each one holds local copy of files with its versions history (each one could be a server). To make edits, just update files and create a new version on your local copy. You can then update server with new versions you added. Also, you can get only new versions from server if there are

Centralized Vs Distributed VCSs

Centralized

Easier to understand
Everything is controlled from one place
You need to be connected to server to work on files
Performance is worse since you need connection to server to get latest version before each edit

Distributed

Could be confusing in certain cases
You can edit directly on your local copy without connection
Performance is better as you already have a local copy

This is a list of VCSs

Subversion(SVN)
- Centralized VCS
- Not widely used due to its cons
Git
- Distributed VCS
- Widely used in software development
- Used in Linux Kernel development
Mercurial
- Distributed VCS
- Currently, used by Mozilla
Bazaar
- Distributed VCS
BitKeeper
- Distributed VCS

Later I’ll add more articles about distributed VCSs specially (Git) and its core concepts.

Finally, Thank you for reading this :heart:! I hope this article is helpful for you. If you have any questions, you’re welcome to ask through comments here.

References

Git Pro

Welcome to my Blog

Fri, 27 Mar 2020 16:00:00 +0000

Today, I’m starting my simple personal blog! :tada::tada::tada:

This blog is a Jeykll based and hosted on Github :heart:

As a start I used a Kean’s blog. I do like how it’s simple and clear and I think this can be a good start, but I’m going to support later more features related to blog (pagination, Newsletter, etc.)

Here is a place to share and discuss with you my interests and technical experience (for all levels). Hopefully, this could make your life better and easier. Thank you :heart: