MrTechpathi Tutorials

Linux Device Drivers - Part 13 : More on Device Numbers

2015-08-01T08:42:00.000-07:00

In this session, we are going to discuss following topics
1. Allocating and freeing Device Numbers
2. Best way to allocate Device Numbers
3. Disadvantage of dynamic assignment of device numbers
4. Allocating device numbers to scull device driver

Source code of Linux Device Driver examples of O'reilly can be downloaded from below link

http://examples.oreilly.com/linuxdrive3/

Watch video here:

Linux Device Drivers Part - 12 : Major and Minor Numbers in Linux Device Driver Programming

2015-08-01T08:38:00.001-07:00

In this session we will discuss following topics

1. Books to refer for Linux Device Driver Programming

2. Our mail Goal to achieve in up coming sessions

3. Steps to follow while Linux Device Driver Programming

Under this particular topic we will learn about

Gathering information about a Linux Device Driver
Gathering information of SCULL Device Driver
Identifying and defining Major and Minor Number
Representation of Device numbers

You can download a softcopy of LDD http://www.oreilly.com/openbook/linuxdrive3/book/

Watch video here :

Linux Device Drivers Part 11: Device Driver Types

2015-07-02T22:46:00.003-07:00

In this video session, we will discuss about
1. /dev directory Device Driver types (Character Devices, Block devices and Network Devices)
Practical session included at the end.
Please subscribe for more videos.

Linux Device Drivers Part 10: Module Parameters

2015-07-02T22:46:00.002-07:00

In this video session we will discuss following topics

1.What are Module parameters ?
2.Ways to change these module parameters?
3.Module_param macro
4.Array Module parameters

Linux Device Drivers Part 9 - More about Symbol tables

2015-06-15T15:34:00.000-07:00

In this part we will discuss about following topics

About undefined symbol error and steps to solve it
Is it mandatory to export the symbols ?
Location of symbol table
About system.map file in Linux

1. About undefined symbol error and steps to solve it

The most common and most frustrating failure in loading an LKM is unresolved symbol, like this:

 insmod: error inserting 'helloworld.ko': -1 Unknown symbol in module

To debug this error,

1. Use nm utility
2. Know symbol definitions (in next slide)

Lets say my module is helloworld.ko

In order to display symbol table, we use following command.

 $nm helloworld.ko.

Output of this command is

 00000000 r ____versions  
 0000002c r __mod_author22  
 00000000 r __mod_description24  
 00000020 r __mod_license23  
 00000040 r __mod_srcversion30  
 00000080 r __mod_vermagic5  
 00000063 r __module_depends  
 00000000 D __this_module  
 00000000 r _rheldata  
 00000000 T cleanup_module  
 00000000 B g_value  
 00000000 t hello_exit  
 00000000 t hello_init  
 00000000 T init_module  
      U printk

In this list, try to find the Undefined symbol tag / Unknown symbol tag (in second column of symbol table).

Once Symbol table is handy, we need to know about symbol types.

Some of these types are:

A for absolute

B or b for uninitialized data section (called BSS)

D or d for initialized data section

G or g for initialized data section for small objects (global)

i for sections specific to DLLs

N for debugging symbol

p for stack unwind section

R or r for read only data section

S or s for uninitialized data section for small objects

T or t for text (code) section

U for undefined

V or v for weak object

W or w for weak objects which have not been tagged so

- for stabs symbol in an a.out object file

2. Is it mandatory to export the symbols ?
Now with symbol table and symbol types in hand, we need to check which symbol type is relevant to our error. From above symbol types, "U for undefined" is relevant "Unknown symbol in module".

So, the symbols which are having U in the symbol table (second column) displayed are g_value and printk. printk will be resolved by Kernel while loading the module because relevant header files are included. So, we need to concentrate on g_value and why its displayed.

In order to resolve this, you need to either export this in any other module where the definition exists or you need to make this local to this module.

To know answer for this question, you can think of kernel symbols as being visible at three different levels in the Kernel source code:

"static", - visible only within their own source file (just like standard user space programming),
"external" - potentially visible to any other code built into the kernel itself, and
"exported - visible and available to any loadable module

From above statement it’s obvious that if you are writing a Linux Kernel Module, it’s mandatory to export your module symbols if you want other module to benefit using them.

3. Location of Symbol tables
The symbol exported by the statically Linked kernel and all linked-in modules can be retrieved by reading the /proc/kallsyms file or using the query_modue() system call.

Take a look at /proc/kallsyms entry by typing following command in your terminal.

 cat /proc/kallsyms

Every entry in this file represents an exported (public) kernel symbol, which can be accessed by a Linux Kernel Module.

If you would like to get symbol table of a particular module or kernel object, you can use “nm” command

 $nm KernelModule.ko.

4.About System.map file in Linux
Every kernel image that you build has a symbol table with it . The linux kernel symbol table contains names and addresses of all the kernel symbols.

In Linux, the System.map file is a symbol table used by the kernel.

Because addresses may change from one build to the next, a new System.map is generated for each build of the kernel.

The System.map is required when the address of a symbol name, or the symbol name of an address, is needed. It is especially useful for debugging kernel panics and kernel oopses.

After building the Linux kernel, System.map is located in the root of the source directory. Try typing “locate System.map” command in terminal.

 locate System.map

These topics are also explained in detail with practical session in below video.
If you like it, please do subscribe and shed your comments.

Linux Device Drivers - Part 8 : Kernel Symbol Tables

2015-06-07T08:28:00.000-07:00

In this session we learn about
1. A symbol in Linux
2. How it is exported ?
3. Symbol and Symbol Table relationship
4. Idea behind exporting a Symbol

1. A Symbol in Linux
In Linux, symbols are nothing but variables and functions that are needed to implement modularised drivers. Note that each and every symbol has its address in the memory.

To make our understanding clear, lets draw a small diagram which shows a Linux Kernel Module with symbols ( Variables and functions ) in it.

So in short, symbol is nothing but a variable or function in LKM

How Symbols are Exported ?

Exporting Kernel Symbols is typically done with

EXPORT_SYMBOL()
EXPORT_SYMBOL_GPL()

EXPORT_SYMBOL(), which exports a given symbol to all loadable modules

EXPORT_SYMBOL_GPL(), which exports a given symbol to only those modules that have a GPL-compatible license. (The first variation is far more common).

GPL here is General Public License is widely used for free software license.

