/* 
 *  procfs.c -  create a "file" in /proc, which allows both input and output.
 */
#include /* We're doing kernel work */
#include /* Specifically, a module */
#include /* Necessary because we use proc fs */
#include /* for get_user and put_user */

/* 
 * Here we keep the last message received, to prove
 * that we can process our input 
 */
#define MESSAGE_LENGTH 80
static char Message[MESSAGE_LENGTH];
static struct proc_dir_entry *Our_Proc_File;

#define PROC_ENTRY_FILENAME "rw_test"

static ssize_t module_output(struct file *filp,/* see include/linux/fs.h   */
     char *buffer,/* buffer to fill with data */
     size_t length,/* length of the buffer     */
     loff_t * offset)
{
static int finished = 0;
int i;
char message[MESSAGE_LENGTH + 30];

/* 
 * We return 0 to indicate end of file, that we have
 * no more information. Otherwise, processes will
 * continue to read from us in an endless loop. 
 */
if (finished) {
finished = 0;
return 0;
}

/* 
 * We use put_user to copy the string from the kernel's
 * memory segment to the memory segment of the process
 * that called us. get_user, BTW, is
 * used for the reverse. 
 */
sprintf(message, "Last input:%s", Message);
for (i = 0; i < length && message[i]; i++)
put_user(message[i], buffer + i);

/* 
 * Notice, we assume here that the size of the message
 * is below len, or it will be received cut. In a real
 * life situation, if the size of the message is less
 * than len then we'd return len and on the second call
 * start filling the buffer with the len+1'th byte of
 * the message. 
 */
finished = 1;

return i;/* Return the number of bytes "read" */
}

static ssize_t
module_input(struct file *filp, const char *buff, size_t len, loff_t * off)
{
int i;
/* 
 * Put the input into Message, where module_output
 * will later be able to use it 
 */
for (i = 0; i < MESSAGE_LENGTH - 1 && i < len; i++)
get_user(Message[i], buff + i);

Message[i] = '\0';/* we want a standard, zero terminated string */
return i;
}

/* 
 * This function decides whether to allow an operation
 * (return zero) or not allow it (return a non-zero
 * which indicates why it is not allowed).
 *
 * The operation can be one of the following values:
 * 0 - Execute (run the "file" - meaningless in our case)
 * 2 - Write (input to the kernel module)
 * 4 - Read (output from the kernel module)
 *
 * This is the real function that checks file
 * permissions. The permissions returned by ls -l are
 * for referece only, and can be overridden here.
 */

static int module_permission(struct inode *inode, int op, struct nameidata *foo)
{
/* 
 * We allow everybody to read from our module, but
 * only root (uid 0) may write to it 
 */
if (op == 4 || (op == 2 && current->euid == 0))
return 0;

/* 
 * If it's anything else, access is denied 
 */
return -EACCES;
}

/* 
 * The file is opened - we don't really care about
 * that, but it does mean we need to increment the
 * module's reference count. 
 */
int module_open(struct inode *inode, struct file *file)
{
try_module_get(THIS_MODULE);
return 0;
}

/* 
 * The file is closed - again, interesting only because
 * of the reference count. 
 */
int module_close(struct inode *inode, struct file *file)
{
module_put(THIS_MODULE);
return 0;/* success */
}

static struct file_operations File_Ops_4_Our_Proc_File = {
.read = module_output,
.write = module_input,
.open = module_open,
.release = module_close,
};

/* 
 * Inode operations for our proc file. We need it so
 * we'll have some place to specify the file operations
 * structure we want to use, and the function we use for
 * permissions. It's also possible to specify functions
 * to be called for anything else which could be done to
 * an inode (although we don't bother, we just put
 * NULL). 
 */

static struct inode_operations Inode_Ops_4_Our_Proc_File = {
.permission = module_permission,/* check for permissions */
};

/* 
 * Module initialization and cleanup 
 */
int init_module()
{
int rv = 0;
Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
Our_Proc_File->owner = THIS_MODULE;
Our_Proc_File->proc_iops = &Inode_Ops_4_Our_Proc_File;
Our_Proc_File->proc_fops = &File_Ops_4_Our_Proc_File;
Our_Proc_File->mode = S_IFREG | S_IRUGO | S_IWUSR;
Our_Proc_File->uid = 0;
Our_Proc_File->gid = 0;
Our_Proc_File->size = 80;

if (Our_Proc_File == NULL) {
rv = -ENOMEM;
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
printk(KERN_INFO "Error: Could not initialize /proc/test\n");
}

return rv;
}

void cleanup_module()
{
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
}

/*
 *  chardev.c - Create an input/output character device
 */

#include /* We're doing kernel work */
#include /* Specifically, a module */
#include 
#include /* for get_user and put_user */

#include "chardev.h"
#define SUCCESS 0
#define DEVICE_NAME "char_dev"
#define BUF_LEN 80

/* 
 * Is the device open right now? Used to prevent
 * concurent access into the same device 
 */
static int Device_Open = 0;

