uzy/415-device-driver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: uzy:a0de7de8026d60ee3a98e27f339b700824bab9a3
Branches Tags
uzy:main
..
compare: uzy:b1087b461d97b618b99d26cb188fbfd402ac6874
Branches Tags
uzy:main

No commits in common. "a0de7de8026d60ee3a98e27f339b700824bab9a3" and "b1087b461d97b618b99d26cb188fbfd402ac6874" have entirely different histories.
a0de7de802 ... b1087b461d

4 changed files with 66 additions and 278 deletions
Show Stats Expand all files Collapse all files

36
Module/helper.sh
View File

@ -1,36 +0,0 @@
#!/bin/bash
MODULE_NAME="tempMonitor"
DEVICE_NAME="/dev/temp_monitor"
echo "What would you like to do?"
echo "1. Install"
echo "2. Uninstall"
read -p "Enter option [1 or 2]: " option
case $option in
1)
echo "Installing the kernel module..."
make clean
make
sudo rmmod $MODULE_NAME 2>/dev/null
sudo insmod ${MODULE_NAME}.ko
MAJOR_NUMBER=$(sudo dmesg | grep "temp_monitor: Device initialized with major number" | tail -1 | awk '{print $NF}')
if [ -z "$MAJOR_NUMBER" ]; then
echo "Failed to get major number from dmesg. Aborting."
exit 1
fi
sudo mknod $DEVICE_NAME c $MAJOR_NUMBER 0
sudo chmod 666 $DEVICE_NAME
echo "Module installed and device file created successfully."
;;
2)
echo "Uninstalling the kernel module..."
sudo rmmod $MODULE_NAME
sudo rm -f $DEVICE_NAME
echo "Module and device file removed successfully."
;;
*)
echo "Invalid option."
;;
esac

151
Module/tempMonitor.c
View File

