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);
}