/* 
 * The message the device will give when asked 
 */
static char Message[BUF_LEN];

/* 
 * How far did the process reading the message get?
 * Useful if the message is larger than the size of the
 * buffer we get to fill in device_read. 
 */
static char *Message_Ptr;

/* 
 * This is called whenever a process attempts to open the device file 
 */
static int device_open(struct inode *inode, struct file *file)
{
#ifdef DEBUG
printk("device_open(%p)\n", file);
#endif

/* 
 * We don't want to talk to two processes at the same time 
 */
if (Device_Open)
return -EBUSY;

Device_Open++;
/*
 * Initialize the message 
 */
Message_Ptr = Message;
try_module_get(THIS_MODULE);
return SUCCESS;
}

static int device_release(struct inode *inode, struct file *file)
{
#ifdef DEBUG
printk("device_release(%p,%p)\n", inode, file);
#endif

/* 
 * We're now ready for our next caller 
 */
Device_Open--;

module_put(THIS_MODULE);
return SUCCESS;
}

/* 
 * This function is called whenever a process which has already opened the
 * device file attempts to read from it.
 */
static ssize_t device_read(struct file *file,/* see include/linux/fs.h   */
   char __user * buffer,/* buffer to be
 * filled with data */
   size_t length,/* length of the buffer     */
   loff_t * offset)
{
/* 
 * Number of bytes actually written to the buffer 
 */
int bytes_read = 0;

#ifdef DEBUG
printk("device_read(%p,%p,%d)\n", file, buffer, length);
#endif

/* 
 * If we're at the end of the message, return 0
 * (which signifies end of file) 
 */
if (*Message_Ptr == 0)
return 0;

/* 
 * Actually put the data into the buffer 
 */
while (length && *Message_Ptr) {

/* 
 * Because the buffer is in the user data segment,
 * not the kernel data segment, assignment wouldn't
 * work. Instead, we have to use put_user which
 * copies data from the kernel data segment to the
 * user data segment. 
 */
put_user(*(Message_Ptr++), buffer++);
length--;
bytes_read++;
}

#ifdef DEBUG
printk("Read %d bytes, %d left\n", bytes_read, length);
#endif

/* 
 * Read functions are supposed to return the number
 * of bytes actually inserted into the buffer 
 */
return bytes_read;
}

/* 
 * This function is called when somebody tries to
 * write into our device file. 
 */
static ssize_t
device_write(struct file *file,
     const char __user * buffer, size_t length, loff_t * offset)
{
int i;

#ifdef DEBUG
printk("device_write(%p,%s,%d)", file, buffer, length);
#endif

for (i = 0; i < length && i < BUF_LEN; i++)
get_user(Message[i], buffer + i);

Message_Ptr = Message;

/* 
 * Again, return the number of input characters used 
 */
return i;
}

/* 
 * This function is called whenever a process tries to do an ioctl on our
 * device file. We get two extra parameters (additional to the inode and file
 * structures, which all device functions get): the number of the ioctl called
 * and the parameter given to the ioctl function.
 *
 * If the ioctl is write or read/write (meaning output is returned to the
 * calling process), the ioctl call returns the output of this function.
 *
 */
int device_ioctl(struct inode *inode,/* see include/linux/fs.h */
 struct file *file,/* ditto */
 unsigned int ioctl_num,/* number and param for ioctl */
 unsigned long ioctl_param)
{
int i;
char *temp;
char ch;

/* 
 * Switch according to the ioctl called 
 */
switch (ioctl_num) {
case IOCTL_SET_MSG:
/* 
 * Receive a pointer to a message (in user space) and set that
 * to be the device's message.  Get the parameter given to 
 * ioctl by the process. 
 */
temp = (char *)ioctl_param;

/* 
 * Find the length of the message 
 */
get_user(ch, temp);
for (i = 0; ch && i < BUF_LEN; i++, temp++)
get_user(ch, temp);

device_write(file, (char *)ioctl_param, i, 0);
break;

case IOCTL_GET_MSG:
/* 
 * Give the current message to the calling process - 
 * the parameter we got is a pointer, fill it. 
 */
i = device_read(file, (char *)ioctl_param, 99, 0);

/* 
 * Put a zero at the end of the buffer, so it will be 
 * properly terminated 
 */
put_user('\0', (char *)ioctl_param + i);
break;

case IOCTL_GET_NTH_BYTE:
/* 
 * This ioctl is both input (ioctl_param) and 
 * output (the return value of this function) 
 */
return Message[ioctl_param];
break;
}

return SUCCESS;
}

/* Module Declarations */

/* 
 * This structure will hold the functions to be called
 * when a process does something to the device we
 * created. Since a pointer to this structure is kept in
 * the devices table, it can't be local to
 * init_module. NULL is for unimplemented functions. 
 */
struct file_operations Fops = {
.read = device_read,
.write = device_write,
.ioctl = device_ioctl,
.open = device_open,
.release = device_release,/* a.k.a. close */
};

