#define MODULE
#define __KERNEL__ 
#define __NO_VERSION__

   // Needed by all modules
#include <linux/kernel.h> 
#include <linux/module.h> 
#include <linux/blkdev.h>
  // Needed for KERN_ALERT
#include <linux/sched.h>
#include <linux/fs.h>

//#define SCHED_YIELD 1
spinlock_t io_request_lock = SPIN_LOCK_UNLOCKED;
//typedef  struct buffer_head * pmy_b_end_io;
typedef void (*b_end_io1)(struct buffer_head *bh, int uptodate); /* I/O completion */

typedef struct {
struct buffer_head *bh;
void (*b_end_io)(struct buffer_head *bh, int uptodate); /* I/O completion */
//b_end_io1 b_end_io;

}my_b_end_io, * pmy_b_end_io;


asmlinkage void kti_b_end_io(struct buffer_head *bh, int uptodate)
{
int j;

printk("In kti_b_end_io \n ");
//struct buffer_head private;
pmy_b_end_io private;


private = bh->b_private;
bh->b_private = NULL;
bh->b_end_io = private->b_end_io;


if(uptodate){
for(j = 0; j < bh->b_size; j ++)
bh->b_data[j] ^= 0xaa;
}


bh->b_end_io(bh, uptodate);


kfree(private);
}


asmlinkage int (*original_make_request_fn)(request_queue_t * q, int rw,struct buffer_head *bh);


asmlinkage pmy_b_end_io kti_get_private(void)
{

#if 1
pmy_b_end_io ptr = NULL;
while (!ptr) {
ptr = (pmy_b_end_io)kmalloc(sizeof(my_b_end_io), GFP_NOIO);
if(!ptr) {
__set_current_state(TASK_RUNNING);
current->policy |= SCHED_NORMAL;
schedule();
}

}
#endif 

return ptr;
}


asmlinkage int kti_make_request_fn(request_queue_t * q, int rw,
struct buffer_head *bh)
{
int retcode;
int i;
pmy_b_end_io private;


switch (rw) {
case READA:
case READ:
	printk("In kti_make_request_fn read\n");
private = kti_get_private();
private->bh = bh;
private->b_end_io = bh->b_end_io;
bh->b_private = private;


bh->b_end_io = kti_b_end_io;


break;


case WRITE:
/*
	
	printk("In kti_make_request_fn write\n");
for(i = 0; i < bh->b_size; i ++)
bh->b_data[i] ^= 0xaa;
*/

break;
}


retcode = original_make_request_fn(q, rw, bh);
return retcode;
}


int init_module()
{


printk("In InterFloppy module start \n");
spin_lock_irq(&io_request_lock);
original_make_request_fn = blk_dev[2].request_queue.make_request_fn;
blk_dev[2].request_queue.make_request_fn = kti_make_request_fn;
spin_unlock_irq(&io_request_lock);
printk("In InterFloppy module end \n");

return 0;
}


void cleanup_module()
{
printk("Clean InterFloppy module start \n");
spin_lock_irq(&io_request_lock);
blk_dev[2].request_queue.make_request_fn = original_make_request_fn;
spin_unlock_irq(&io_request_lock);
printk("Clean InterFloppy module end \n");
}