EXPORT_SYMBOL_GPL functionality is same as EXPORT_SYMBOL, but it marks the exported symbol as usable only in modules licensed through either the General public License or a compatible one.

So, whenever you write a driver, it should be GPL licensed. That will be a great facility in case your module wants to use any other module’s functions that are already exported using GPL.

3.Symbol and Symbol Table relation

Now we know about a symbol and how it is exported in Linux Kernel module. Lets learn about Kernel Symbol Table (also called Symbol Table in short).

Kernel symbol table is nothing but a look-up table between symbol names and their addresses in memory.

When a module is loaded into Kernel memory using insmod or modprobe utility, any symbol exported by the module becomes part of the Kernel symbol table. Exported symbols will become public Kernel symbols.

While insmoding, the insmod utility resolves undefined symbols against the table of public Kernel symbols.

Kernel Symbol tables hold all the information needed to find program symbols, assign value to them, and relocate them.

Primary task of symbol is to associate a string with a value. For ex, printk symbol represents the address of the printk function in virtual address space where the function machine code resides.

This Kernel symbol table is loaded into memory as part of the Kernel boot process.

We will be learning more about Kernel Symbol Tables in coming Sessions.

4. Idea behind Exporting a Symbol

Whole idea of exporting a symbol is to make other modules benefit using them.

New modules can use symbols exported by your module, and you can stack new modules on top of other modules. This concept is called Module stacking.

Module stacking is implemented in the mainstream kernel sources as well: like each input USB device module stacks on the usbcore and input modules.

Module loading order can be important, particularly if they are stacked (dependent on the symbols defined in other modules)

This mechanism help reduce development time by simplifying each layer

Check out video on this topi in my youtube channel. Don't forget to subscribe.

Linux Device Drivers Part -7 : Kernel Modules vs Applications

2015-06-06T06:27:00.001-07:00

In this part, we are going to discus about ,

The difference between Kernel Modules (KM) and Applications (APs) in brief.

Before proceeding further, I strongly recommend to watch my earlier videos from "Linux Device Drivers Part -1 to Part 6".

Though there are many differences, to keep it simple and to explain in brief , I have hand picked few differences and listed them as topics form, which can be easily remembered and recollected when required

We compare below 6 topics between Kernel Modules (KM) and Applications (APs)

1. Initialisation
2. Which are Event Driven KM's or AP’s
3. About Exit Procedure in KM's or AP’s
4. Ability to unload a module
5. Linking stage
6. Handling faults

This tutorial covers only brief description of all topics listed. This will help us to understand upcoming sessions with ease

Lets start with our first topic,

1. Initialisation
When we invoke a application, it starts and proceed ahead till end .
Most small and medium sized application programs perform a single task from beginning to end. Take any application in your PC, they start and run till you end them

Whereas every Kernel module registers itself with Kernel in order to serve future requests, and its initialisation function terminates immediately.

In other words, the task of the module's initialisation function is to prepare for later invocation of the module's functions when required.

2. Which are Event Driven KMs or APs
To understand in simple way, say if something happens, an event is raised and that should be served. So, with our current understanding, do you think Kernel is event driven ?

Yes, when a Kernel module is loaded, it invokes init function (hello_init) which conveys Kernel “Here I am, and this is what I can do”. Its conveying kernel, if some events occurs, just let me know i will serve

When Kernel module is unloaded, it invokes exit (hello_exit) which conveys Kernel “I am not there anymore; don’t ask me to do anything else”.

This kind of approach to programming is similar to event-driven programming, but while not all applications are event-driven, each and every Kernel module is even driven.

3. About Exit Procedure in KM or AP’s
I have mentioned earlier, not all applications are event-driven . Imagine we have event driven application

Major difference between event-driven applications and Kernel code is in the exit function.

When an application terminates, it can be lazy in releasing resources or avoids clean up altogether, the exit function of a module must carefully undo everything the init function built up, or the pieces remain around until the system is rebooted.

Sometimes , we end out of memory situations and system may totally crash. Note when application crashes, system can run without any issue, if kernel module crashes, it will kill the process or whole system needs to be rebooted

4. Ability to unload a module
Incidentally, the ability to unload a module is one of the features of modularisation that you'll most appreciate, because it helps cut down development time; you can test successive versions of your new driver without going through the lengthy shutdown/reboot cycle each time.

If you have driver programming experience, you will really appreciate this feature. It save lot of time and effort

With application, you need to either exit it completely and rerun the application. You will not be sure if the memory allocated is dealloated or the task initiated is exited cleanly. It all depends on how you implement the application.

5. Linking Stage
An application can call functions it doesn't define: the linking stage resolves external references using the appropriate library of functions.

printf is one of those callable functions and is defined in libc.

A module, on the other hand, is linked only to the Kernel, and the only functions it can call are the ones exported by the Kernel; there are no libraries to link to. This point is very important. Keep in mind that there are no libraries for kernel modules to link to

The printk function used in hello.c earlier, for example, is the version of printf defined within the kernel and exported to modules. It behaves similarly to the original function, with a few minor differences.

Because no library is linked to kernel modules, source files should never include the usual header files. There are special exceptions like <stdarg.h> .

Only functions that are actually part of the Kernel itself may be used in Kernel modules. Anything related to the Kernel is declared in headers found in the Kernel source tree had to be set up and configured.

Most of the relevant headers live in "include/linux" and "include/asm", but other sub directories of include have been added to host material associated to specific Kernel subsystems.

6. Handling Faults
Another important difference between kernel programming and application programming is in how each environment handles faults.

As briefed earlier , Segmentation fault is harmless during application development and a debugger can always be used to trace the error to the problem in the source code, a kernel fault kills the current process at least, if not the whole system.

Hey don't forget to check out youtube version of this article here.

If you like, please dont forget to give a thumbsup :)

Linux Device Drivers Part - 6 : Loading Listing and Unloading Kernel Modules

2015-06-06T06:26:00.000-07:00

In this part , we are going to discuss about

1. Loading Kernel modules
2. Listing kernel modules
3. Unloading kernel modules

Before going ahead with these topics, I strongly recommend you to watch my earlier videos on Linux Device Driver Part 1 to 5.

Fine, lets start with our first topic

1. Loading Kernel modules
In earlier session "Linux Device Drivers Part-5", we learnt how to build a sample helloworld Linux Kernel module.

In this session we will see how to load that sample module into the kernel.

We have two kernel utilities which does the trick of loading modules into the kernel.

