Operating Systems 2017F Lecture 16

Video

The video from the lecture given on Nov. 7, 2017 is now available.

Code

newgetpid.c

/* Code derived from:
  https://appusajeev.wordpress.com/2011/06/18/writing-a-linux-character-device-driver/
  and
  http://pete.akeo.ie/2011/08/writing-linux-device-driver-for-kernels.html
*/

#include <linux/module.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <asm/uaccess.h>

#define dbg(format, arg...) do { if (debug) pr_info(CLASS_NAME ": %s: " format, __FUNCTION__, ## arg); } while (0)
#define err(format, arg...) pr_err(CLASS_NAME ": " format, ## arg)
#define info(format, arg...) pr_info(CLASS_NAME ": " format, ## arg)
#define warn(format, arg...) pr_warn(CLASS_NAME ": " format, ## arg)


#define DEVICE_NAME "newgetpid"
#define CLASS_NAME "comp3000"

static struct class* newgetpid_class = NULL;
static struct device* newgetpid_device = NULL;
static int newgetpid_major;

static int newgetpid_open(struct inode *the_inode, struct file *f)
{
        return 0;
}

static ssize_t newgetpid_read(struct file *f, char *buf, size_t len, loff_t *offset)
{
        size_t i, msglen;
        pid_t thepid;

        char message[100];
        
        if (*offset > 0) {
                return 0;
        }
        
        thepid = task_tgid_vnr(current);

        snprintf(message, 100, "Your PID is %d!\n", thepid);
        
        msglen = strlen(message);

        if (len < msglen) {
                msglen = len;
        }

        for (i = 0; i < msglen; i++) {
                put_user(message[i], buf++);
        }

        *offset = i;

        return i;
}

static int newgetpid_release(struct inode *the_inode, struct file *f)
{
        printk(KERN_ALERT "Newgetpid device closed\n");
        return 0;
}


static struct file_operations newgetpid_fops = {
        .open = newgetpid_open,
        .read = newgetpid_read,
        .release = newgetpid_release,
};


static char *newgetpid_devnode(struct device *dev, umode_t *mode)
{
        if (mode)
	        *mode = 0444;
        return NULL;
}

static int __init newgetpid_init(void)
{
        int retval;
  
        newgetpid_major = register_chrdev(0, DEVICE_NAME, &newgetpid_fops);
        if (newgetpid_major < 0) {
                err("failed to register device: error %d\n", newgetpid_major);
                retval = newgetpid_major;
                goto failed_chrdevreg;
        }
 
        newgetpid_class = class_create(THIS_MODULE, CLASS_NAME);
        if (IS_ERR(newgetpid_class)) {
                err("failed to register device class '%s'\n", CLASS_NAME);
                retval = PTR_ERR(newgetpid_class);
                goto failed_classreg;
        }
 
	newgetpid_class->devnode = newgetpid_devnode;

        newgetpid_device = device_create(newgetpid_class, NULL, MKDEV(newgetpid_major, 0),
                                    NULL, DEVICE_NAME);

        if (IS_ERR(newgetpid_device)) {
                err("failed to create device '%s'\n", DEVICE_NAME);
                retval = PTR_ERR(newgetpid_device);
                goto failed_devreg;
        }
        
        info("Newgetpid device registered using major %d.\n", newgetpid_major);
        
        return 0;
        
 failed_devreg:
        class_unregister(newgetpid_class);
        class_destroy(newgetpid_class);
 failed_classreg:
        unregister_chrdev(newgetpid_major, DEVICE_NAME);
 failed_chrdevreg:
        return -1;
}

static void __exit newgetpid_exit(void)
{
        device_destroy(newgetpid_class, MKDEV(newgetpid_major, 0));
        class_unregister(newgetpid_class);
        class_destroy(newgetpid_class);
        unregister_chrdev(newgetpid_major, "newgetpid");
        info("Unloading Newgetpid module.\n");
        return;
}

module_init(newgetpid_init);
module_exit(newgetpid_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anil Somayaji <soma@scs.carleton.ca>");
MODULE_DESCRIPTION("A write newgetpid character device module");

Makefile

obj-m := newgetpid.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
        $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules

Additional Notes

What determines what files you can and cannot create?

Ssh privileges

Anything that you can do as an ssh user you can do in the vm, just doing file operations
Sshfs means when you do read and write system calls for programs in a directory it also does it on the remote machine
Ssh is a good tool to access remote files locally, we will use it to edit modules

Ones/newgetpid program:

We want to extend its functionality in a specific way
We want to access info about the process that made the system call
Let's get current processes id
- Normally we would use getpid
- But we can't make system calls in kernel space
- But we can call the function that the system call uses or just copy the functionality
Code for this is in "kernel/sys.c"

Syscall_define0:

Macro that expands
Defines system calls with "getpid" and takes no arguments

Can use the code inside the function but not the function itself in the kernel
Getpid returns a pid_t
Instead of get_ones returning all those ones we want it to return the pid
Lets try to get it to output a basic string with the pid

How does printk work?

Printk sends its output to the kernel log
We changed the name to "newgetpid"
How do we convert int to string to print the pid?
- Make a buffer, let's call it "message"

Why does the pid keep incrementing each time we call "cat /dev/newgetpid"?

"Cat" spawns a process so every time we do a fork we get a new pid

Why can we use snprintf but not printf?

We include "linux/kernel.h" which defines snprintf but not printf
Printf assumes we have a standard output to print to
Snprintf only needs character arrays for it to work

Read functionality uses an API
Adding new functionality like "write" is easy, just look at the standard API and original kernel source
All device files have their own custom read and write functions

Why do we use goto's?

C has no exception handling functionality so we implement our own
Jumps to error paths: failed_devreg, failed_classreg, failed_chrdevreg (very important in the kernel)
Kernel needs to be able to handle it's own errors
Needs to free up allocated resources, "undo" everything

"." is the current directory
".." is the parent directory
- Introduces another hardlink

In order to build kernel modules, you need to have the headers associated with the current kernel you're running
Modules are specified to a particular version of the kernel