/* 
 * Initialize the module - Register the character device 
 */
int init_module()
{
int ret_val;
/* 
 * Register the character device (atleast try) 
 */
ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);

/* 
 * Negative values signify an error 
 */
if (ret_val < 0) {
printk("%s failed with %d\n",
       "Sorry, registering the character device ", ret_val);
return ret_val;
}

printk("%s The major device number is %d.\n",
       "Registeration is a success", MAJOR_NUM);
printk("If you want to talk to the device driver,\n");
printk("you'll have to create a device file. \n");
printk("We suggest you use:\n");
printk("mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
printk("The device file name is important, because\n");
printk("the ioctl program assumes that's the\n");
printk("file you'll use.\n");

return 0;
}

/* 
 * Cleanup - unregister the appropriate file from /proc 
 */
void cleanup_module()
{
int ret;

/* 
 * Unregister the device 
 */
ret = unregister_chrdev(MAJOR_NUM, DEVICE_NAME);

/* 
 * If there's an error, report it 
 */
if (ret < 0)
printk("Error in module_unregister_chrdev: %d\n", ret);
}

/*
 *  chardev.h - the header file with the ioctl definitions.
 *
 *  The declarations here have to be in a header file, because
 *  they need to be known both to the kernel module
 *  (in chardev.c) and the process calling ioctl (ioctl.c)
 */

#ifndef CHARDEV_H
#define CHARDEV_H

#include 

/* 
 * The major device number. We can't rely on dynamic 
 * registration any more, because ioctls need to know 
 * it. 
 */
#define MAJOR_NUM 100

/* 
 * Set the message of the device driver 
 */
#define IOCTL_SET_MSG _IOR(MAJOR_NUM, 0, char *)
/*
 * _IOR means that we're creating an ioctl command 
 * number for passing information from a user process
 * to the kernel module. 
 *
 * The first arguments, MAJOR_NUM, is the major device 
 * number we're using.
 *
 * The second argument is the number of the command 
 * (there could be several with different meanings).
 *
 * The third argument is the type we want to get from 
 * the process to the kernel.
 */

/* 
 * Get the message of the device driver 
 */
#define IOCTL_GET_MSG _IOR(MAJOR_NUM, 1, char *)
/* 
 * This IOCTL is used for output, to get the message 
 * of the device driver. However, we still need the 
 * buffer to place the message in to be input, 
 * as it is allocated by the process.
 */

/* 
 * Get the n'th byte of the message 
 */
#define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
/* 
 * The IOCTL is used for both input and output. It 
 * receives from the user a number, n, and returns 
 * Message[n]. 
 */

/* 
 * The name of the device file 
 */
#define DEVICE_FILE_NAME "char_dev"

#endif

/*
 *  ioctl.c - the process to use ioctl's to control the kernel module
 *
 *  Until now we could have used cat for input and output.  But now
 *  we need to do ioctl's, which require writing our own process.
 */

/* 
 * device specifics, such as ioctl numbers and the
 * major device file. 
 */
#include "chardev.h"

#include /* open */
#include /* exit */
#include /* ioctl */

/* 
 * Functions for the ioctl calls 
 */

ioctl_set_msg(int file_desc, char *message)
{
int ret_val;

ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);

if (ret_val < 0) {
printf("ioctl_set_msg failed:%d\n", ret_val);
exit(-1);
}
}

ioctl_get_msg(int file_desc)
{
int ret_val;
char message[100];

/* 
 * Warning - this is dangerous because we don't tell
 * the kernel how far it's allowed to write, so it
 * might overflow the buffer. In a real production
 * program, we would have used two ioctls - one to tell
 * the kernel the buffer length and another to give
 * it the buffer to fill
 */
ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);

if (ret_val < 0) {
printf("ioctl_get_msg failed:%d\n", ret_val);
exit(-1);
}

printf("get_msg message:%s\n", message);
}

ioctl_get_nth_byte(int file_desc)
{
int i;
char c;

printf("get_nth_byte message:");

i = 0;
while (c != 0) {
c = ioctl(file_desc, IOCTL_GET_NTH_BYTE, i++);

if (c < 0) {
printf
    ("ioctl_get_nth_byte failed at the %d'th byte:\n",
     i);
exit(-1);
}

putchar(c);
}
putchar('\n');
}

/* 
 * Main - Call the ioctl functions 
 */
main()
{
int file_desc, ret_val;
char *msg = "Message passed by ioctl\n";

file_desc = open(DEVICE_FILE_NAME, 0);
if (file_desc < 0) {
printf("Can't open device file: %s\n", DEVICE_FILE_NAME);
exit(-1);
}

ioctl_get_nth_byte(file_desc);
ioctl_get_msg(file_desc);
ioctl_set_msg(file_desc, msg);

close(file_desc);
}

/*
 *  syscall.c
 *
 *  System call "stealing" sample.
 */

/* 
 * Copyright (C) 2001 by Peter Jay Salzman 
 */

/* 
 * The necessary header files 
 */