We have two utilities to perform this task
1. insmod
2. modprobe

In following slides we will discuss about these utilities, their syntax and usage

So,What is insmod and what does it do ?

Insmod is a kernel utility that installs loadable Kernel modules into kernel.

It actually loads the module code and data into the kernel land, it links any unresolved symbols in the module to the symbol table of the kernel.

Insmod accepts a number of command line options and it can assign a value to parameters in a module before linking it to the current kernel.

Note that if a module is correctly designed, it can be configured at load time by passing arguments to insmod.

Lets see syntax of insmod

Syntax:
insmod [filename] [module-options...]

These module options are optional.

For example:
insmod my_module.ko

This command inserts a module named my_module into kernel with no module option

Take another example,

 insmod /path/to/my_module.ko param1=0x330

This command inserts my_module into kernel, specifying the module options "param1=330" . Module-options are just like command line arguments to kernel object

We will discuss more about module options in upcoming sessions ===
One important point to note here is that insmod accepts only one module as input prameter

You can't load two loadable modules at a time using insmod utility.

Second utiltiy is modproble

It’s a Linux utility which offers more features than basic insmod utility.

When compared to insmod, modprobe has various advantages like
It has the ability to decide which modules to load. Modprobe checks a directory /lib/modules/$(uname -r) for modules. This way it knows what modules to load

Also, Its aware of module dependencies.To know details of module dependencies, Modprobe uses another configuration file called modules.dep which is generated by depmod program

It supports resolution of recursive module dependencies when required. When requested to load a particular module say its name x, if it has dependency on another module say y which is again dependency on z, modprobe tries to find these modules in the current path or standard lib path and loads these modules to resolve all the dependecy symbols.

These features are not available with basic insmod command

Coming to syntax of modprobe to install a module

Its Basic syntax is
modprobe [modulename...]

command followed by optional module name

For Example :
$sudo modprobe

When modeprobe is soley used, it intelligently adds or removes a module from /lib/modules/'uname -r'

$sudo modprobe my_module.

  $sudo modprobe my_module.

Note you should be a super user to execute modprobe.
Modprobe supports various options. Please refer modprobe man page for more details.

Lets learn the difference between insmod and modprobe

While loading a module, insmod fails with "Unresolved Symbol" error when an unresolved symbol is present in the loading module.

Where as modprobe looks at the module to be loaded to see whether it references any symbols that are not currently defined in the kernel. If any such references are found, modprobe looks for other modules in the current module search path that define the relevant symbols.

When modprobe finds those modules which are needed by the module being loaded, it loads them into the kernel as well.

In short, while loading a module into kernel, if that module has any dependency on another module, modprobe find those modules under current module search path, it loads them into the kernel.

Note modeprobe is aware of default location of modules and knows how to figure out the dependencies and load the modules in the right order.

One more important point to note here is we need to root permissions for executing both insmod and modporbe commands.

When a module is loaded, any symbol exported by the module becomes part of kernel symbol table.

So what exactly is kernel symbol table

Kernel Symbol Table:

In earlier slides we have discussed about insmod resolving undefined symbols by referring Kernel Symbol Table. The Kernel Symbol table contains the addresses of global kernel items, functions and variables that are needed to implement modularized drivers.

Now we know details of loading a kernel module using insmod and modprobe. Lets jump to our second topic,

2. Listing modules currently loaded in kernel

We use a Linux utility called “lsmod”

Lsmod command lists the modules currently loaded in the kenrel. Lsmod works by reading the /proc/modules virtual file.

Information on currently loaded modules can also be found in the sysfs virtual filesystem under /sys/modules.

Syntax:
$lsmod

3. Unloading kernel modules
Two Kernel Utilities to unload the modules are
$rmmod
$Modprobe

Lets learn about rmmod
rmmod is a Linux utility which unloads the loadable module.

Module should be already loaded to execute rmmod command.

Module fails if the kernel believes that the module is still in use or if the kernel has been configured to disallow module removal.

Syntax of rmmod

rmmod [module name]
Example: $rmmod my_module

Note name "my_module" doesnt have any extension like .ko here

Note :We need to be a super user for executing this command.

Modprobe syntax

Since we have already discussed about modprobe in earlier slides, lets learn the syntax for unloading a kernel module

Syntax is
$modprobe –r [module-name]

For example:

  insmod my_module.ko

$modprobe –r my_module

Note : There is no ko extension here and We need to be a super user for executing this command.

Lets wind up this session with an important question asked in forums.

Is it possible to forcibly remove the kernel modules when the are in use ?

Yes, its possible to configure the kernel to allow forced removal of modules, even when they appear to be busy.

Commands normally used are
rmmod -f yourmodule
modprobe -rf yourmodule

These commands only work when you enable the kernel configuration CONFIG_MODULE_FORCE_UNLOAD.

Hey don't forget to check out youtube version of this article here.

If you like, please don't forget to give a thumbsup :)

Linux Device Drivers Part - 5 : Building and Compiling Kernel Moduels

2014-08-11T14:34:00.001-07:00

In this part, we will discuss about 5 topics

Linux Device Driver Example References
Setting up Environment for compiling Kernel modules.
Implementing Helloworld Kernel module and Macros used in it.
Creating Makefile to compile Helloworld Kernel module
Compilation and Kernel object generation of Helloworld Kernel module

1. Linux Device Driver Example references

Before proceeding further, make sure you have watched my earlier videos on "Linux Device drivers" Part 1 to Part 4.

As mentioned in my earlier videos, most of the concepts discussed in these sessions are derived from famous O'Rielly Linux Device Drivers 3rd edition.

To demonstrate Kernel programming concepts, I will be using the O'Reilly sample programs which are available on below site to download.

      http://examples.oreilly.com/linuxdrive3

Download these files and save it to your harddrive. Compiling, loading and modifying these examples are good way to improve your understanding of how Linux Device drivers work and interact with Kernel.

All examples work with any 2.6.x Kernel. You need to install Kernel headers before Building and running your modules.

2. Setting up Environment for compiling Kernel modules.

I am using a Virtual Linux system in Windows 7. To know how to install Linux on Windows 7 Pc, please watch my earlier video on "Installing Linux in windows 7 PC using Oracle VM Machine"

Now we will install the necessary packages required for compiling Compiling a Kernel module.

In order to install any package you should be a super user (from here on we will address it as root).

Login as root by typing "su" command in the terminal.

