******************* 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");
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
No comments:
Post a Comment