• Like
Linux Kernel Programming
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Linux Kernel Programming

  • 583 views
Published

 

Published in Education , Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
583
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
57
Comments
0
Likes
2

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Kernel Module Programming BY: MONIS JAVED NALIN SHARMA OBEDULLAH
  • 2. WHAT IS KERNEL? a program having control over everything that occurs in system.  central part of operating system.  it acts as an interface between the user applications and the hardware. 
  • 3. ROLE OF THE KERNEL Kernel is responsible for:     Process Management - allocating resources to a process. - synchronization among processes. Memory Management - allocating and deallocating memory to programs. Device Management - controlling several devices attached to the system. Storage Management - disk management. - disk scheduling.
  • 4. TYPES OF KERNEL  Monolithic Kernel  Micro Kernel  Hybrid Kernel  Nano Kernel  Exo Kernel
  • 5. MONOLITHIC KERNEL      Entire operating system works in kernel space. Larger in size as they retain full privilege access over various components like file system, IPC, IO/device management etc. Slower to load because of large size. Recompilation is required to add more features or remove bugs. Example includes: Linux based OS, MSDOS etc.
  • 6. MICRO KERNEL  Deals with only critical activities such as controlling memory and CPU.  Everything else is handled under user mode.  Kernel don’t have to worry about lower level functionality.  Example include: QNX ,Minix.
  • 7. HYBRID KERNEL  have the ability to pick and choose what they want to run in user mode and what they want to run in supervisor mode.  Example : Windows NT,2000, XP, Vista,7,8, Mac OS X.
  • 8. INTRODUCING KERNEL MODULES
  • 9. KERNEL MODULES  Linux Kernel has ability to extend its set of features at run time.  Modules are pieces of code that can be loaded and unloaded into the kernel upon demand.  They extend the functionality of the kernel without the need to reboot the system.
  • 10. KERNEL MODULES CONTD…  A module run in kernel mode.  Without loadable kernel modules, an operating system would have to include all possible anticipated functionality already compiled directly into the base kernel.  This require rebooting kernel every time when new functionality is added.
  • 11. KERNEL MODULES CONTD…  Kernel modules allow a Linux system to be set up with a standard minimal kernel without any extra device drivers built in.  For example, one type of module is the device driver, which allows the kernel to access hardware connected to the system.
  • 12. MODULE PROGRAMMING
  • 13. MODULE COMMANDS • modinfo : display information about a kernel module • lsmod : list loaded modules • insmod : Install loadable kernel module • rmmod : Unload loadable modules • depmod : handle dependency descriptions for loadable kernel modules • modprobe : High level handling of loadable modules
  • 14. HOW DO MODULES GET INTO THE KERNEL?  modules already loaded into the kernel can be listed by running lsmod, which gets its information by reading the file /proc/modules.  When the kernel needs a feature that is not resident in the kernel, the kernel module daemon kmod executes modprobe to load the module in.  modprobe is passed a string in one of two forms: · A module name like soft or ppp. · A more generic identifier like
  • 15. CONTD…...  If modprobe is handed a generic identifier, it first looks for that string in the file /etc/modules.conf. If it finds an alias line like: alias char−major−10−30 soft it knows that the generic identifier refers to the module soft.o  Next, modprobe looks through the file /lib/modules/version/modules.dep, to see if other modules must be loaded before the requested module may be loaded.  This file is created by depmod −a and contains module dependencies.
  • 16. CONTD….  Lastly, modprobe uses insmod to first load any prerequisite modules into the kernel, and then the requested module. modprobe directs insmod to /lib/modules/version/, the standard directory for modules.  insmod is intended to be fairly dumb about the location of modules, whereas modprobe is aware of the default location of modules.
  • 17. CONTD… Example: We need to insert module msdos.o which requires fat.o module to be already loaded. This can be done in two ways: 1. using insmod insmod /lib/modules/2.5.1/kernel/fs/fat/fat.o insmod /lib/modules/2.5.1/kernel/fs/msdos/msdos. o 2. using modprobe
  • 18. BEFORE WE BEGIN TO GET INTO THE CODE
  • 19. MODVERSIONING  Everyone's system is different and everyone has their own groove.  A module compiled for one kernel won't load if you boot a different kernel.  unless you enable CONFIG_MODVERSIONS in the kernel.
  • 20. STEPS   #cd /usr/src/linux-headers-3.8.0-34-generic/ #make menuconfig
  • 21. HELLO WORLD PROGRAM  /* hello−1.c − The simplest kernel module.*/  #include <linux/module.h> /* Needed by all modules */ #include <linux/kernel.h> /* Needed for KERN_ALERT */ int init_module(void) { printk("Hello world n"); return 0; //A non 0 return means init_module failed; module can't be      loaded.      } void cleanup_module(void) { printk(KERN_ALERT "Goodbye world 1.n"); }
  • 22.  Kernel modules must have at least two functions:  a "start" (initialization) function called init_module() which is called when the module is insmoded into the kernel, and  an "end" (cleanup) function called cleanup_module() which is called just before it is rmmoded.
  • 23.  init_module() either registers a handler for something with the kernel, or it replaces one of the kernel functions with its own code (usually code to do something and then call the original function).  The cleanup_module() function is supposed to undo whatever init_module() did, so the module can be unloaded safely.
  • 24. INTRODUCING PRINTK()      printk() is not meant to communicate information to the user. It is used to log information or give warnings. each printk() statement comes with a priority. There are 8 priorities and the kernel has macros for them. The header file linux/kernel.h describes what each priority means.
  • 25. PRINTK() CONTD… 1. KERN_EMERG "<0>" /* emergency message*/ 2. KERN_ALERT "<1>" /* action must be taken immediately*/ 3 KERN_CRIT "<2>" /* critical conditions*/ 4. KERN_ERR "<3>" /* error conditions*/ 5. KERN_WARNING "<4>" /* warning conditions*/ 6. KERN_NOTICE 7. KERN_INFO "<5>" /* normal but significant condition*/ "<6>" /* informational message*/ 8. KERN_DEBUG "<7>" /* debug-level messages*/ Default : DEFAULT_MESSAGE_LOGLEVEL
  • 26. PRINTK() CONTD…  If the priority is less than int console_loglevel, the message is printed on your current terminal.  We use a high priority, like KERN_ALERT, to make sure the printk() messages get printed to your console rather than just logged to your logfile.
  • 27. STEPS FOR COMPILATION OF KERNEL MODULE 1. write the kernel module code with filename like filename.c 2. make a file containing code for compiling the module and save it using name “Makefile”. 3. now compile the module code by issuing command make. To see what kind of information it is , type:modinfo filename.ko
  • 28. CONTD… 4. now insert module by command modprobe filename.ko OR insmod filename.ko - you can see your inserted module in cat /proc/modules OR by command lsmod
  • 29. MAKE FILE  A makefile is a script for appropriate compilation of different type of sources to the appropriate object code.  Makefiles are used to define the procedure to compile and link your program.  as number of files increases it's very difficult to compile and link them one by one.
  • 30. CONTD….  Also you will have to remember the dependencies between these files.  Makefiles are used to automate these tasks so just define your rules once and instead of compiling and linking individual files you just need to execute the makefile.
  • 31. HOW TO MAKE A “MAKEFILE” FOR KERNEL MODULE: obj-m += filename.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
  • 32. RENAME YOUR FUNCTION NAME: you can rename the init and cleanup functions of your modules.  This is done with the --module_init() and module_exit()  These are macros defined in linux/init.h
  • 33. EXAMPLE:              #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> static int _init myname(void) { printk(KERN_INFO “Hello world?”); return 0; } static void _exit yourname(void) { printk(KERN_INFO “Goodbye”); } module_init(myname); module_exit(yourname);
  • 34. MODULES SPANNING MULTIPLE FILES:Modules Spanning Multiple Files: First we invent an object name for our combined module,  Second we tell make what object files are part of that module. 
  • 35. begin.c end.c #include <linux/kernel.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/module.h> int init_module(void) void cleanup_module() { { printk(KERN_INFO "Hello, printk(KERN_INFO worldn"); "Goodbyen"); return 0; } } Makefile :obj-m += beginend.o beginend-objs := begin.o end.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
  • 36. MODULE UNLOADING  Modules can be unloaded using rmmod command.  rmmod ensures the restriction that the modules are not in use.  Unlinked from the kernel and unlisted from the list of kernel modules  Dependency is released
  • 37. KERNEL MODULES VS APPLICATION PROGRAM     Applications perform a single task from beginning to end. Kernel module just registers itself in order to serve future requests. Application can use library function (like printf) but a module can only use functions exported by kernel (like printk). A module runs in kernel space, whereas applications run in user space.
  • 38. REFERENCES The Linux Kernel Module Programming Guide by Peter Jay Salzman Michael Burian Ori Pomerantz
  • 39. THANK YOU