Modular As Part Of Kernel|Computer Science
Paper 3 =========== Convert the paper 2 that you did, to be built statically as part of kernel, instead of a loadable module. Give user the choice of including this module or not in the final binary in the ‘make menuconfig’ Your user program from assignment 2 should work with out any changes. Please submit the following files… 1. Kconfig (that you edited) 2. .config 3. Module source code 4. User program 5. Out put text (both dmesg output as well as user program execution) Do not submit binaries
#include<linux/module.h> #include<linux/kernel.h> #include<linux/semaphore.h> #include<linux/uaccess.h> #include<linux/fs.h> #include<linux/cdev.h> //……………………… Variable declaration………………………………………….. #define DEVICENAME “CHARACTER_DEVICE” #define BUFFER_SIZE 1024 static char device_buffer[BUFFER_SIZE]; struct cdev *mcdev; struct semaphore semaph; int MAJOR_NUMBER; int return_value; dev_t dev_number; //……………………..Function …………………………………………… static int _driver_device_open(struct inode *inode, struct file *filp) { if(down_interruptible(&semaph) != 0) { printk(KERN_ALERT “Device is already in use, unable to open lock\n”); return -1; } printk(KERN_INFO “Device is now opened :)\n”); return 0; } static ssize_t _driver_device_read(struct file *fp, char *buff, size_t length, loff_t *ppos) { int bytes_read; int max_bytes; int bytes_to_read; max_bytes = BUFFER_SIZE – *ppos; if(max_bytes > length) bytes_to_read = length; else bytes_to_read = max_bytes; if(bytes_to_read == 0) printk(KERN_INFO “At end\n”); bytes_read = bytes_to_read – copy_to_user(buff, device_buffer + *ppos, bytes_to_read); printk(KERN_INFO “Read Device%d\n”,bytes_read); *ppos += bytes_read; printk(KERN_INFO “Deviceis read\n”); return bytes_read; } static ssize_t _driver_device_write(struct file *fp, const char *buff, size_t len, loff_t *ppos) { int bytes_writen; int max_bytes; int bytes_to_write; max_bytes = BUFFER_SIZE – *ppos; if(max_bytes > len) bytes_to_write = len; else bytes_to_write = max_bytes; bytes_writen = bytes_to_write – copy_from_user(device_buffer + *ppos, buff, bytes_to_write); printk(KERN_INFO “Device has been written %d\n”,bytes_writen); *ppos += bytes_writen; printk(KERN_INFO “Device has been written\n”); return bytes_writen; } static loff_t device_lseek(struct file *file, loff_t offset, int orig) { loff_t new_position = 0; switch(orig) { case 0 : new_position = offset; //set break; case 1 : new_position = file->f_pos + offset; //current break; case 2 : new_position = BUFFER_SIZE – offset; //end break; } if(new_position > BUFFER_SIZE) new_position = BUFFER_SIZE; if(new_position < 0) new_position = 0; file->f_pos = new_position; return new_position; } static int _driver_device_close(struct inode *inode, struct file *filp) { printk(KERN_INFO “Device Driver is going to be closed\n”); up(&semaph); return return_value; } //………………… Device functionality provided by the driver…………………… struct file_operations fops = { .owner = THIS_MODULE, .open = _driver_device_open, .write = _driver_device_write, .read = _driver_device_read, .release = _driver_device_close, .llseek = device_lseek }; int chardevice_init(void) { printk(KERN_ALERT ” initializing the device….\n”); return_value = alloc_chrdev_region(&dev_number,0,1,DEVICENAME); if(return_value < 0) { printk(KERN_ALERT ” Failed 🙁 \n”); return return_value; } else printk(KERN_INFO “Number allocated succesful\n”); MAJOR_NUMBER = MAJOR(dev_number); printk(KERN_INFO “Number allocated to device is %d\n”,MAJOR_NUMBER); printk(KERN_INFO ” to use mknod /dev/%s c %d 0\n”,DEVICENAME, MAJOR_NUMBER); mcdev = cdev_alloc(); mcdev->ops = &fops; mcdev->owner = THIS_MODULE; return_value = cdev_add(mcdev,dev_number,1); if(return_value < 0) { printk(KERN_ALERT ” Adding Device to kernel is failed\n”); return return_value;} else printk(KERN_INFO ” Device addition to the kernel succesful\n”); sema_init(&semaph,1); return 0; } void chardevice_exit(void) { cdev_delelet(mcdev); printk(KERN_INFO ” mcdev has been removed from kernel\n”); unregister_chrdev_region(dev_number,1); printk(KERN_ALERT “Character Device driver is now exiting\n”); } MODULE_AUTHOR(“A”); MODULE_DESCRIPTION(“A Simple CHARACTER DEVICE DRIVER”); module_init(chardevice_init); module_exit(chardevice_exit);#include<string.h> #include<malloc.h> #include<stdio.h> #include<fcntl.h> #include <unistd.h> //…………………… Function Declaration …………………………………. int debug = 1; int fd = 0; int read_device() { int read_length = 0; char *data = (char *)malloc(1024 * sizeof(char)); ssize_t return_val; printf(“Enter the length of buffer you want to read\n”); scanf(“%d”,&read_length); if(debug) { printf(“Read length is %d\n”,read_length); } // resetting the buffer memset(data,0,sizeof(data)); data[0] = ‘ ‘; return_val = read(fd,data,read_length); printf(“DEVICE READ : %s\n”,data); if(return_val == -1) { printf(“reading failed\n”); } else { printf(“reading success\n”); } if(debug) { fflush(stdout); } free(data); return 0; } int write_device() { int length_write = 0; char *data = (char *)malloc(1024 * sizeof(char)); ssize_t return_val; printf(“Enter values to write into device\n”); scanf(” %[^\n]”,data); length_write = strlen(data); if(debug) { printf(“Length of data: %d\n”,length_write); } return_val = write(fd, data, length_write); if(return_val == -1) { printf(“Writting operation failed :(\n”); } else { printf(“Writting operation success :)\n”); } if(debug) { fflush(stdout); } free(data); return 0; } int lseek_device() { int seek_value = 0; int lseek_offset = 0; int counter = 0; counter++; printf(“counter: %d\n”,counter); printf(“Enter offset for seek\n”); scanf(“%d”,&lseek_offset); if(debug) { printf(“Offset is: %d\n”,lseek_offset); } printf(“………………GET…………………………\n”); printf(“1)SEEK_SET\n 2)SEEK_CURRENT\n 3)SEEK_END\n”); scanf(“%d”, &seek_value); printf(“seek: %d\n”, seek_value); switch(seek_value) { case 1: lseek(fd,lseek_offset,SEEK_SET); return 0; break; case 2: lseek(fd,lseek_offset,SEEK_CUR); return 0; break; case 3: lseek(fd,lseek_offset,SEEK_END); return 0; break; default : printf(“Wrong 🙁 Enter correct one\n”); break; } if(debug) { fflush(stdout); } return 0; } int lseek_read() { lseek_device(); read_device(); return 0; } int lseek_write() { lseek_device(); write_device(); return 0; } int main() { printf(“Welcome to UCSC Second Assignment \n”); int value = 0; if(access(DEVICE, F_OK) == -1) { printf(“module %s is not loaded :(\n”,DEVICE); return 0; } else printf(“module %s loaded, will be used\n”,DEVICE); while(1) { printf(“\t\tEnter 1) to write\n \ 2) to read\n \ 3) IOCTL read\n \ 4) IOCTL write\n”); scanf(“%d”,&value); switch(value) { case 1 :printf(“Writing…..\n”); fd = open(DEVICE, O_RDWR); write_device(); close(fd); break; case 2 :printf(“Read……\n”); fd = open(DEVICE, O_RDWR); read_device(); close(fd); break; case 3 :printf(“IOCTL read\n”); fd = open(DEVICE, O_RDWR); lseek_write(); close(fd); break; case 4 :printf(“IOCTL wirte\n”); fd = open(DEVICE, O_RDWR); lseek_read(); close(fd); break; default : printf(“Option is not corret 🙁 please enter right one\n”); break; } } return 0; }