/*
 * Standard in kernel modules 
 */
#include /* We're doing kernel work */
#include /* Specifically, a module, */
#include /* which will have params */
#include /* The list of system calls */

/* 
 * For the current (process) structure, we need
 * this to know who the current user is. 
 */
#include 
#include 

/* 
 * The system call table (a table of functions). We
 * just define this as external, and the kernel will
 * fill it up for us when we are insmod'ed
 *
 * sys_call_table is no longer exported in 2.6.x kernels.
 * If you really want to try this DANGEROUS module you will
 * have to apply the supplied patch against your current kernel
 * and recompile it.
 */
extern void *sys_call_table[];

/* 
 * UID we want to spy on - will be filled from the
 * command line 
 */
static int uid;
module_param(uid, int, 0644);

/* 
 * A pointer to the original system call. The reason
 * we keep this, rather than call the original function
 * (sys_open), is because somebody else might have
 * replaced the system call before us. Note that this
 * is not 100% safe, because if another module
 * replaced sys_open before us, then when we're inserted
 * we'll call the function in that module - and it
 * might be removed before we are.
 *
 * Another reason for this is that we can't get sys_open.
 * It's a static variable, so it is not exported. 
 */
asmlinkage int (*original_call) (const char *, int, int);

/* 
 * The function we'll replace sys_open (the function
 * called when you call the open system call) with. To
 * find the exact prototype, with the number and type
 * of arguments, we find the original function first
 * (it's at fs/open.c).
 *
 * In theory, this means that we're tied to the
 * current version of the kernel. In practice, the
 * system calls almost never change (it would wreck havoc
 * and require programs to be recompiled, since the system
 * calls are the interface between the kernel and the
 * processes).
 */
asmlinkage int our_sys_open(const char *filename, int flags, int mode)
{
int i = 0;
char ch;

/* 
 * Check if this is the user we're spying on 
 */
if (uid == current->uid) {
/* 
 * Report the file, if relevant 
 */
printk("Opened file by %d: ", uid);
do {
get_user(ch, filename + i);
i++;
printk("%c", ch);
} while (ch != 0);
printk("\n");
}

/* 
 * Call the original sys_open - otherwise, we lose
 * the ability to open files 
 */
return original_call(filename, flags, mode);
}

/* 
 * Initialize the module - replace the system call 
 */
int init_module()
{
/* 
 * Warning - too late for it now, but maybe for
 * next time... 
 */
printk("I'm dangerous. I hope you did a ");
printk("sync before you insmod'ed me.\n");
printk("My counterpart, cleanup_module(), is even");
printk("more dangerous. If\n");
printk("you value your file system, it will ");
printk("be \"sync; rmmod\" \n");
printk("when you remove this module.\n");

/* 
 * Keep a pointer to the original function in
 * original_call, and then replace the system call
 * in the system call table with our_sys_open 
 */
original_call = sys_call_table[__NR_open];
sys_call_table[__NR_open] = our_sys_open;

/* 
 * To get the address of the function for system
 * call foo, go to sys_call_table[__NR_foo]. 
 */

printk("Spying on UID:%d\n", uid);

return 0;
}

/* 
 * Cleanup - unregister the appropriate file from /proc 
 */
void cleanup_module()
{
/* 
 * Return the system call back to normal 
 */
if (sys_call_table[__NR_open] != our_sys_open) {
printk("Somebody else also played with the ");
printk("open system call\n");
printk("The system may be left in ");
printk("an unstable state.\n");
}

sys_call_table[__NR_open] = original_call;
}

/*
 *  sleep.c - create a /proc file, and if several processes try to open it at
 *  the same time, put all but one to sleep
 */

#include /* We're doing kernel work */
#include /* Specifically, a module */
#include /* Necessary because we use proc fs */
#include /* For putting processes to sleep and 
   waking them up */
#include /* for get_user and put_user */

/* 
 * The module's file functions 
 */

/* 
 * Here we keep the last message received, to prove that we can process our
 * input
 */
#define MESSAGE_LENGTH 80
static char Message[MESSAGE_LENGTH];

static struct proc_dir_entry *Our_Proc_File;
#define PROC_ENTRY_FILENAME "sleep"

/* 
 * Since we use the file operations struct, we can't use the special proc
 * output provisions - we have to use a standard read function, which is this
 * function
 */
static ssize_t module_output(struct file *file,/* see include/linux/fs.h   */
     char *buf,/* The buffer to put data to 
   (in the user segment)    */
     size_t len,/* The length of the buffer */
     loff_t * offset)
{
static int finished = 0;
int i;
char message[MESSAGE_LENGTH + 30];

/* 
 * Return 0 to signify end of file - that we have nothing 
 * more to say at this point.
 */
if (finished) {
finished = 0;
return 0;
}

/* 
 * If you don't understand this by now, you're hopeless as a kernel
 * programmer.
 */
sprintf(message, "Last input:%s\n", Message);
for (i = 0; i < len && message[i]; i++)
put_user(message[i], buf + i);

finished = 1;
return i;/* Return the number of bytes "read" */
}

