#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/stat.h>


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anton Khokhlov");
MODULE_DESCRIPTION("A simple message queue Linux module.");
MODULE_VERSION("0.01");

#define MESSAGE_SIZE    65536
#define QUEUE_SIZE      1024
#define PROC_ENTRY_FILENAME     "lkm_queue"

typedef struct message_item
{
        struct message_item *next;
        //int message_type;
        char *message;
        size_t message_size;
		int dirty;
} message_item;

struct message_queue
{
        message_item *front;
        message_item *back;
        size_t size;
} queue;


static ssize_t push_queue(struct file *filp, const char *buf, size_t count, loff_t *offp)
{
        if (count > MESSAGE_SIZE)
        {
                printk(KERN_WARNING "Message size is too big!\n");
                return 0;
        }

        if (queue.size >= QUEUE_SIZE)
        {
                printk(KERN_WARNING "Queue is full!\n");
                return 0;
        }

        if (queue.size == 0)
        {
                queue.back = queue.front = NULL;
        }

        char *msg = kmalloc(count * sizeof(char), GFP_KERNEL);

        if (copy_from_user(msg, (void*)buf, count))
        {
                printk(KERN_ERR "Error copy a block of data from user space!\n");
                return 1;
        }

        message_item *new_mes_item = kmalloc(sizeof(message_item), GFP_KERNEL);
        new_mes_item->next = NULL;
        new_mes_item->message = msg;
        new_mes_item->message_size = count;
		new_mes_item->dirty = 0;

        if (queue.size == 0)
        {
                queue.front = new_mes_item;
                queue.back = queue.front;
        }
        else
        {
                queue.back->next = new_mes_item;
                queue.back = new_mes_item;
        }
        queue.size++;

        return count;
}

static ssize_t pop_queue(struct file *filp, char *buf, size_t count, loff_t *offp)
{
		message_item *front_mes_item;
		int ret;

        if (queue.size == 0)
        {
                //const char *empstr = "Queue is empty!\n";
                //int emplen = strlen(empstr);
                //copy_to_user(buf, empstr, count);
                printk(KERN_WARNING "Queue is empty!\n");
                return 0/*emplen*/;
        }

        front_mes_item = queue.front;
		if (front_mes_item->dirty == 0) {
				ret = copy_to_user(buf, front_mes_item->message, front_mes_item->message_size);
				front_mes_item->dirty = 1;
				ret = front_mes_item->message_size;
		} else {
				queue.front = queue.front->next;

				kfree(front_mes_item);

				queue.size--;

				if (queue.size == 0)
				{
						queue.back = queue.front = NULL;
				}

				ret = 0;
		}

        return ret;
}


static const struct file_operations node_fops = {
   .owner = THIS_MODULE,
   .read  = pop_queue,
   .write  = push_queue
};


static int __init lkm_example_init(void)
{
        printk(KERN_INFO "Initializing message queue linux kernel module...\n");
        struct proc_dir_entry *own_proc_node;
        //own_proc_node = create_proc_entry(PROC_ENTRY_FILENAME, S_IFREG | S_IRUGO | S_IWUGO, NULL);
        own_proc_node = proc_create(PROC_ENTRY_FILENAME, 0777, NULL, &node_fops);
        if(own_proc_node == NULL)
        {
                printk( KERN_ERR "Can't create /proc/%s\n", PROC_ENTRY_FILENAME );
                return -ENOMEM;
        }
        //own_proc_node->uid = 0;
        //own_proc_node->gid = 0;
        //own_proc_node->proc_fops = &node_fops;
        queue.size = 0;
        printk(KERN_INFO "Message queue LKM initialized.\n");
        return 0;
}

static void __exit lkm_example_exit(void)
{
        printk(KERN_INFO "End of message queue linux kernel module...\n");
        remove_proc_entry(PROC_ENTRY_FILENAME, NULL);
}

module_init(lkm_example_init);
module_exit(lkm_example_exit);