file_ops.c

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>

#define MEM_IOCTL 1

#ifdef MEM_IOCTL
#include "mem_ioctl.h"
#endif

int main(int argc, char *argv[])
{
    char *file_name;
    int choice;
    int fd = -1;
    unsigned char data[128];
    int cnt;
    int i;
    off_t seek;
#ifdef MEM_IOCTL
    int size;
#endif

    if (argc != 2)
    {
        fprintf(stderr, "Usage: %s <device file name>\n", argv[0]);
        return 1;
    }
    else
    {
        file_name = argv[1];
    }

    do
    {
        printf("1: Open\n");
        printf("2: Read\n");
        printf("3: Write\n");
        printf("4: Close\n");
        printf("5: Seek\n");
#ifdef MEM_IOCTL
        printf("6: Store Size Set\n");
        printf("7: Store Size Get\n");
#endif
        printf("0: Exit\n");
        printf("Enter choice: ");
        scanf("%d", &choice);
        getchar();
        switch (choice)
        {
            case 1:
                fd = open(file_name, O_RDWR);
                if (fd == -1)
                {
                    perror("file_ops open");
                }
                break;
            case 2:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                printf("Bytes to read: ");
                scanf("%d", &cnt);
                getchar();
                cnt = read(fd, data, cnt);
                if (cnt == -1)
                {
                    perror("file_ops read");
                    break;
                }
                printf("Read %d bytes in %p: ", cnt, data);
                for (i = 0; i < cnt; i++)
                {
                    printf("%c (%02X) ", data[i], data[i]);
                }
                printf("\n");
                break;
            case 3:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                printf("Enter your string: ");
                scanf("%[^\n]", data);
                getchar();
                cnt = write(fd, data, strlen(data));
                if (cnt == -1)
                {
                    perror("file_ops write");
                    break;
                }
                printf("Wrote %d bytes from %p\n", cnt, data);
                break;
            case 4:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                close (fd);
                fd = -1;
                break;
            case 5:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                printf("Enter the seek from start of device file: ");
                scanf("%lld", &seek);
                getchar();
                if (lseek(fd, seek, SEEK_SET) == -1)
                {
                    perror("file_ops lseek");
                    break;
                }
                break;
#ifdef MEM_IOCTL
            case 6:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                printf("Enter the store size: ");
                scanf("%d", &size);
                getchar();
                if (ioctl(fd, MEM_SET_STORE_SIZE, size) == -1)
                {
                    perror("file_ops ioctl");
                    break;
                }
                break;
            case 7:
                if (fd == -1)
                {
                    printf("File not open\n");
                    break;
                }
                if (ioctl(fd, MEM_GET_STORE_SIZE, &size) == -1)
                {
                    perror("file_ops ioctl");
                    break;
                }
                printf("Current store size: %d\n", size);
                break;
#endif
        }
    } while (choice != 0);

    return 0;
}

mem_ioctl.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <asm/uaccess.h>

#include "mem_ioctl.h"

#define FIRST_MINOR 0
#define MINOR_CNT 1

static dev_t dev;
static struct cdev c_dev;
static int store_size;
static char *c;
static int store_len;

static int my_open(struct inode *i, struct file *f)
{
    return 0;
}
static int my_close(struct inode *i, struct file *f)
{
    return 0;
}
static ssize_t my_read(struct file *f, char __user *buf, size_t len, loff_t *off)
{
    int copy_len;

    if (*off < store_len)
    {
        copy_len = (len < (store_len - *off)) ? len : (store_len - *off);
        if (copy_to_user(buf, &c[*off], copy_len))
        {
            return -EFAULT;
        }
        (*off) += copy_len;
        return copy_len;
    }
    else
    {
        return 0;
    }
}
static ssize_t my_write(struct file *f, const char __user *buf, size_t len, loff_t *off)
{
    store_len = (len < store_size) ? len : store_size;
    if (copy_from_user(c, &buf[len - store_len], store_len))
    {
        store_len = 0;
        return -EFAULT;
    }
    return len;
}
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
static int my_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned long arg)
#else
static long my_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
#endif
{
    switch (cmd)
    {
        case MEM_SET_STORE_SIZE:
            printk(KERN_INFO "Store size requested (%d): %d\n", sizeof(arg), (int)arg);
            if (store_size)
            {
                store_len = 0;
                kfree(c);
            }
            store_size = arg;
            if ((c = kmalloc(store_size, GFP_KERNEL)) == NULL)
            {
                return -ENOMEM;
            }
            break;
        case MEM_GET_STORE_SIZE:
            if (copy_to_user((int *)arg, &store_size, sizeof(int)))
            {
                return -EFAULT;
            }
            break;
        default:
            return -EINVAL;
    }

    return 0;
}

static struct file_operations driver_fops =
{
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_close,
    .read = my_read,
    .write = my_write,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
    .ioctl = my_ioctl
#else
    .unlocked_ioctl = my_ioctl
#endif
};

static int __init mem_ioctl_init(void)
{
    int ret;

    if ((ret = alloc_chrdev_region(&dev, FIRST_MINOR, MINOR_CNT, "mem_ioctl")) < 0)
    {
        return ret;
    }

    cdev_init(&c_dev, &driver_fops);

    if ((ret = cdev_add(&c_dev, dev, MINOR_CNT)) < 0)
    {
        return ret;
    }
   
    return 0;
}

static void __exit mem_ioctl_exit(void)
{
    if (store_size)
    {
        store_len = 0;
        kfree(c);
        store_size = 0;
    }

    cdev_del(&c_dev);
    unregister_chrdev_region(dev, MINOR_CNT);
}

module_init(mem_ioctl_init);
module_exit(mem_ioctl_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anil Kumar Pugalia <anil@sysplay.in>");
MODULE_DESCRIPTION("Memory based Char Driver");