/* 
 * This function receives input from the user when the user writes to the /proc
 * file.
 */
static ssize_t module_input(struct file *file,/* The file itself */
    const char *buf,/* The buffer with input */
    size_t length,/* The buffer's length */
    loff_t * offset)
{/* offset to file - ignore */
int i;

/* 
 * Put the input into Message, where module_output will later be 
 * able to use it
 */
for (i = 0; i < MESSAGE_LENGTH - 1 && i < length; i++)
get_user(Message[i], buf + i);
/* 
 * we want a standard, zero terminated string 
 */
Message[i] = '\0';

/* 
 * We need to return the number of input characters used 
 */
return i;
}

/* 
 * 1 if the file is currently open by somebody 
 */
int Already_Open = 0;

/* 
 * Queue of processes who want our file 
 */
DECLARE_WAIT_QUEUE_HEAD(WaitQ);
/* 
 * Called when the /proc file is opened 
 */
static int module_open(struct inode *inode, struct file *file)
{
/* 
 * If the file's flags include O_NONBLOCK, it means the process doesn't
 * want to wait for the file.  In this case, if the file is already 
 * open, we should fail with -EAGAIN, meaning "you'll have to try 
 * again", instead of blocking a process which would rather stay awake.
 */
if ((file->f_flags & O_NONBLOCK) && Already_Open)
return -EAGAIN;

/* 
 * This is the correct place for try_module_get(THIS_MODULE) because 
 * if a process is in the loop, which is within the kernel module,
 * the kernel module must not be removed.
 */
try_module_get(THIS_MODULE);

/* 
 * If the file is already open, wait until it isn't 
 */

while (Already_Open) {
int i, is_sig = 0;

/* 
 * This function puts the current process, including any system
 * calls, such as us, to sleep.  Execution will be resumed right
 * after the function call, either because somebody called 
 * wake_up(&WaitQ) (only module_close does that, when the file 
 * is closed) or when a signal, such as Ctrl-C, is sent 
 * to the process
 */
wait_event_interruptible(WaitQ, !Already_Open);

/* 
 * If we woke up because we got a signal we're not blocking, 
 * return -EINTR (fail the system call).  This allows processes
 * to be killed or stopped.
 */

/*
 * Emmanuel Papirakis:
 *
 * This is a little update to work with 2.2.*.  Signals now are contained in
 * two words (64 bits) and are stored in a structure that contains an array of
 * two unsigned longs.  We now have to make 2 checks in our if.
 *
 * Ori Pomerantz:
 *
 * Nobody promised me they'll never use more than 64 bits, or that this book
 * won't be used for a version of Linux with a word size of 16 bits.  This code
 * would work in any case.
 */
for (i = 0; i < _NSIG_WORDS && !is_sig; i++)
is_sig =
    current->pending.signal.sig[i] & ~current->
    blocked.sig[i];

if (is_sig) {
/* 
 * It's important to put module_put(THIS_MODULE) here,
 * because for processes where the open is interrupted
 * there will never be a corresponding close. If we 
 * don't decrement the usage count here, we will be 
 * left with a positive usage count which we'll have no
 * way to bring down to zero, giving us an immortal 
 * module, which can only be killed by rebooting 
 * the machine.
 */
module_put(THIS_MODULE);
return -EINTR;
}
}

/* 
 * If we got here, Already_Open must be zero 
 */

/* 
 * Open the file 
 */
Already_Open = 1;
return 0;/* Allow the access */
}

/* 
 * Called when the /proc file is closed 
 */
int module_close(struct inode *inode, struct file *file)
{
/* 
 * Set Already_Open to zero, so one of the processes in the WaitQ will
 * be able to set Already_Open back to one and to open the file. All 
 * the other processes will be called when Already_Open is back to one,
 * so they'll go back to sleep.
 */
Already_Open = 0;

/* 
 * Wake up all the processes in WaitQ, so if anybody is waiting for the
 * file, they can have it.
 */
wake_up(&WaitQ);

module_put(THIS_MODULE);

return 0;/* success */
}

/*
 * This function decides whether to allow an operation (return zero) or not
 * allow it (return a non-zero which indicates why it is not allowed).
 *
 * The operation can be one of the following values:
 * 0 - Execute (run the "file" - meaningless in our case)
 * 2 - Write (input to the kernel module)
 * 4 - Read (output from the kernel module)
 *
 * This is the real function that checks file permissions. The permissions
 * returned by ls -l are for reference only, and can be overridden here.
 */
static int module_permission(struct inode *inode, int op, struct nameidata *nd)
{
/* 
 * We allow everybody to read from our module, but only root (uid 0)
 * may write to it
 */
if (op == 4 || (op == 2 && current->euid == 0))
return 0;

/* 
 * If it's anything else, access is denied 
 */
return -EACCES;
}

/* 
 * Structures to register as the /proc file, with pointers to all the relevant
 * functions.
 */

