Operating Systems 2017F Lecture 16

Video

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

Code

Code for download

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