/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <asm/uaccess.h>
#include <linux/config.h>
#include <linux/slab.h>
#include <asm/fcntl.h>
#include <asm/ioctl.h>
#include <linux/devfs_fs_kernel.h>
#include <asm/semaphore.h>
#include <asm/errno.h>
#include <linux/wait.h>
#include <asm/smplock.h>

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
static DECLARE_COMPLETION(dummy_evt_dead);
static unsigned int dummy_thread_init_done = 0;

struct _dummy_thread {
    struct task_struct *p_current;
    int dummy_thread_pid;
    struct semaphore dummy_sema;
    char Name[80];
};


/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
static int dummy_thread(void *context) {
    struct _dummy_thread *dummy = (struct _dummy_thread *)context;
	lock_kernel();
	daemonize();
	unlock_kernel();
	strcpy(current->comm, dummy->Name);
    dummy->p_current = current;
    down_interruptible(&dummy->dummy_sema);
    complete_and_exit(&dummy_evt_dead, 0);
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
struct _dummy_thread *dummy_create_thread(char *name) {
    struct _dummy_thread *dummy;

    dummy = kmalloc(sizeof(struct _dummy_thread), GFP_ATOMIC);
    if(dummy == NULL)
        return NULL;

    dummy->p_current = NULL;
    sema_init(&dummy->dummy_sema, 0);
    strcpy(dummy->Name, name);

	dummy->dummy_thread_pid = kernel_thread(dummy_thread, dummy, CLONE_SIGHAND);

    dummy_thread_init_done = 1;
    return dummy;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void dummy_delete_thread(struct _dummy_thread *dummy) {
    int stat;
    if(dummy == NULL)
        return;

    up(&dummy->dummy_sema);
    stat = kill_proc(dummy->dummy_thread_pid, SIGTERM, 1);
    if(!stat) {
        wait_for_completion(&dummy_evt_dead);
    }

    kfree(dummy);
    return;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void dummy_update_one_process(struct _dummy_thread *dummy, unsigned int entry) {
    void update_one_process(struct task_struct *p, unsigned long user, unsigned long system, int cpu);
    if(entry) {
        current->real_times_update_only = 1;
	    update_one_process(current, 0, 1, current->processor);
        return;
    }
    if(dummy == NULL)
        return;

    dummy->p_current->real_times_update_only = 1;
    update_one_process(dummy->p_current, 0, 1, dummy->p_current->processor);
    return;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
struct _dummy_threads {
    char *Name;
    struct _dummy_thread *handle;
};
static struct _dummy_threads dummy_threads_init[] = {
    { "copy_to_user", NULL },
    { "copy_from_user", NULL },
    { NULL, NULL }
};

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void dummy_update_special_process(struct _dummy_thread *dummy, unsigned int entry) {
    static signed int last_time = 0;
    signed int this_time = (signed int)get_cycles();
    if(dummy == NULL || dummy->p_current == NULL)
        return;
    if(entry) {
        dummy->p_current->real_times.tms_utime += (unsigned long long)(this_time - last_time);
    } else {
        dummy->p_current->real_times.tms_stime += (unsigned long long)(this_time - last_time);
    }
    last_time = this_time;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void dummy_thread_copy_from_user(unsigned int entry) {
    if(dummy_thread_init_done == 0)
        return;

    if(dummy_threads_init[1].handle == NULL) {
        dummy_threads_init[1].handle = dummy_create_thread(dummy_threads_init[1].Name);
    }
    dummy_update_special_process(dummy_threads_init[1].handle, entry);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void dummy_thread_copy_to_user(unsigned int entry) {
    if(dummy_thread_init_done == 0)
        return;

    if(dummy_threads_init[0].handle == NULL) {
        dummy_threads_init[0].handle = dummy_create_thread(dummy_threads_init[0].Name);
    }
    dummy_update_special_process(dummy_threads_init[0].handle, entry);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
EXPORT_SYMBOL(dummy_thread_copy_from_user);
EXPORT_SYMBOL(dummy_thread_copy_to_user);
EXPORT_SYMBOL(dummy_create_thread);
EXPORT_SYMBOL(dummy_delete_thread);
EXPORT_SYMBOL(dummy_update_one_process);
EXPORT_SYMBOL(dummy_update_special_process);