Scribd
Upload
32 views

How To Make A Pseudo-File: As A Follow-Up To Our First Lab, We Examine The Steps Needed To Create Our Own /proc' File

This document provides instructions for creating a custom '/proc' file as a kernel module in Linux. It discusses the need for kernel extensibility, two mechanisms for extending the kernel (open source programming and installable kernel modules), and provides a step-by-step example of creating a module that uses the printk() function and proc file system to display the value of the jiffies variable in a new '/proc/jiffies' file.

Uploaded by

DrBabita Singla
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
32 views

How To Make A Pseudo-File: As A Follow-Up To Our First Lab, We Examine The Steps Needed To Create Our Own /proc' File

This document provides instructions for creating a custom '/proc' file as a kernel module in Linux. It discusses the need for kernel extensibility, two mechanisms for extending the kernel (open source programming and installable kernel modules), and provides a step-by-step example of creating a module that uses the printk() function and proc file system to display the value of the jiffies variable in a new '/proc/jiffies' file.

Uploaded by

DrBabita Singla
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 24

How to make a pseudo-file

As a follow-up to our first lab, we


examine the steps needed to
create our own /proc file

The extensibility imperative

A modern OS needs the ability to evolve


It will need to support new devices
It will need to allow bugs to be repaired
It will need to permit performance gains

Otherwise: suffer early obsolescence!

Two Extensibility Mechanisms


Open Source programming
Installable kernel modules

Open Source
Source text for the Linux kernel is on disk
(usual directory-location is /usr/src/linux)
Majority of the sources are written in C
(so portable across CPU architectures)
Some are written in assembly languages
(for nearly twenty different architectures)
Files are grouped into major categories
(kernel, mm, fs, net, ipc, lib, drivers, init)
You could edit and recompile your kernel

Installable kernel modules

Great mechanism for kernel extensibility


Neat tool for studying how kernel works
Kernel can be modified while its running
Unnecessary to recompile and then reboot
But inherently unsafe: programming bugs
in the kernel can cause system crashes!

Some superuser privileges


Since modifying a running kernel is risky,
only authorized system administrators
are normally allowed to install kernel
modules
But our systems are specially configured
to permit you to install or remove modules
This is purely for educational purposes
(so you should use this privilege wisely)

Linux module structure


Two module administration functions are
mandatory components in every module
plus
Appropriate module service functions and
their supporting kernel data-structures are
optional components in particular modules
also
Recent kernels require a Module License!

A minimal module-template
#include <linux/module.h>
int init_module( void )
{
// code here gets called during module installation
}
void cleanup_module( void )
{
// code here gets called during module removal
}
MODULE_LICENSE(GPL);

How to compile a module


You could directly invoke the C-compiler:
$ gcc c O D__KERNEL__ -DMODULE
I/lib/modules/2.4.26/build/include mod.c
OR: you can use the make utility:
$ make mod.o

The printk() function


Kernel modules cannot call any functions
in the C runtime library (e.g., printf())
But similar kernel versions of important
functions are provided (e.g., printk())
Syntax and semantics are slightly different
(e.g., priority and message-destination)
Capabilities may be somewhat restricted
(e.g., printk() cant show floating-point)

Simple module example


#include <linux/module.h>
int init_module( void )
{
printk( <1>Hello, world!\n );
return 0;
// SUCCESS
}
void cleanup_module( void )
{
printk( <1>Goodbye everyone\n );
}
MODULE_LICENSE(GPL);

How to install and remove


root#/sbin/insmodhello.o
root#/sbin/rmmodhello

A non-trivial module-example
Lets see how we can use kernel functions
to create our own /proc file
Easy if we use create_proc_read_entry()
during module-initialization (and then use
remove_proc_entry() during cleanup)
Prototypes in the <linux/proc_fs.h> header
Well show the current value of a volatile
kernel variable, named jiffies

jiffies

unsigned long volatile jiffies;


global kernel variable (used by scheduler)
Initialized to zero when system reboots
Gets incremented when timer interrupts
So it counts clock-ticks since cpu restart
tick-frequency is architecture dependent

Writing the jiffies.c module


We need to declare a name for pseudo-file
static char modname[ ] = jiffies;
We need to define a proc_read function
(see code on the following slide)
We need to register our filename, along
with its read method, in init_module()
We need to unregister our pseudo-file in
cleanup_module()

Our modules read method


static int
my_proc_read( char *buf, char **start,
off_t off, int count, int *eof, void *data )
{
return sprintf( buf, jiffies=%lu\n, jiffies );
}

Our initialization function


int init_module( void )
{
create_proc_read_entry( modname,
0, NULL, my_proc_read, NULL );
return 0;
}

Our cleanup function


void cleanup_module( void )
{
remove_proc_entry( modname, NULL );
}

In-class exercise #1
Use an editor (e.g., vi) to create a source
file in C (named jiffies.c) for your module
Use the make command to compile your
modules source-file into an object-file
Use the insmod command to install your
module object-file into the running kernel
Use the cat command to display jiffies
Then use rmmod to remove your module

Makefile

We need it to automate module compiles


Otherwise we type a VERY long command
To compile jiffies.c type: $ make jiffies.o
Our Makefile defines some implicit rules
make works by doing pattern-matching

Rule syntax

targets:dependencies
commands
...

Pattern Rule example


CC=gcc
INCLUDE=
/lib/modules/2.4.26/build/include
CFLAGS=cO
CFLAGS+=D__KERNEL__DMODULE
#primarypatternrule
%.o:%.c%.h
$(CC)I$(INCLUDE)$CFLAGS$<
#fallbackpatternrule
%.o:%.c
$(CC)I$(INCLUDE)$CFLAGS$<

Makefile is on class website


You can download the Makefile from our
website: http://cs.usfca.edu/~cruse/cs326/
Put the Makefile in your current working
directory (along with your module source)
Then you can compile by typing this short
command: $ make jiffies.o

In-class exercise #2
Use your knowledge of standard C library
functions (e.g., open(), read(), close() ) to
write an application-program (name it
showjifs.cpp) which reads the information
from your proc/jiffies pseudo-file and then
prints it on the screen
Use a program-loop to re-read the pseudo
file multiple times
How rapidly does jiffies value increase?

You might also like