Enter the root password.

Its always safe and good practise to login as user and then switch to root when required.

Type below command to install Kernel headers and other basic packages required for compiling kernel modules.

$sudo yum install vim gcc kernel-devel kernel-headers dkms make bzip2

Lets see more about the packages which we are going to install

Vim – Popular Linux Editor
gcc – C Compiler
Kernel-devel – are the files that are required for compiling kernel code that will run as part of the kernel, such as kernel modules.
Kernel-headers - contains files that describe the system environment and are used for compiling normal programs that run in userspace.
dkms - Dynamic kernel module support package
make - make file tool necessary for Kernel code buildsystem.
bzip2 - zipping tool

While installation kernel may ask "Is this ok Y/N". Type Y and complete the installation.

At the end, you will observe kernel source installed under /usr/src/kernels/2.6.xx

Once the installation is done, reboot your Linux Machine.

Once your virtual box is rebooted, login with user credentials.

We have completed the setting up environment.

3. Implementing Helloworld Kernel module and Macros used in it.

Now lets begin with Hello world Module

Log into your Virtual machines as a user.

Open a terminal window

Create a directory with name LDD-3 (Its your choice) anywhere preferably in your home directory (like /home/mrtechpathi)

Change directory to it

cd LDD3

Create your first helloworld module. So how do you do that ?

For this we will use vim editor. Which is very popular and used by many Linux programmers all over the world. Though novice programmers may face issues but will be wonderful editor to work with.

Now lets type hello world program. I will name it as hello.c

 #include <linux/init.h>  
 #include <linux/module.h>  
 MODULE_LICENSE("Dual BSD/GPL");  
 static int hello_init(void)  
 {  
   printk(KERN_ALERT "Hello, world\n");  
   return 0;  
 }  
 static void hello_exit(void)  
 {  
   printk(KERN_ALERT "Goodbye, cruel world\n");  
 }  
 module_init(hello_init);  
 module_exit(hello_exit);

Instead of copy pasting this program, I would recommend to type program yourself which makes you understand each and every line of it.

Great you have coded your first Hello world kernel module.

Lets understand more about the helloworld kernel module

Kernel headers used in Module

#include <linux/init.h>
This header contains the definition of the functions used in this module.
Module_init() and Module_exit() are defined in this file.

Module_init() is a macro which defines the function to be called at module
insertion time or at system boot time.

Module_exit() is a macro which defines the function to be called at module removal time. This function is also called Celan up function.

Kernel modules must always contain these two functions, init_module and cleanup_module.

If you clearly observe in helloworld kernel module code (above) , we have used a two kernel headers and special kernel macros.

 1.MODULE_LICENsE  
 2.printk  
 3.KERN_ALERT

Lets see whats significance of these Kernel headers.

1. MODULE_LICENSE
This macro is used to tell the kernel that this module bears a free license; without such a declaration, the kernel complains when the module is loaded.

2. Printk function
This function is similar to printf in standard C. This is implemented to make kernel have its own print function instead of having dependency on C library.

3.KERN_ALERT
This string is the priority of message. KERN_ALERT is the highest priority set to specify kernel to print the message immediately.We will discuss more about this macro in up coming sessions.

Coming to the functions used in this Helloworld kernel module,
There are two main functions.

hello_init and hello_exit

Function 1: hello_init()
This particular function is called when the module is loaded

Function 2: hello_exit()
This particular function is called when module is removed.

We will see more about loading and removing kernel modules in coming session

Now we have our hello.c module implemented. Its time to compile

To compile this Kernel modules, we need to create a Makefile.

I am in LDD-3 directory where my hello.c is present.

Before creating a makefile for our helloworld module, we need to know the path of kernel build directory. For this first we need to know the kernel version.

To know the kernel version used in your PC, type "uname -a"command in the terminal.

 [root@localhost LDD]# uname -a  
 Linux localhost.localdomain 2.6.32-431.20.5.el6.i686 #1 SMP Fri Jul 25 05:42:52 UTC 2014 i686 i686 i386 GNU/Linux

This command displays the current linux version.

Make a note of this name for example, 2.6.32-431.20.5.el6.i686.

With this information, we will try creating a makefile for our helloworld module.

4. Creating Makefile to compile Helloworld Kernel module

Open a vim editor and type these couple of lines.

 obj-m := hello.o  
 KDIR := /lib/modules/2.6.32-431.20.5.el6.i686/build  
 PWD := $(shell pwd)  
 default:  
     $(MAKE) -C $(KDIR) SUBDIRS=$(PWD)

obj-m:=hello.o
This assignment states that there is one module to be built from object file hello.o.

Some may wonder how this single line does whole job.

The kernel build system in Linux 2.6 Kernel is designed in
such a way to handler the rest of the parameters.

KDIR := /lib/modules/2.6.32-431.20.5.el6.i686/build
Its Kernel build directory. The director which starts with 2.6.32 here is the one which we noted down before creating this Makefile. We got this by executing 'uname -a'

PWD := $(shell pwd)
Current directory path. It shows the kernel about the current location of our kernel module. Since we are creating makefile in the same directory, we will read current path to PWD variable.

Now the last line
default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD)

This is the main make command which switches to your Kernel build directory and invokes the make command to compile helloworld kernel module present in the sub-directory.

-C option tells make command to switch to kernel build directory. directory.

5. Compilation and Kernel object generation of Helloworld Kernel module
Now we have Makefile and hello.c file in our LDD-3 directory.

Lets execute the program. Executing program is very simple now.

Just type ‘make’ command in the directory where your Kernel module and Makefile are present.

make will compile the helloworld program and generates the kernel object of helloworld module.

We can find kernel object hello.ko in the same directory.

In next session we will see how to load and remove this kernel module.

Hey dont forget to watch Linux Device Part -5 in youtube. I am sure you will like it and give a thumbs-up.

Linux Device Drivers - Part 4 : Linux Kernel Moduels (LKM) and types of LKM's

2013-06-23T06:45:00.000-07:00

In this sesssion, we will discuss about

Linux Kernel Modules
Base Kernel,
User Space and Kernel Space
Types of Linux Kernel Modules,
Which module type to choose while Kernel Programming ?
Location of Linux Kernel Modules in a linux PC.

What exactly is a module in Linux ?
Its a piece of code that can be added to the Base Kernel. We will be discussing about Base kernel in coming slides.