@ -1,140 +1,36 @@
/**************************************************************
* Class:: CSC-415-01 Fall 2024
* Name:: Uzair Hamed Mohammed
* Student ID:: 920142896
* GitHub-Name:: gamersekofy
* Project:: Assignment 6 - Device Driver
*
* File:: tempMonitor.c
*
* Description:: This is a complex kernel module that retrieves CPU temperature
*data from /sys/class/thermal/thermal_zone*\/temp
*
**************************************************************/
#include <linux/device.h>
#include <linux/err.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/ioctl.h>
#include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/random.h> #include <linux/kernel.h>
#include <linux/slab.h> #include <linux/init.h>
#include <linux/stat.h> #include <linux/fs.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#define DEVICE_NAME "temp_monitor" #define DEVICE_NAME "temp_monitor"
#define IOCTL_GET_TEMP _IOR('t', 1, int) #define IOCTL_GET_TEMP _IOR('t', 1, int)
// The CPU temperature will be accessed from thermal_zone0/temp static int temp = 0;
#define TEMP_SENSOR_PATH "/sys/class/thermal/thermal_zone0/temp"
#define BUF_LEN 100
static int major_number; static int major_number;
static struct class *temp_monitor_class = NULL; static struct class* temp_monitor_class = NULL;
static struct device *temp_monitor_device = NULL; static struct device* temp_monitor_device = NULL;
static char temp_unit[BUF_LEN] = "C"; // Default unit is Celsius
/* A similar flag exists in the test/user application. If it's detected that static int device_open(struct inode *inode, struct file *file) {
* the user is in a virtual machine, a smulated temperature is returned */ return 0;
static bool simulate_temp = false;
static int device_open(struct inode *inode, struct file *file) { return 0; }
static int device_release(struct inode *inode, struct file *file) { return 0; }
static ssize_t device_read(struct file *file, char __user *buffer, size_t len,
loff_t *offset) {
int temp = 0;
char temp_str[BUF_LEN];
struct file *f;
char *buf;
loff_t pos = 0;
bool is_simulated = false;
// Check if the temperature file exists. If it doesn't, simulate the
// temperature.
f = filp_open(TEMP_SENSOR_PATH, O_RDONLY, 0);
if (IS_ERR(f)) {
printk(KERN_INFO "temp_monitor: Temperature file not found\n");
is_simulated = true;
get_random_bytes(&temp, sizeof(temp));
// Simulate a temperature between 10 and 50 degrees
temp = (temp % 40) + 10;
} else {
buf = kmalloc(16, GFP_KERNEL);
if (!buf) {
filp_close(f, NULL);
return -ENOMEM;
}
// Read the temperature
kernel_read(f, buf, 16, &pos);
sscanf(buf, "%d", &temp);
// Convert to degrees Celsius
temp /= 1000;
filp_close(f, NULL);
kfree(buf);
}
// Convert to desired unit
if (strcmp(temp_unit, "F") == 0) {
temp = temp * 9 / 5 + 32;
// Convert to Fahrenheit
} else if (strcmp(temp_unit, "K") == 0) {
temp += 273;
// Convert to Kelvin
}
snprintf(temp_str, BUF_LEN, "%d %s%s\n", temp, temp_unit,
is_simulated ? " (simulated temperature)" : "");
// Copy the result to user-space
if (copy_to_user(buffer, temp_str, strlen(temp_str) + 1)) {
return -EFAULT;
}
return strlen(temp_str) + 1;
} }
static ssize_t device_write(struct file *file, const char __user *buffer, static int device_release(struct inode *inode, struct file *file) {
size_t len, loff_t *offset) { return 0;
char msg[BUF_LEN];
// Check if input too long
if (len > BUF_LEN - 1) {
return -EINVAL;
}
if (copy_from_user(msg, buffer, len)) {
return -EFAULT;
}
msg[len] = '\0';
if (strcmp(msg, "simulate") == 0) {
simulate_temp = true;
} else {
simulate_temp = false;
strncpy(temp_unit, msg, BUF_LEN - 1);
}
printk(KERN_INFO "temp_monitor: Write operation: %s\n", msg);
return len;
} }
static long device_ioctl(struct file *file, unsigned int cmd, static long device_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
unsigned long arg) {
switch (cmd) { switch (cmd) {
case IOCTL_GET_TEMP: { case IOCTL_GET_TEMP:
int temp = 0; // Simulate reading temperature
// Retrieve the temperature data temp = 50; // Example temperature
if (copy_to_user((int *)arg, &temp, sizeof(temp))) { if (copy_to_user((int *)arg, &temp, sizeof(temp))) {
return -EACCES; return -EACCES;
} }
break; break;
}
default: default:
return -EINVAL; return -EINVAL;
} }
@ -144,8 +40,6 @@ static long device_ioctl(struct file *file, unsigned int cmd,
static struct file_operations fops = { static struct file_operations fops = {
.open = device_open, .open = device_open,
.release = device_release, .release = device_release,
.read = device_read,
.write = device_write,
.unlocked_ioctl = device_ioctl, .unlocked_ioctl = device_ioctl,
}; };
@ -155,22 +49,20 @@ static int __init temp_monitor_init(void) {
printk(KERN_ALERT "temp_monitor: Failed to register a major number\n"); printk(KERN_ALERT "temp_monitor: Failed to register a major number\n");
return major_number; return major_number;
} }
temp_monitor_class = class_create(THIS_MODULE->name); // Updated this line temp_monitor_class = class_create(DEVICE_NAME);
if (IS_ERR(temp_monitor_class)) { if (IS_ERR(temp_monitor_class)) {
unregister_chrdev(major_number, DEVICE_NAME); unregister_chrdev(major_number, DEVICE_NAME);
printk(KERN_ALERT "temp_monitor: Failed to register device class\n"); printk(KERN_ALERT "temp_monitor: Failed to register device class\n");
return PTR_ERR(temp_monitor_class); return PTR_ERR(temp_monitor_class);
} }
temp_monitor_device = device_create( temp_monitor_device = device_create(temp_monitor_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
temp_monitor_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
if (IS_ERR(temp_monitor_device)) { if (IS_ERR(temp_monitor_device)) {
class_destroy(temp_monitor_class); class_destroy(temp_monitor_class);
unregister_chrdev(major_number, DEVICE_NAME); unregister_chrdev(major_number, DEVICE_NAME);
printk(KERN_ALERT "temp_monitor: Failed to create the device\n"); printk(KERN_ALERT "temp_monitor: Failed to create the device\n");
return PTR_ERR(temp_monitor_device); return PTR_ERR(temp_monitor_device);
} }
printk(KERN_INFO "temp_monitor: Device initialized with major number %d\n", printk(KERN_INFO "temp_monitor: Device initialized with major number %d\n", major_number); // Added this line
major_number);
return 0; return 0;
} }
@ -186,6 +78,5 @@ module_init(temp_monitor_init);
module_exit(temp_monitor_exit); module_exit(temp_monitor_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Uzair Hamed Mohammed"); MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION( MODULE_DESCRIPTION("A CPU Temperature Monitoring Kernel Module");
"An Awesome and Super Complex CPU Temperature Monitoring Kernel Module");

BIN
Mohammed_UzairHamed_HW6_Writeup_2.pdf
View File

Binary file not shown.

79
Test/Mohammed_UzairHamed_HW6_main.c
View File

@ -1,91 +1,24 @@
/**************************************************************
* Class:: CSC-415-01 Fall 2024
* Name:: Uzair Hamed Mohammed
* Student ID:: 920142896
* GitHub-Name:: gamersekofy
* Project:: Assignment 6 - Device Driver
*
* File:: Mohammed_UzairHamed_HW6_main.c
*
* Description:: This file contains a very easy to use and application that
reads and writes data
* to the tempMonitor kernel module.
**************************************************************/
#include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h> #include <unistd.h>
#include <sys/ioctl.h>
#define IOCTL_GET_TEMP _IOR('t', 1, int) #define IOCTL_GET_TEMP _IOR('t', 1, int)
#define GREEN "\033[1;32m"
#define RESET "\033[0m"
void read_temp(int fd, const char *unit) {
char buffer[128];
ssize_t bytes_read;
/* Declare this variable because /sys/class/thermal/thermal_zonex/ isn't
available on virtual machines. In case of a virtual machine, set this flag
that will make the kernel module return a simulated temperature. */
int is_simulated = 0;
// Writing the desired unit or "simulate" command to the device
ssize_t bytes_written = write(fd, unit, strlen(unit));
if (bytes_written < 0) {
return;
}
// Reading the temperature
bytes_read = read(fd, buffer, sizeof(buffer));
if (bytes_read < 0) {
return;
} else {
buffer[bytes_read] = '\0';
// Check if the temperature is simulated. If it is, set flag here.
if (strstr(buffer, "(simulated temperature)") != NULL) {
is_simulated = 1;
}
if (is_simulated) {
printf(GREEN "CPU Temperature\n--- -----------\n" RESET "%s\n", buffer);
} else {
printf(GREEN "CPU Temperature\n--- -----------\n" RESET "%s\n", buffer);
}
}
}
int main() { int main() {
int fd; int fd, temp;
char choice;
// Access kernel module here
fd = open("/dev/temp_monitor", O_RDWR); fd = open("/dev/temp_monitor", O_RDWR);
if (fd < 0) { if (fd < 0) {
perror("Failed to open the device"); perror("Failed to open the device");
return -1; return -1;
} }
// Ask the user for the preferred temperature unit if (ioctl(fd, IOCTL_GET_TEMP, &temp) == -1) {
printf("Choose temperature unit (C/F): "); perror("Failed to get temperature");
scanf(" %c", &choice);
if (choice == 'C' || choice == 'c') {
// Request the kernel module provide temperature in Celsius
read_temp(fd, "C");
} else if (choice == 'F' || choice == 'f') {
// Request the kernel module provide the temperature in Fahrenheit
read_temp(fd, "F");
} else {
printf("Invalid choice. Please choose 'C' or 'F'.\n");
close(fd); close(fd);
return -1; return -1;
} }
printf("Current temperature: %d\n", temp);
close(fd); close(fd);
return 0; return 0;
} }