1. The makefile has a variable which specifies the kernel directory: KDIR := /lib/modules/$(shell uname -r)/build. On the virtual image, this variabla becomes /lib/modules/2.6.27.7-smp/build.
2. Kernel modules do not have access to standard C libraries. We have to use libraries provided by the kernel. printk() is a function defined in the kernel which is almost eqvuivalent to printf().
3. The -C flag in the makefile tells make to change to the specified directory before doing anything else. I navigated to /lib/modules/2.6.27.7-smp/build and discovered another Makefile, which performs the actual build. I scrolled through the file and noticed some code which handles both modules and clean. I didn't quite understand what the -M flag is doing though. I wasn't able to find it in the man pages either.
4. If we remove MODULE_LICENSE from our code, the kernel will complain when we are loading the module: modpost: missing MODULE_LICENSE().

a)

static ssize_t dev_write (struct file *file, const char *buf, size_t count, loff_t *ppos)
{
	sprintf(msg, "");
	int bufLen=0;

	if( copy_from_user( msg, buf, count ) )
	{
		printk("simplkm_rw: copy_from_user failed\n");
		return -EFAULT;
	}
	else
	{
		printk(KERN_INFO "%s\n", msg);
		sprintf(msg + strlen(msg), "\n");
		bufLen = strlen( msg );
		return bufLen;
	}
}

And add this line to the file_operations struct:

.write = dev_write

c)

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
)

func main() {
	msg := flag.String("write", "", "message to write to /dev/simp_rw")
	flag.Parse()

	if *msg != "" {
		write(*msg)
	} else {
		read()
	}
}

func write(msg string) {
	file, err := os.OpenFile("/dev/simp_rw", os.O_RDWR, 0644)
	defer file.Close()
	checkError(err)
	_, err = file.Write([]byte(msg))
	checkError(err)
}

func read() {
	file, err := os.Open("/dev/simp_rw")
	defer file.Close()
	checkError(err)
	data := make([]byte, 100)
	count, err := file.Read(data)
	checkError(err)
	fmt.Printf("%q\n", data[:(count-1)])
}

func checkError(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

d) I believe this question is more relevant for task b. Task a only handles one message, so we don't have to think about protection. The buffer is cleared every time write() is called, so we will never have a buffer overflow.

a)

b)

Why do we have to use copy_to_user() and copy_from_user() in a kernel driver? Protection is a keyword here. We should not be able to acecss kernel addresses directly from user space. The functions check this by calling access_ok() on the adress. The functions handles errors as well. This means that if we encounter a page fault during copy, we can return -EFAULT to the user and prevent the kernel from crashing.