If you are planning to add some code to kernel, then it means you are adding a module to Linux Kernel.We can't just add code to Linux without any purpose. We add code to make a device (like printer,bluetooth dongle etc) to work.We call this piece of code as device drivers in Windows.

Assuming many are familiar with Windows, we can draw one conclusion.As we have device drivers in Windows Operating system, we have modules in Linux Operating system.In short, Devices Drivers are called modules in Linux Operating system. Both terms can be used interchangeably.

Before knowing about Module types, we need to know about Base Kenel, User Space and Kernel Space.

What is a Base Kernel:

Kernel code which is compiled and loaded along with basic device drivers as a single entity is called Base Kernel.Note that all parts of base kernel will be loaded all the time.Once you have a working base kernel,it is good to leave it untouched as long as possible.

Next we will discuss about User space and Kernel space in Linux.

From this diagaram, Base Kernel along with Kernel modules (KM1 and KM10) fall under Kernel space. User applications fall under user space.

What are User Space and Kernel Space ?

Simplified answer is that the kernel runs in kernel space, and normal programs run in user space.

Normal programs in user space can't mess with memory (and other resources) owned by other programs or by the Linux kernel. This limits their ability to do corrupt things like crashing the machine.

The kernel is the core of the operating system. It normally has full access to all memory and machine hardware (and everything else on the machine. To keep the machine as stable as possible, you normally want only the most trusted, well-tested code to run in kernel mode/kernel space.

Modules in Linux are of two types.

1. Static Modules
2. Dynamic Modules

What is a static module ?

Static modules are those which are compiled as a part of the base kernel and is available at anytime.

From this diagram you can see the static modules are part of Kernel image. They are compiled and loaded as a part of base kernel image.

What is dynamic module ?

Dynamic modules are compiled as modules separately and loaded as and when required.

These are also called Loadable Kernel Modules. In short we call them as LKM from now on.

Every Kernel Programmer should clearly understand about dynamic modules and how they work.

From this diagram, we see the dynamic modules are compiled separtely. They are not part of basic kernel image.

To know how exactly dynamic module is loaded, we need to know 4 important steps.

Step 1: From this diagram, assume you have written a dynamic module xyz. You will also write an application which tries to access xyz functionalities.

Step 2: Once Linux is up on running on your PC or device, you will dynamically insmod your xyz module using "insmod" command to RAM. We will discuss about insmod in later sessions.

Step 3: You application in userspace xyz will try to access functionalities of your hardware through xyz module by calling Linux provided system calls. Normally they are called ioctl calls. We will discuss about ioctl calls later.

Step 4: Once the required hardware functionality is retrieved by the user application, when xyz module is no more needed, we can request kernel to remove xyz module using rmmod command.

These are 4 simple steps how a dynamic module is loaded, functionality of hardware is retrieved and dynamic module is removed.

Once after discussing about static and dynamic modules, we have a common question, which one to use ? which is the best ?

Yes ,always a device driver programmer has a choice between building his module as static module or dynamic module.

To decide on this, we need to first know few things.

Disadvantages of building your module as static.
Advantages of building your module as dynamic (as LKM).

Disadvantages of building your module as static:

Lets say you have written a static module "xyz" for a device driver.
When you compile this as static module along with kernel, you will be adding extra size to the kernel image permanently. This the first major disadvantage. As the kernel size grows, the time taken to load the kernel and size occupied by the kernel image in the memory.increases.

Whenever you modify your "xyz" device driver, you need to recompile your entire kernel to build it.
Also machine need to be rebooted for the changes to take effect.

One more important drawback is While you device driver is not stable, when you build it as static module, you will face issues which takes more time to debug.

Take scenario when there is a memory overflow bug in your "xyz" static module. Once it is statically compiled and the kernel is loaded, at some point of time, the kernel may crash.

In order to debug it people may take hours or days to fix it. Also your kernel which includes this "xyz" as part of it will be useless till you fix the crash issue.

This doesn't happen when you build you "xyz" as dynamic module. We will see how in a short while.

Advantages of building your module as dynamic (as LKM):

Lets say you built your xyz module as dynamic (LKM) now.

With this you don't have to rebuild your kernel as often. It can be compiled separately.

It saves you time and spares you the possiblity of introducing an error in rebuilding and reinstalling the base kernel.

It can be loaded onto kernel at run time without having the machine to reboot.

It saves you memory beacause you load them when you are actually using them.

It can be unloaded anytime and hence no permanent affect on kernel size.

Since these are compiled and built serpately from kernel, they are much faster to maintain and debug.

Each dynamic module is made up of object code that can be dynamically linked to the running kernel by the insmod program and can be unlinked by the rmmod program.

Many have a misconception that dynamci modules are bit slower than Static modules. I totally disagree with them because, loading either one is simply a brach to the memory location where it resides.

With information known till now, lets see the example which we discussed earlier about a overflow bug in your module. Assume this bug is present in your "xyz" module which is built as dyanmic module.

Once you boot-up your Linux on your Embedded device or PC, load your LKM's along with your “xyz” dynamic module, after a while when your system crashes because of overflow bug, to know if your "xyz" module is causing the issue, you can discard loading your "xyz" module after next boot up and just load the base kernel along with other dynamic modules and see if the system crash.

If it doesnt, then it clearly shows that your "xyz" module is the culprit and you can debug and fix the bug without any much headache.

Remember, you can even use your base kernel and other LKM's till you fix this overflow bug in your "xyz" dynamic module.

Hope everyone are clear with this explanation. If youare not clear, please drop a comment.

ok,Now if we repeate our earlier question as a kernel programmer, which one do you prefer static module or dynamic module ?

As a good kernel programmer, one should prefer building their module as dynamic module.

So when to use Static modules ?

There are times where one have to build something into the base kernel instead of making it a dynamic module.

Anything that is necessary to get the system up far enough to load dynamic modules must obviously be built into the base kernel.

For example, the driver for the disk drive that contains the root filesystem must be built into the base kernel

Final topic of this session,

Location of linux kernel modules in linux device or PC:

Usually, all Linux kernel modules (drivers) are stored in the module directory located that /lib/modules/$(uname -r) directory.

To see current modules, type:
$ ls /lib/modules/$(uname -r)

Use the following command to list all drivers for various devices:
$ ls /lib/modules/$(uname -r)/kernel/drivers/

Thats all for this session. If you have any doubts, dont hesitate to drop a comment or a mail.

For more explanation, please watch this video.

Installing Linux on Windows 7 PC using Oracle VM Virtual Box

2013-06-09T11:38:00.000-07:00

In previous session, we learnt about a Windows 7 application "Oracle VM VirtualBox". Please view previous session before proceeding further.

Right, once you are done installing with "Oracle VM VirtualBox", you need to first choose the flavour of Linux you are going to install using VirtualBox.

I will go ahead and download Centos OS Linux Flavour.

To download this iso image, open a separate tab and type this address in address bar.

 http://centos.linuxfreedom.com/download.html

In this website, scroll down and download the first one. Since its 690Meg, it takes time to download. So, wait till the download gets completed.

Since, I have already downloaded this image to a particular location, I will go ahead with our tutorial.

Start VirtualBox application in windows.Best way is to click here on startup menu and search for virtualbox. Click on it to open.

This is very simple interface and easy to install Linux using this application.

Using this application you can create n number of virtual machines depending on your requirement. For today's tutorial, we will create Centos Linux Virtual machine.77

So lets see how to do it.

First select New.

Type Name as you wish. I am going to type "MrTechpathi_Centos"

Based on your name, the type and verison will get updated automatically. If not, select the type as "Linux" and version as "Red Hat".

Click on "Next".

Now, we need to select the memory size.You should be very careful in choosing the amount of memory here because its allocated to virtual Machine from your existing Ram memory.

I am having 3Gig of RAM so, I will go ahead with 1.4GB. VirtualBox actually shows green and pink color in order to show the best and worst case scenarios. So, choose wisely.

Click on "Next"

Here, you need to create a hard driver for your virtual machine. So, you need to

Select option "Create a virtual hard drive now"0. Click on "Create"

Now, select default options from here on. Select VDI (VirtualBox Disk Image) as type of your hard drive and click on "Next".

Select "Dynamically allocated" option and click on "next".

Choose the location of virtual harddrive and also size of the harddrive. I will leave the default location unchanged and change the Harddisk size from 8Gig to 32Gig. Choosing Harddisk size again depends on the size of free space available in your Windows 7 harddrive.

Click on "create".

Now we are ready with a virutal machine skeleton.

We need to add iso image to it. Lets do it now.

When you click on "storage", you can see two entries. One IDE and SATA.

Under IDE, you will find Empty entry.Select Empty and On the right hand side, under attributes, choose a virtual CD or disk file option.

Here you need to select your centos iso image downloaded during initial stages of this tutorial.

Once selected, click on ok.

So, till now, we have created Harddrive for virutal machine and added centos iso image as controller IDE.

Now its time to start the centos virtual machine and install iso image to virtually created harddisk.

Select your virtual machine and click "start".

Please read this message on all pop up messages from here on and press ok.

I would like to mention one important thing here. In order to switch between your virtual machine and Windows 7 PC, you need to press "RightCtrl" button on your keyboard. To make it easier to remember, VirtualBox displays "RightCtrl" at the bottom of virtual machine.

Wait till Linux boots up.

Click on "Login".

Now you have standalone virual centos Linux operating system running on your Windows 7 PC.

To install Centos to your virtual harddrive, select "Install to HardDrive" option on the desktop.

This will start CentOS installer.

From here on its normal installation procedure.

Click on "Next"

Select your preferred country. I will select mine as "United Kingdom".

Select "Basic Storage Devices" and click "Next".

Since we have allocated 32Gig from Windows 7 free space for our virtual harddrive, select "Yes,discard any data".

Name your computer. I will name mine as mrtechpathi and click next.

Select the timezone accordingly.

Mine I have selected as London. Click on "Next"

Enter root password and confirm. Click on "Next".

To use 32Gig virutal harddisk, select "Use all space" and click "Next".

Select "write changes to disk" option to write storage configuration to disk.

Now relax and wait for few minutes for the installation to complete.

So, after few minutes, the installation is done.

Click on Close and proceed.

Now poweroff the virtual machine and restart by pressing Start.

Wait till the Linux Boots-up. Once after the bootup you need to do initial setup. For more details please watch this video.

How Linux Boots ? Linux Boot-up procedure made easy.

2013-06-07T08:09:00.002-07:00

If you are new to Linux and interested in Linux Boot process, you have reached the correct web-page.This article is for you.

Linux is a Open Source Operating System developed by many programmers around the clock. Its a dynamically evolving Operating system used in various devices like Mobiles, Personal computers, Laptops, tablets etc.

If you are using a Linux PC (or a device) in your daily life, it’s important to know how it boots and what steps are involved in its boot up process.

The moment you switch on a Linux device, you may notice various screen displayed during the initial stage of Linux Boot-up. Finally you will end up with a log-in prompt.

Are you curious to know what exactly happens between the power-up and the display of Login prompt ? If you are, then lets see how Linux boots.

Linux Boot-up process involves mainly 4 steps:
1.    BIOS
2.    MBR (First Stage Bootloader)
3.    Kernel Loader (Second Stage Boot loader)
4.    Kernel

1. BIOS (Basic Input/Output System) :

Resides at the end of flash memory. This is a well- known location to a processor when the system is reset.
BIOS program is written into permanent read-only memory and is always available to use.
It provides the lowest level interface to peripheral devices and controls the first step of the boot process.
It performs a Power On Self-Test (POST) for all the hardware components in the system to make sure that all hardware’s are functional.
It checks if the computer is being started from a cool boot (off position) or from a warm boot (restarted).
It retrieves the information from CMOS (Complementary Metal Oxide Semiconductor) a batter operated memory chip on the motherboard that sotres time, data, and critical information of the computer.
Once above steps are successful, based on the order of the bootable media selected in the BIOS, it boots up the Linux.
If Linux is installed in Hard-drive, it looks at the first sector of the Hard-disk for (MBR) Master Boot Record. It loads MBR to memory and passes control to it.

2. MBR (First stage Boot Loader):

MBR is the first stage boot loader which is loaded into the RAM and executed. This boot loader is less than 512 bytes in length (a single sector) .
First 416 bytes is the Boot loader, the next 64 bytes is the partition table and 2 bytes of magic number.
Job of boot loader is to load the second stage boot loader.
It does this by looking through the partition table for an active partition. When active partition is found, it scans the remaining partition in the partition table and make sure that they are all inactive. When this is verified, the active partition is loaded into the RAM and executed.
From there on, second stage boot loader passes control to the kernel image and the kernel is decompressed and initialized.

3. Kernel Loader (Second stage Boot loader):

Once control reaches kernel loaders , its task is to load the Linux Kernel and optional initial RAM disk (initrd kernel).
This also checks the system hardware, enumerates the attached hardware devices, mounts the root device, and then loads the necessary kernel modules.
On success, it starts the first user-space program (init) and performs high level system initialization.
The first and second stage boot loader combined together are called LILO (Linux Loader) or GRUB (Grand Unified Boot loader) in X86 PC environment.
GRUB is superior to LILO. So, let’s know about GRUB.

GRUB:

GRUB includes knowledge of Linux File systems.
It can load a Linux Kernel from an ext2 or ext3 system.
Its loads Linux Kernel in three stage boot loader instead of above discussed two stage boot loaders.
Stage 1: Boots a stage 1.5 boot loader that understands the particular file system containing the Linux Kernel Image.
Once Stage 1.5 boot loader is up and running, stage 2 boot loader can be loaded.
With Stage 2 boot loader loaded, GRUB displays list of available kernels (as in /etc/grub.conf). It allows you to select a kernel and even amend it with additional kernel parameters.
Till here, with second stage boot loader in memory, the file system is verified, and default kernel image and initrd image are loaded into memory. With the image ready, the stage 2 boot loader invokes the kernel image.

4. Kernel:

Once kernel is loaded into the memory, it finds init in sbin and executes it.
Init is the parent or grandparent of all the processes that start up automatically in Linux system.
Init reads the initialization file “/etc/inittab”. This instructs init to read an initial configuration script for the environment, which sets the path, starts swapping, checks the file systems , sets the clock , initializes serial ports etc.
Init continues to read /etc/inittab file, which describes how the system should be set up in each run level and sets the default run level.
Available run levels are generally described in /etc/inittab, which is partially shown below:

 #  
 # inittab  This file describes how the INIT process should set up  
 #      the system in a certain run-level.  
 # Default run level. The run levels are:  
 #  0 - halt (Do NOT set initdefault to this)  
 #  1 - Single user mode  
 #  2 - Multiuser, without NFS  
 #  (The same as 3, if you do not have networking)  
 #  3 - Full multiuser mode  
 #  4 - unused  
 #  5 - X11  
 #  6 - reboot (Do NOT set initdefault to this)  
 #

Runlevel selection can be done in /etc/inittab file.

Now based on run level selection, the Linux Kernel boots up and finishes the boot process and displays the login prompt for the user to input.

Note : System boot up process depends on the hardware that Linux is being booted on.
Please note that in this article we discussed about the boot process of Linux on X86 platforms.
This process may change for other platforms.

Installing Oracle VirtualBox Applicaiton on Windows 7

2013-05-31T15:47:00.000-07:00

Before starting this tutorial, please take backup of your valuable data. MrTechpathi-Tutorials takes no repsonsibility for any damage or loss of your valuable data.

Many wish to install Linux operating system on PC or laptop. First we think about installing as a secondary operating system along with Windows 7.

Later, we feel difficult to switch between Linux and Windows because we need to reboot PC for doing this.

How to overcome this issue ? Cant we install Linux in Windows 7 ?

Yes we can. But we need an application which will allow us to complete this task.

There are many such applications available in market. I have chosen Oracle VM VirtualBox Manager.

What exactly is a VirtualBox ?
VirtualBox is a general-purpose full virtualizer for x86 hardware, targeted at server, desktop and embedded use.

Lets see how to install ..

First,open your favourite web-brower and copy past this url in address bar of your web-browser.

 https://www.virtualbox.org/wiki/Downloads

You will find various virtualBox binaries for various platforms. Since we are installing VirtualBox in Windows 7 PC, choose the first one and save it to a particular location in your hard-drive.

Once the binary is downloaded, double click on it.

Select Run to the pass the security warning.

Select Next to pass the welcome screen.

Select the location where the installation should take place. Simply select the defaults and press Next.

Select Yes for passing this warning.

Next select install to proceed ahead with installation.

This may take some time.

Finally, Oracle VM VirtualBox is successfully installed.

Leave default check box selection to start Oracle VM VirtualBox" and select Finish.

So, this is the oracle VM VirutalBox Manager applicaiton using which we will be installing a Linux Virtual Machine in Windows 7.

For more details, please check this video:

Linux Device Drivers Part - 3 : Role of Linux Kernel

2012-10-24T14:06:00.001-07:00

As a prerequisite, I strongly recommend you to watch Part-1 and Part-2 of Linux Device Drivers from MrTechpathi Tutorials.

In this part we will learn about Role of Linux Kernel.

Why this topic is choosen ?

This topic is choosen to understand the exact role played by Kernel to provide various services. In this part, I will just brief about kernel roles, eventually we will be discussing them in detail in upcoming parts.

In a Linux system, several concurrent processes attend to different tasks. Each process asks for system resources like computing power, memory, "network connectivity", or some other resource.

Who will be serving these resources ? Yes its the Kernel.

Kernel is the big chunk of executable code in charge of handling all these requests.

Although distinction between the different kernel tasks isn't always clearly marked, the kernel's role can be split into the following parts.

Process management
Memory management
File Systems
Device control
Networking

1. Process managament
As a part of process management, kernel is in charge of creating and destroying processes and handling input and output operations.

Communication amoung different proceess happens through various mechanims called Inter process communication mechanisms. We will discuss about various interprocesss mechanisms like signals,pipes,shared memory in upcoming topics.

In addition, the scheduler, which controls how processes share the CPU, is part of process management. More generally, the kernel's process management activity runs several processes on top of a single CPU or on multiple CPUs.

2. Memory Management
Memory management looks at how the kernel manages physical memory.

Memory is a major resource, and the policy used to deal with it is a critical one for system performance. The kernel builds up a virtual addressing space for any and all processes on top of the limited available resources.

We will be discussing about virtual address space in upcoming topics.

The different parts of the kernel interact with the memory-management subsystem through a set of function calls, ranging from the simple malloc/free pair to much more complex functionalities.

3. File Systems
Almost everything in Linux can be treated as a file. Linux is heavily based on the filesystem concept.

The kernel builds a structured filesystem on top of unstructured hardware, and the resulting file concept is heavily used throughout the whole system.

In addition, Linux also supports multiple filesystem types, that is, different ways of organizing data on the physical medium. For example, disks may be formatted with the Linux-standard ext3 filesystem... the commonly used FAT filesystem or several others.

Key point to remember here is "almost everything in Linux can be treated as a file".

4. Device Control
Almost every system operation eventually maps to a physical device.All device control operations are performed by code that is specific to the device being addressed. Only the exception entitites are processor, memory, and a very few other entities.

What does this mean ? It means in Linux every physical device is controlled by specific code called Device Driver.

The kernel must have embedded in it a device driver for every peripheral present on a system, from the hard drive to the keyboard and the tape drive. This aspect of the kernel's functions is our primary interest in this tutorial.

5. Networking
Networking must be managed by the operating system, because most network operations like asychronous incoming packets are not specific to a process. The packets must be collected, identified, and dispatched before a process takes care of them.

The system is in charge of delivering data packets across program and network interfaces, and it must control the execution of programs according to their network activity. Additionally, all the routing and address resolution issues are implemented within the kernel.

Networking service from the kernel is the one which helps the programmer to explore and access various devices by accessing them remotely.

This is end of Part-3 Linux Device Drivers.

We will continue our next topic in Linux Device Drivers Part-4. Till then stay tuned ....

To know more in detail, watch below video.

Please feel free to comment and query.

Don’t forget to subscribe mrtechpathi videos in youtube.

Linux Device Drivers Part - 2 : System Memory, Static Modules and Dynamic Modules

2012-10-21T03:43:00.000-07:00

Before proceeding further, I strongly recommend you to watch Part-1 of Linux Device Drivers from MrTechpathi tutorials.

In this part we will learn about following topics.

System Memory
Kernel Space and User Space
Kernel Modules : Static Modules and Dynamic Modules

So lets start with our first topic

1. System Memory
This topic is choosen to completely understand user space and kernel space.

Every system has certain amount of memory.

This memory consists of RAM (Random Access Memory) cells, whose contents can be accessed (i.e., read and written to) at extremely high speeds but are retained only temporarily (i.e., while in use or, at most, while the power supply remains on).

Coming to the purpose of memory, it holds programs and data that are currently in use and thereby serve as a high speed mediumbetween the CPU (central processing unit) and the much slower storages like hard disk drives (HDDs).

This System memory in Linux can be divided into two distinct regions: Kernel space and User space.

Hope you understood how system memory, user space and kernel space are correlated.

Now, lets move to our next topic.

2. Kernel Space and User space
So, what is a kernel space ?

Kernel space is where the core of the operating system runs and provides its services.

The left paritition is the kernel space where the operating system runs and provides services.

The right partition is the user space where user processes run.

What is a user space ?

User space is that set of memory locations in which user processes run. A process is an executing instance of a program. One of the roles of the kernel is to manage individual user processes within this space and to prevent them from interfering with each other.

Note that Device Driver runs in Kernel space and not in user space. All applications run in User space.These are very important points to be remembred by every device programmer.

3. Kernel Space and User space Interaction
How does this interaction happens ?

To answer this quesion in short, it happens only through system calls.

In detail, Kernel space can be accessed by user processes only through the use of system calls.System calls are requests in a Unix-like operating system by an active process for a service provided by the kernel, such as input/output (I/O) or process creation.

In this what exactly we mean by Active process ?

An active process is a process that is currently progressing in the CPU. Whereas, process is the one which is waiting for its next turn in the CPU. I/O is any program, operation or device that transfers data to or from a CPU and to or from a peripheral device (such as disk drives, keyboards, mice and printers).

Please note that user space processes can't access the hardware directly. They need to use system calls for accessing certain functionality of hardware. These system calls are implemented by a driver and runs in kernel space to provide functionaliy of hardware to user.

All these interactions are managed by the core kernel.

If we go one step further and relate the previous "User space and Kernel Space" diagram with our program, kernel and hardware, it will resemble as this figure.

Our application program will reside in user space and driver will reside in Kernel space. System calls are the only way for a user space program to access kernel space Device Drivers.

Hope all are clear with Kernel space , User space and their interaction using system calls.

Kernel Modules

Kernel Modules can be classified into two types

Static modules
Dynamic modules

What is a static module ?

Static modules are compiled as a part of the kernel and are available at anytime. These make the kernel larger and has the disadvantage of requiring us to rebuild and reboot the kernel every time we want new functionality.

Is there any better way than static modules ? Yes they are dynamic modules.

What is a dynamic module ?

Dynamic 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. After loading the kernel, we can load this modules using insmod and unload using rmmod. We will be discussing about insmod and rmmod in upcoming tutorials.

Dynamic Modules have the advantage that it uses the Memory more efficiently than the Statically linked drivers.

Hope you are clear about Static modules which will be part of the kernel and dynamic modules which can be loaded into kernel based on our requirement.

This is end of part-2 of Linux Device Drivers.

If you are not clear on any topic discussed till now, please watch part-1 and part-2 couple of times without missing a single point. This will help in upcoming tutorials.

Linux Device Drivers Part - 1 : What is Linux Device Driver ?

2012-10-07T04:32:00.000-07:00

From today, we will be discussing about Linux Device Drivers which are very useful for Device Driver programmers.

Linux has more future and those who learn more on Linux Kernel and Device drivers will benefit a lot. Linux is one of the best open source operating system which is available to everyone. It is majorly used operating system in smart phones and Embedded Systems these days. Yes all, Android phones have Open source Linux Operating system in it which is customized according to Smartphone vendor needs.

So, lets start with Linux Device Driver Programming..

Scope of this Tutorial
To gain in depth knowledge on Linux Device Driver.

From now on, for your convenience, we will be discussing this topic part by part.

In this part we will know about
What is a Linux Device Driver ?

So What is a Linux Device Driver ?
Linux Device drivers are distinct “black boxes” that make a particular piece of hardware respond to a well-defined internal programming interface.They completely hide the details of how the device works.

Points to note while writing a device driver

While writing a driver to a specific device, remember that each driver is different; as a driver writer, you need to understand your specific device well.
You need to gather all information like datasheets, design documents and schematics of your device from device vendor.
Please note that its very difficult to teach about a specific device in this tutorial. Instead, we will teach you how to build the background required to make your device work.

Role of Device driver

As stated earlier, User activities are performed by means of a set of standardized calls that are independent of the specific driver; mapping those calls to device-specific operations that act on real hardware is then the role of the device driver.

That's it for today, for your convenience, we will be discussing Linux Device drivers part by part.

For more pictorial description, watch below video and shed your comments and queries.