125 lines
3.2 KiB
C
125 lines
3.2 KiB
C
#include <linux/cdev.h> // for cdev
|
|
#include <linux/device.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h> // for kmalloc
|
|
|
|
#include "monitor_kernel.h"
|
|
|
|
#define DEVICE_NAME "variable_monitor"
|
|
|
|
// for character device
|
|
static dev_t dev_num;
|
|
static struct cdev *watch_cdev;
|
|
static struct class *watch_class;
|
|
|
|
struct my_device_data {
|
|
pid_t pid;
|
|
};
|
|
|
|
static int device_open(struct inode *inode, struct file *file) {
|
|
struct my_device_data *data;
|
|
printk(KERN_INFO "%s: with pid %d\n", __FUNCTION__, current->pid);
|
|
// save pid
|
|
data = kmalloc(sizeof(*data), GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
data->pid = current->pid;
|
|
file->private_data = data;
|
|
return 0;
|
|
}
|
|
|
|
static int device_release(struct inode *inode, struct file *file) {
|
|
// printk(KERN_INFO "%s\n", __FUNCTION__);
|
|
// load pid
|
|
struct my_device_data *data = file->private_data;
|
|
// clear watch with pid
|
|
clear_watch(data->pid);
|
|
kfree(data); // free data memory
|
|
return 0;
|
|
}
|
|
|
|
static long device_ioctl(struct file *file, unsigned int ioctl_num,
|
|
unsigned long ioctl_param) {
|
|
watch_arg warg;
|
|
// copy watch_arg
|
|
if (copy_from_user(&warg, (watch_arg *)ioctl_param, sizeof(warg))) {
|
|
return -EACCES;
|
|
}
|
|
printk(KERN_INFO "Watch_arg: task_id=%d, name=%s, ptr=%p, length_byte=%d, "
|
|
"time_ns=%ld, threshold=%lld\n",
|
|
warg.task_id, warg.name, warg.ptr, warg.length_byte, warg.time_ns,
|
|
warg.threshold);
|
|
// start watch variable
|
|
start_watch_variable(warg);
|
|
return 0;
|
|
}
|
|
|
|
static struct file_operations fops = {
|
|
.open = device_open,
|
|
.release = device_release,
|
|
.unlocked_ioctl = device_ioctl,
|
|
};
|
|
|
|
int init_module(void) {
|
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
|
if (alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME) < 0) {
|
|
printk(KERN_ALERT "Failed to register device number\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((watch_cdev = cdev_alloc()) == NULL) {
|
|
printk(KERN_ALERT "Failed to allocate cdev structure\n");
|
|
unregister_chrdev_region(dev_num, 1);
|
|
return -1;
|
|
}
|
|
|
|
cdev_init(watch_cdev, &fops);
|
|
if (cdev_add(watch_cdev, dev_num, 1) == -1) {
|
|
printk(KERN_ALERT "Failed to add cdev structure\n");
|
|
device_destroy(watch_class, dev_num);
|
|
class_destroy(watch_class);
|
|
unregister_chrdev_region(dev_num, 1);
|
|
return -1;
|
|
}
|
|
|
|
if ((watch_class = class_create(THIS_MODULE, DEVICE_NAME)) == NULL) {
|
|
printk(KERN_ALERT "Failed to create class\n");
|
|
cdev_del(watch_cdev);
|
|
unregister_chrdev_region(dev_num, 1);
|
|
return -1;
|
|
}
|
|
|
|
if (device_create(watch_class, NULL, dev_num, NULL, DEVICE_NAME) == NULL) {
|
|
printk(KERN_ALERT "Failed to create device\n");
|
|
class_destroy(watch_class);
|
|
cdev_del(watch_cdev);
|
|
unregister_chrdev_region(dev_num, 1);
|
|
return -1;
|
|
}
|
|
|
|
printk(KERN_INFO "dev number: %d\n", dev_num);
|
|
printk(KERN_INFO "path: /dev/%s %d\n", DEVICE_NAME, dev_num);
|
|
|
|
// orig_X | buffer
|
|
monitor_init();
|
|
|
|
return 0;
|
|
}
|
|
|
|
void cleanup_module(void) {
|
|
printk(KERN_INFO "%s\n", __FUNCTION__);
|
|
// clear all watch | free buffer
|
|
monitor_exit();
|
|
|
|
// unmount
|
|
device_destroy(watch_class, dev_num);
|
|
class_destroy(watch_class);
|
|
cdev_del(watch_cdev);
|
|
unregister_chrdev_region(dev_num, 1);
|
|
}
|
|
|
|
MODULE_LICENSE("GPL");
|