/* 
 * File operations for our proc file. This is where we place pointers to all
 * the functions called when somebody tries to do something to our file. NULL
 * means we don't want to deal with something.
 */
static struct file_operations File_Ops_4_Our_Proc_File = {
.read = module_output,/* "read" from the file */
.write = module_input,/* "write" to the file */
.open = module_open,/* called when the /proc file is opened */
.release = module_close,/* called when it's closed */
};

/* 
 * Inode operations for our proc file.  We need it so we'll have somewhere to
 * specify the file operations structure we want to use, and the function we
 * use for permissions. It's also possible to specify functions to be called
 * for anything else which could be done to an inode (although we don't bother,
 * we just put NULL).
 */

static struct inode_operations Inode_Ops_4_Our_Proc_File = {
.permission = module_permission,/* check for permissions */
};

/* 
 * Module initialization and cleanup 
 */

/* 
 * Initialize the module - register the proc file 
 */

int init_module()
{
int rv = 0;
Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
Our_Proc_File->owner = THIS_MODULE;
Our_Proc_File->proc_iops = &Inode_Ops_4_Our_Proc_File;
Our_Proc_File->proc_fops = &File_Ops_4_Our_Proc_File;
Our_Proc_File->mode = S_IFREG | S_IRUGO | S_IWUSR;
Our_Proc_File->uid = 0;
Our_Proc_File->gid = 0;
Our_Proc_File->size = 80;

if (Our_Proc_File == NULL) {
rv = -ENOMEM;
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
printk(KERN_INFO "Error: Could not initialize /proc/test\n");
}

return rv;
}

/* 
 * Cleanup - unregister our file from /proc.  This could get dangerous if
 * there are still processes waiting in WaitQ, because they are inside our
 * open function, which will get unloaded. I'll explain how to avoid removal
 * of a kernel module in such a case in chapter 10.
 */
void cleanup_module()
{
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
}

/* 
 *  print_string.c - Send output to the tty we're running on, regardless if it's
 *  through X11, telnet, etc.  We do this by printing the string to the tty
 *  associated with the current task.
 */
#include 
#include 
#include 
#include /* For current */
#include /* For the tty declarations */
#include /* For LINUX_VERSION_CODE */

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peter Jay Salzman");

static void print_string(char *str)
{
struct tty_struct *my_tty;

/* 
 * tty struct went into signal struct in 2.6.6 
 */
#if ( LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,5) )
/* 
 * The tty for the current task 
 */
my_tty = current->tty;
#else
/* 
 * The tty for the current task, for 2.6.6+ kernels 
 */
my_tty = current->signal->tty;
#endif

/* 
 * If my_tty is NULL, the current task has no tty you can print to 
 * (ie, if it's a daemon).  If so, there's nothing we can do.
 */
if (my_tty != NULL) {

/* 
 * my_tty->driver is a struct which holds the tty's functions,
 * one of which (write) is used to write strings to the tty. 
 * It can be used to take a string either from the user's or 
 * kernel's memory segment.
 *
 * The function's 1st parameter is the tty to write to,
 * because the same function would normally be used for all 
 * tty's of a certain type.  The 2nd parameter controls whether
 * the function receives a string from kernel memory (false, 0)
 * or from user memory (true, non zero).  The 3rd parameter is
 * a pointer to a string.  The 4th parameter is the length of
 * the string.
 */
((my_tty->driver)->write) (my_tty,/* The tty itself */
   0,/* Don't take the string 
   from user space        */
   str,/* String                 */
   strlen(str));/* Length */

/* 
 * ttys were originally hardware devices, which (usually) 
 * strictly followed the ASCII standard.  In ASCII, to move to
 * a new line you need two characters, a carriage return and a
 * line feed.  On Unix, the ASCII line feed is used for both 
 * purposes - so we can't just use \n, because it wouldn't have
 * a carriage return and the next line will start at the
 * column right after the line feed.
 *
 * This is why text files are different between Unix and 
 * MS Windows.  In CP/M and derivatives, like MS-DOS and 
 * MS Windows, the ASCII standard was strictly adhered to,
 * and therefore a newline requirs both a LF and a CR.
 */
((my_tty->driver)->write) (my_tty, 0, "\015\012", 2);
}
}

static int __init print_string_init(void)
{
print_string("The module has been inserted.  Hello world!");
return 0;
}

static void __exit print_string_exit(void)
{
print_string("The module has been removed.  Farewell world!");
}

module_init(print_string_init);
module_exit(print_string_exit);

/* 
 *  kbleds.c - Blink keyboard leds until the module is unloaded.
 */

#include 
#include 
#include 
#include /* For fg_console, MAX_NR_CONSOLES */
#include /* For KDSETLED */
#include /* For vc_cons */

MODULE_DESCRIPTION("Example module illustrating the use of Keyboard LEDs.");
MODULE_AUTHOR("Daniele Paolo Scarpazza");
MODULE_LICENSE("GPL");

struct timer_list my_timer;
struct tty_driver *my_driver;
char kbledstatus = 0;

