Adding hello world system call to Linux

I just finished doing this and so thought I’d write about it in my blog since it took me a while to get this done after many an experimentation I suppose :P. So here goes!

I did this on an Ubuntu 12.04.1 LTS OS running on an 64bit machine but this post should mostly work on any Linux OS(with a few differences here and there).

Step 1: Get the source

The first step is to download the source code of the Linux kernel. I used the one available from the repositories but feel free to get the sources from kernel.org.

apt-get source linux-image-$(uname -r)

This would download all the archives and unpack it into a directory linux-3.2.0.

Step 2: Add system call to system call table

Open the file arch/x86/kernel/syscall_table_32.S and add the following line.

.long sys_hello

Step 3: Define macros associated with system call

Open the file arch/x86/include/asm/unistd_32.h. You will notice that a macro is defined for each system call. At the end of the huge macro definition, add a definition for our new system call. I added the following line:

#define __NR_hello 349

and accordingly incremented the value of the macro NR_SYSCALLS:

#define NR_syscalls 350

Also, add the macro definition to the file arch/x86/include/asm/unistd_64.h

#define __NR_hello 312
 __SYSCALL(__NR_hello, sys_hello)

Now to the file include/linux/syscalls.h, add the prototype of the system call.

asmlinkage long sys_hello(void);

Now, in the root directory of the kernel sources, create a directory named hello and in it, a file hello.c with the following content:

#include <linux/kernel.h>

asmlinkage long sys_hello(void)
{
    printk("Hello world\n");
    return 0;
}

printk is similar to printf function of C but writes to the kernel log instead of the screen. asmlinkage is a key word used to indicate that all parameters of the function(here none of course 🙂 ) would be available on the stack.

After creating the function definition, create a file named Makefile within the hello directory and the following content to the file:

obj-y := hello.o

This is to ensure that our hello.c file is compiled and included in the kernel.

Now, to the Makefile in the root directory of the kernel sources, edit the following line:

core-y          += kernel/ mm/ fs/ ipc/ security/ crypto/ block/

to:

core-y          += kernel/ mm/ fs/ ipc/ security/ crypto/ block/ hello/

This is to tell the compiler that the source files of our new system call are in present in the hello directory.

That’s it-you have added your own system call! Now all you need to compile the kernel. [1] is a good place to get information on how to compile the kernel. You needn’t do all the steps since you have the sources-read it carefully :)!

After you compile and reboot into the kernel you just compiled, try running the following program.

#include <stdio.h>
#include <linux/kernel.h>
#include <sys/syscall.h>
#include <unistd.h>

#define __NR_hello 312 //349 if you are running a 32bit kernel and following my tutorial

long hello_syscall(void)
{
    return syscall(__NR_hello);
}

int main(int argc, char *argv[])
{
    long int a = hello_syscall();
    printf("System call returned %ld\n", a);
    return 0;
}

The output of the program would be:

System call returned 0

The printk’s output get written to the kernel log. To view it, run the command

dmesg

and sure enough you will see the Hello World on the very last line.

Congratulations you have just added a system call to Linux!

Helpful resources

[1] http://www.howopensource.com/2011/08/how-to-compile-and-install-linux-kernel-3-0-in-ubuntu-11-04-10-10-and-10-04/

[2] http://bluegrit.cs.umbc.edu/~lsebald1/cmsc421/new-syscall.php

[3] https://wiki.ubuntu.com/Kernel/BuildYourOwnKernel (easier method)

[4] https://help.ubuntu.com/community/Kernel/Compile