I have to write a program in c or c++  for Device driver. It should open, read, write and excute. so far I have come up with these. if anybody know any links that can help me to write it or anybody know the actual program plz help me . it is very important to me. Thanks in advance. // Header files needed to load the driver #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #DEFINE BUFF_SIZE 16 MODULE_AUTHOR("OS student"); MODULE_DESCRIPTION("Box's assignment"); static int hari_open = 0; static char buff_size[BUFF_SIZE]; static int index = 0; static char *DEVICE_NAME = "hari"; static int major_no = 0; struct file_operations fops = { read:     hari_read, write:     hari_write, open:     hari_open, release:     hari_release }; int hari_open(struct inode *inode, struct file *file) {     if (hari_open) {         // Allowing only one process to open this device at a time.         return -EBUSY;     }     hari_open++;     // This will prevent rmmod to successfully remove     // this module when the device is in use.     try_module_get(THIS_MODULE);     // on open, reset the read index to 0     index = 0;     return 0; } int hari_release(struct inode *inode, struct file *file) {     hari_open--;     // releaseing this module so an admin may rmmod it.     module_put(THIS_MODULE);     return 0; } ssize_t hari_read(struct file *f, char *buffer, size_t length, loff_t *offset) {     int i;     int bytes_read = 0;     // This will just simply copy device buffer to the reader     for(i = 0; index < BUFF_SIZE && i < length; i++) {         buffer[i] = box_buff[index];         index++;         bytes_read++;     }     return bytes_read; } ssize_t hari_write(struct file *f, const char *buffer, size_t length, loff_t *offset) {     // This will just overwrite stuffs to the buffer     //  but the device will not reset the index everytime the 'hari_write'     //  is called, resulting in writing only at maximum of 16 bytes     //  on each open.     //  (a little bit different from     //  what I showed in the class where we can write 17 bytes     //  per one open -- with automatic two writes by system)     // Feel free to modify this to match the assignment requirement.     int bytes_written = 0;     int i;     for(i = 0; index < BUFF_SIZE && i < length; i++) {         box_buff[index++] = buffer[i];         bytes_written++;     }     if(bytes_written == 0) {         // We cannot write anything here ...         // meaning that the buffer is full :)         // return error         return -ENOSPC; // no space left         // NOTE: please see 'man errno' for more information         // you may change this to some other error as you see fit.     }     // if the device can write something, return the number of written bytes.     return bytes_written; } int init_module(void) {     int i;     printk(KERN_INFO "DEVICE: module initialization\n");     // initializing the device buffer     for (i = 0; i < BUFF_SIZE; i++) {         box_buff[i] = 'a';     }     // registering device ... if the major number 999 has been occupied,     //  the register_chrdev function will fail (see messages in     //  /var/log/kern.log for Ubuntu; please note that the kernel message     //  can be stored in different location, depending on the system     //  you're using)     major_no = register_chrdev(999, DEV_NAME, &fops);     if (major_no < 0) {         printk(KERN_ALERT "Registering virtual device failed with %d\n", major_no);         return major_no;     }     return 0; } void cleanup_module() {     printk(KERN_INFO "DEVICE: Unloaded\n");     // Finally, don't forget to unregister the device ... or you will not     //  be able to insmod your module again.     unregister_chrdev(999, DEV_NAME); }