#include <linux/kernel.h> 
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/config.h>
#include <linux/percpu.h>
#include <linux/pid.h>


MODULE_DESCRIPTION("SignalHandler kernel module");

MODULE_AUTHOR("zhaofeng");

MODULE_LICENSE("GPL");


#define MESSAGE_LENGTH 1024
#define SIGNALNUM 32
char message[MESSAGE_LENGTH];	

static struct proc_dir_entry *Our_Proc_File;
#define PROC_ENTRY_FILENAME "psinfo"


void getProcessSignalInfo(char * buf,int pid)
{
	char tmp[50];
	int i;
	struct task_struct * currentTask = find_task_by_pid(pid);
	if(currentTask == NULL)
		return;
	memset(tmp,0,sizeof(tmp));
	if(currentTask->sighand != NULL)
	{
		sprintf(tmp,"%lu\n",currentTask->blocked);
		strcat(buf,tmp);
		for(i = 1;i < SIGNALNUM;i++)
		{
			switch((int)currentTask->sighand->action[i].sa.sa_handler)
			{
				case 0:sprintf(tmp,"%d 0\n",i);
				strcat(buf,tmp);
				break;
				case 1:sprintf(tmp,"%d 1\n",i);
				strcat(buf,tmp);
				break;
				default:sprintf(tmp,"%d 0x%x\n",i,currentTask->sighand->action[i].sa.sa_handler);
				strcat(buf,tmp);
			}
		}
	}				
}


static ssize_t module_output(struct file *filp, char *buffer, size_t length,loff_t * offset)
{	
	int i =0 ;
	
	int processPid = -1;
	
	if(strlen(message) == 0)
		return 0;

	sscanf(message,"%d",&processPid);
	if(processPid < 0 )
		return 0;

	memset(message,0,MESSAGE_LENGTH);
	getProcessSignalInfo(message,processPid);
	
	for (i=0; i < length && message[i]; i++)
		put_user(message[i], buffer + i);

	memset(message,0,sizeof(message));

	
	return i;
}


static ssize_t module_input(struct file *filp, const char *buff, size_t len, loff_t * off)
{
	int i;
	memset(message,0,sizeof(message));
	for (i = 0; i < MESSAGE_LENGTH - 1 && i < len; i++)
		get_user(message[i], buff + i);
	message[i] = '\0'; 
	return i;

	
}

static int module_permission(struct inode *inode, int op, struct nameidata *foo)
{

	if (op == 4 || (op == 2 && current->euid == 0))
		return 0;

	return -EACCES;
}

int module_open(struct inode *inode, struct file *file)
{
	try_module_get(THIS_MODULE);
	return 0;
}

int module_close(struct inode *inode, struct file *file)
{
	module_put(THIS_MODULE);
	return 0; /* success */
}
static struct file_operations File_Ops_4_Our_Proc_File = {
	.read = module_output,
	.write = module_input,
	.open = module_open,
	.release = module_close,
};



static struct inode_operations Inode_Ops_4_Our_Proc_File = {
	.permission = module_permission, /* check for permissions */
};


static int communicationmodule_init_module(void)
{
	int rv = 0;
	Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
	Our_Proc_File->owner = THIS_MODULE;
	Our_Proc_File->proc_fops = &File_Ops_4_Our_Proc_File;
	Our_Proc_File->proc_iops = &Inode_Ops_4_Our_Proc_File;
	
	Our_Proc_File->mode = S_IFREG | S_IRUGO | S_IWUSR;
	Our_Proc_File->uid = 0;
	Our_Proc_File->gid = 0;
	Our_Proc_File->size = 80;
	if (Our_Proc_File == NULL) 
	{
		rv = -ENOMEM;
		remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
		printk(KERN_INFO "Error: Could not initialize /proc/test\n");
	}
	return rv;
}

static void communicationmodule_exit_module(void)
{
	remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
}

module_init(communicationmodule_init_module);
module_exit(communicationmodule_exit_module);