#define BLINK_DELAY   HZ/5
#define ALL_LEDS_ON   0x07
#define RESTORE_LEDS  0xFF

/*
 * Function my_timer_func blinks the keyboard LEDs periodically by invoking
 * command KDSETLED of ioctl() on the keyboard driver. To learn more on virtual 
 * terminal ioctl operations, please see file:
 *     /usr/src/linux/drivers/char/vt_ioctl.c, function vt_ioctl().
 *
 * The argument to KDSETLED is alternatively set to 7 (thus causing the led 
 * mode to be set to LED_SHOW_IOCTL, and all the leds are lit) and to 0xFF
 * (any value above 7 switches back the led mode to LED_SHOW_FLAGS, thus
 * the LEDs reflect the actual keyboard status).  To learn more on this, 
 * please see file:
 *     /usr/src/linux/drivers/char/keyboard.c, function setledstate().
 * 
 */

static void my_timer_func(unsigned long ptr)
{
int *pstatus = (int *)ptr;

if (*pstatus == ALL_LEDS_ON)
*pstatus = RESTORE_LEDS;
else
*pstatus = ALL_LEDS_ON;

(my_driver->ioctl) (vc_cons[fg_console].d->vc_tty, NULL, KDSETLED,
    *pstatus);

my_timer.expires = jiffies + BLINK_DELAY;
add_timer(&my_timer);
}

static int __init kbleds_init(void)
{
int i;

printk(KERN_INFO "kbleds: loading\n");
printk(KERN_INFO "kbleds: fgconsole is %x\n", fg_console);
for (i = 0; i < MAX_NR_CONSOLES; i++) {
if (!vc_cons[i].d)
break;
printk(KERN_INFO "poet_atkm: console[%i/%i] #%i, tty %lx\n", i,
       MAX_NR_CONSOLES, vc_cons[i].d->vc_num,
       (unsigned long)vc_cons[i].d->vc_tty);
}
printk(KERN_INFO "kbleds: finished scanning consoles\n");

my_driver = vc_cons[fg_console].d->vc_tty->driver;
printk(KERN_INFO "kbleds: tty driver magic %x\n", my_driver->magic);

/*
 * Set up the LED blink timer the first time
 */
init_timer(&my_timer);
my_timer.function = my_timer_func;
my_timer.data = (unsigned long)&kbledstatus;
my_timer.expires = jiffies + BLINK_DELAY;
add_timer(&my_timer);

return 0;
}

static void __exit kbleds_cleanup(void)
{
printk(KERN_INFO "kbleds: unloading...\n");
del_timer(&my_timer);
(my_driver->ioctl) (vc_cons[fg_console].d->vc_tty, NULL, KDSETLED,
    RESTORE_LEDS);
}

module_init(kbleds_init);
module_exit(kbleds_cleanup);

/*
 *  sched.c - scheduale a function to be called on every timer interrupt.
 *
 *  Copyright (C) 2001 by Peter Jay Salzman
 */

/* 
 * The necessary header files 
 */

/* 
 * Standard in kernel modules 
 */
#include /* We're doing kernel work */
#include /* Specifically, a module */
#include /* Necessary because we use the proc fs */
#include /* We scheduale tasks here */
#include /* We need to put ourselves to sleep 
   and wake up later */
#include /* For __init and __exit */
#include /* For irqreturn_t */

struct proc_dir_entry *Our_Proc_File;
#define PROC_ENTRY_FILENAME "sched"
#define MY_WORK_QUEUE_NAME "WQsched.c"

/* 
 * The number of times the timer interrupt has been called so far 
 */
static int TimerIntrpt = 0;

static void intrpt_routine(void *);

static int die = 0;/* set this to 1 for shutdown */

/* 
 * The work queue structure for this task, from workqueue.h 
 */
static struct workqueue_struct *my_workqueue;

static struct work_struct Task;
static DECLARE_WORK(Task, intrpt_routine, NULL);

/* 
 * This function will be called on every timer interrupt. Notice the void*
 * pointer - task functions can be used for more than one purpose, each time
 * getting a different parameter.
 */
static void intrpt_routine(void *irrelevant)
{
/* 
 * Increment the counter 
 */
TimerIntrpt++;

/* 
 * If cleanup wants us to die
 */
if (die == 0)
queue_delayed_work(my_workqueue, &Task, 100);
}

/* 
 * Put data into the proc fs file. 
 */
ssize_t
procfile_read(char *buffer,
      char **buffer_location,
      off_t offset, int buffer_length, int *eof, void *data)
{
int len;/* The number of bytes actually used */

/* 
 * It's static so it will still be in memory 
 * when we leave this function
 */
static char my_buffer[80];

static int count = 1;

/* 
 * We give all of our information in one go, so if the anybody asks us
 * if we have more information the answer should always be no.
 */
if (offset > 0)
return 0;

/* 
 * Fill the buffer and get its length 
 */
len = sprintf(my_buffer, "Timer called %d times so far\n", TimerIntrpt);
count++;

/* 
 * Tell the function which called us where the buffer is 
 */
*buffer_location = my_buffer;

/* 
 * Return the length 
 */
return len;
}

