Kernel Module Basic Programs

*******************  Kernel Module Basic Programs************************************

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module1.c

Description :- This program illustrate the concept of first kernel module program.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>
#include<linux/kernel.h>

int init_module(void)
{
printk(KERN_INFO "Jay shreeKrishna\n");
return 0;
}
void cleanup_module(void)
{
printk(KERN_INFO "Hare Ram\n");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module1.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module2.c

Description : - This program illustrate the concept, we have to write your user defined entry point functions and its calling mechanism.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

static int __init Module_2_init(void)

{

printk(KERN_INFO "Jay shreeKrishna\n");

return 0;

}

static void __exit Module_2_exit(void)

{

printk(KERN_INFO "Jay RadheShyam\n");

}

module_init(Module_2_init);

module_exit(Module_2_exit);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module2.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module3.c

Description :- This program illustrate concept of to define integer variable and print it in kernel log file using kernel module. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

static int Module3_data __initdata = 3;

static int __init Module_3_init(void)

{

printk(KERN_INFO "Jay shreeKrishna %d\n", Module3_data);

return 0;

}

static void __exit Module_3_exit(void)

{

printk(KERN_INFO "Jay RadheShyam\n");

}

module_init(Module_3_init);

module_exit(Module_3_exit);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module3.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module4.c

Description :- This program illustrate the concept of GPL Licening schem. See this information using command as " modinfo Module4.ko " 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

static int __init Module_4_init(void)

{

printk(KERN_INFO "Hello Sunil \n");

return 0;

}

static void __exit Module_4_exit(void)

{

printk(KERN_INFO "Bye Sunil \n");

}

module_init(Module_4_init);

module_exit(Module_4_exit);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Sunil Bhagwat");

MODULE_DESCRIPTION("This my kernel module");

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module4.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module5.c

Description :- This program illustrate the concept of fulle GPL Licening schem.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

* hello3.c - Demonstrates module documentation.

*/

#include<linux/module.h> /* Needed by all modules */

#include<linux/kernel.h> /* Needed for KERN_INFO */

#include<linux/init.h> /* Needed for the macros */

#define DRIVER_AUTHOR "Sunil V Bhagwat <p@dirac.org>"

#define DRIVER_DESC "A Sample Driver"

static int __init init_Module_5(void)

{

printk(KERN_INFO "Jay shreeKrishna 3\n");

return 0;

}

static void __exit cleanup_Module_5(void)

{

printk(KERN_INFO "Jay RadheShyam 3\n");

}

module_init(init_Module_5);

module_exit(cleanup_Module_5);

/*

* You can use string, like this:

*/

/*

* Get rid of taint message by declaring code as GPL.

*/

MODULE_LICENSE("GPL");

/*

* Or with defines, like this:

*/

MODULE_AUTHOR(DRIVER_AUTHOR); /* Who wrote this module? */

MODULE_DESCRIPTION(DRIVER_DESC); /* What does this module do */

/*

* This module uses /dev/testdevice. The MODULE_SUPPORTED_DEVICE macro might

* be used in the future to help automatic configuration of modules, but is

* currently unused other than for documentation purposes.

*/

MODULE_SUPPORTED_DEVICE("testdevice"); 

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module5.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Module6.c

Description :- This program illustrate the concept of setting access permission to users.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

#include<linux/moduleparam.h>

#include<linux/stat.h>

int myint = 20;

module_param(myint, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

MODULE_PARM_DESC(myint, "integer variable");

static int __init Module_6_init(void)

{

printk(KERN_INFO "Hello Sunil %d\n", myint);

return 0;

}

static void __exit Module_6_exit(void)

{

printk(KERN_INFO "Bye sunil\n");

}

module_init(Module_6_init);

module_exit(Module_6_exit);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Sunil Bhagwat");

MODULE_DESCRIPTION("This is my module for int variable demo");

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Module5.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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- First.c

Description :- This program illustrate the concept of module split into various file. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

int init_module(void)

{

printk(KERN_INFO "Hello sunil bhagwat");

return 0;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Second.c

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/init.h>

void cleanup_module(void)

{

printk(KERN_INFO "Bye sunil bhagwat");

}

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Sunil Bhagwat");

MODULE_DESCRIPTION("This is my module");

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += FirstSecond.o

FirstSecond-objs := First.o Second.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

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Driver_1.c

Description :- This Program illustrate the concept of first Driver virtual program .

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/init.h>

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/fs.h>

#include<asm/uaccess.h>

#include<linux/device.h>

#define DEVICE_NAME "My Driver"

#define CLASS_NAME "MY DEVICE DRIVER"

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Sunil Bhagwat");

MODULE_DESCRIPTION("My Demo Device Driver");

MODULE_VERSION("0.1");

static int majorNumber;

static char message[250] = {0};

static short size_of_message;

static int numberOpens = 0;

static struct class* charClass = NULL;

static struct device* charDevice = NULL;

static int dev_open(struct inode *, struct file *);

static int dev_release(struct inode *, struct file *);

static ssize_t dev_read(struct file *, char *, size_t, loff_t *);

static ssize_t dev_write(struct file *, const char *, size_t, loff_t *);

static struct file_operations fops = 

{

.open = dev_open,

.read = dev_read,

.write = dev_write,

.release = dev_release,

};

static int __init char_init(void)

{

printk(KERN_INFO "MyDriver : Driver loaded sucessfully \n");

majorNumber = register_chrdev(0, DEVICE_NAME, &fops);

if(majorNumber < 0)

{

printk(KERN_ALERT "MyDriver : failed to register a major number \n");

return majorNumber;

}

printk(KERN_INFO "MyDriver : reistered correctly with major number %d \n", majorNumber);

charClass = class_create(THIS_MODULE, CLASS_NAME);

if(IS_ERR(charClass))

{

unregister_chrdev(majorNumber, DEVICE_NAME);

printk(KERN_ALERT "Failed to create the device \n");

return PTR_ERR(charClass);

}

printk(KERN_INFO "MyDriver : device class registered correctly \n");

charDevice = device_create(charClass, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME);

if(IS_ERR(charDevice))

{

class_destroy(charClass);

unregister_chrdev(majorNumber, DEVICE_NAME);

printk(KERN_ALERT  "Failed to create the device \n");

return PTR_ERR(charDevice);

}

printk(KERN_INFO "MyDriver : device class created correctly \n");

return 0;

}

static void __exit char_exit(void)

{

device_destroy(charClass, MKDEV(majorNumber, 0));

class_unregister(charClass);

class_destroy(charClass);

unregister_chrdev(majorNumber, DEVICE_NAME);

printk(KERN_INFO "MyDevice : Goodbye from our driver! \n");

}

static int dev_open(struct inode *inodep, struct file *filep)

{

numberOpens++;

printk(KERN_INFO "MyDriver : Device has been opened %d time(s) \n", numberOpens);

return 0;

}

static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset)

{

int error_count = 0;

error_count = copy_to_user(buffer, message, size_of_message);

if(error_count == 0)

{

printk(KERN_INFO "MyDriver : Sent %d characters to the user \n", size_of_message);

return (size_of_message = 0);

}

else

{

printk(KERN_INFO "MyDriver : Failed to send %d characters to the user \n", error_count);

return -EFAULT;

}

}

static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset)

{

sprintf(message, "%s(%d letters)", buffer, len);

size_of_message = strlen(message);

printk(KERN_INFO "MyDriver : Received %dcharacters from the user \n",len);

return len;

}

static int dev_release(struct inode *inodep, struct file *filep) 

{

printk(KERN_INFO "MyDriver : Device successfully closed \n");

return 0;

}

module_init(char_init);

module_exit(char_exit);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Driver_1.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

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Demo.c

Description :- This is a demo program to access that virtual device.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<stdio.h>

#include<stdlib.h>

#include<errno.h>

#include<fcntl.h>

#include<string.h>

#define BUFFER_LENGTH 256

static char receive[BUFFER_LENGTH];

int main()

{

int ret, fd;

char stringToSend[BUFFER_LENGTH];

printf("Starting device test code example...\n");

fd = open("/dev/My Driver", O_RDWR);

if(fd < 0)

{

perror("Failed to open the device...");

return errno;

}

printf("Type in a short string to send to the kernel module: \n ");

scanf("%[^\n]%*c",stringToSend);

printf("Writing message to he device [%s].\n",stringToSend);

ret = write(fd, stringToSend, strlen(stringToSend));

if(ret < 0)

{

perror("Failed to write the message to the device.");

return errno;

}

printf("Press Enter to read back from the device...\n");

getchar();

printf("Reading from the device...\n");

ret = read(fd, receive, BUFFER_LENGTH);

if(ret < 0)

{

perror("Failed to read the message from the device.");

return errno;

}

printf("The received message is:[%s]\n",receive);

printf("End of the program\n");

return 0;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program Name :- Driver_2.c

Description :- This program illustrate the concept of registering the Driver program.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<linux/module.h>

#include<linux/init.h>

#include<linux/kernel.h>

#include<linux/types.h>

#include<linux/fs.h>

#include<linux/kdev_t.h>

static dev_t mydev;

static char buffer[64];

MODULE_AUTHOR("Sunil Bhagwat");

MODULE_LICENSE("GPL");

static __init chardrv_in(void)

{

printk(KERN_INFO "Character driver being loaded.\n");

alloc_chrdev_region(&mydev, 0, 1, "Demo Driver");

printk(KERN_INFO "Information of our driver is %s \n", format_dev_t(buffer, mydev));

return 0;

}

static void __exit chardrv_out(void)

{

printk(KERN_INFO "Characterr driver being unloaded. \n");

unregister_chrdev_region(mydev, 1);

}

module_init(chardrv_in);

module_exit(chardrv_out);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

File Name :- Makefile

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

obj-m += Driver_2.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

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////