/* 
 * Initialize the module - register the proc file 
 */
int __init init_module()
{
int rv = 0;
/* 
 * Put the task in the work_timer task queue, so it will be executed at
 * next timer interrupt
 */
my_workqueue = create_workqueue(MY_WORK_QUEUE_NAME);
queue_delayed_work(my_workqueue, &Task, 100);

Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
Our_Proc_File->read_proc = procfile_read;
Our_Proc_File->owner = THIS_MODULE;
Our_Proc_File->mode = S_IFREG | S_IRUGO;
Our_Proc_File->uid = 0;
Our_Proc_File->gid = 0;
Our_Proc_File->size = 80;

if (Our_Proc_File == NULL) {
rv = -ENOMEM;
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
printk(KERN_INFO "Error: Could not initialize /proc/%s\n",
       PROC_ENTRY_FILENAME);
}

return rv;
}

/* 
 * Cleanup
 */
void __exit cleanup_module()
{
/* 
 * Unregister our /proc file 
 */
remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
printk(KERN_INFO "/proc/%s removed\n", PROC_ENTRY_FILENAME);

die = 1;/* keep intrp_routine from queueing itself */
cancel_delayed_work(&Task);/* no "new ones" */
flush_workqueue(my_workqueue);/* wait till all "old ones" finished */
destroy_workqueue(my_workqueue);

/* 
 * Sleep until intrpt_routine is called one last time. This is 
 * necessary, because otherwise we'll deallocate the memory holding 
 * intrpt_routine and Task while work_timer still references them.
 * Notice that here we don't allow signals to interrupt us.
 *
 * Since WaitQ is now not NULL, this automatically tells the interrupt
 * routine it's time to die.
 */

}

/* 
 * some work_queue related functions
 * are just available to GPL licensed Modules 
 */
MODULE_LICENSE("GPL");

/*
 *  intrpt.c - An interrupt handler.
 *
 *  Copyright (C) 2001 by Peter Jay Salzman
 */

/* 
 * The necessary header files 
 */

/* 
 * Standard in kernel modules 
 */
#include /* We're doing kernel work */
#include /* Specifically, a module */
#include 
#include 
#include /* We want an interrupt */
#include 

#define MY_WORK_QUEUE_NAME "WQsched.c"

static struct workqueue_struct *my_workqueue;

/* 
 * This will get called by the kernel as soon as it's safe
 * to do everything normally allowed by kernel modules.
 */
static void got_char(void *scancode)
{
printk("Scan Code %x %s.\n",
       (int)*((char *)scancode) & 0x7F,
       *((char *)scancode) & 0x80 ? "Released" : "Pressed");
}

/* 
 * This function services keyboard interrupts. It reads the relevant
 * information from the keyboard and then puts the non time critical
 * part into the work queue. This will be run when the kernel considers it safe.
 */
irqreturn_t irq_handler(int irq, void *dev_id, struct pt_regs *regs)
{
/* 
 * This variables are static because they need to be
 * accessible (through pointers) to the bottom half routine.
 */
static int initialised = 0;
static unsigned char scancode;
static struct work_struct task;
unsigned char status;

/* 
 * Read keyboard status
 */
status = inb(0x64);
scancode = inb(0x60);

if (initialised == 0) {
INIT_WORK(&task, got_char, &scancode);
initialised = 1;
} else {
PREPARE_WORK(&task, got_char, &scancode);
}

queue_work(my_workqueue, &task);

return IRQ_HANDLED;
}

/* 
 * Initialize the module - register the IRQ handler 
 */
int init_module()
{
my_workqueue = create_workqueue(MY_WORK_QUEUE_NAME);

/* 
 * Since the keyboard handler won't co-exist with another handler,
 * such as us, we have to disable it (free its IRQ) before we do
 * anything.  Since we don't know where it is, there's no way to
 * reinstate it later - so the computer will have to be rebooted
 * when we're done.
 */
free_irq(1, NULL);

/* 
 * Request IRQ 1, the keyboard IRQ, to go to our irq_handler.
 * SA_SHIRQ means we're willing to have othe handlers on this IRQ.
 * SA_INTERRUPT can be used to make the handler into a fast interrupt.
 */
return request_irq(1,/* The number of the keyboard IRQ on PCs */
   irq_handler,/* our handler */
   SA_SHIRQ, "test_keyboard_irq_handler",
   (void *)(irq_handler));
}

/* 
 * Cleanup 
 */
void cleanup_module()
{
/* 
 * This is only here for completeness. It's totally irrelevant, since
 * we don't have a way to restore the normal keyboard interrupt so the
 * computer is completely useless and has to be rebooted.
 */
free_irq(1, NULL);
}

/* 
 * some work_queue related functions are just available to GPL licensed Modules
 */
MODULE_LICENSE("GPL");