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

Added comments

Browse Source
This commit is contained in:
uzy lol 2024-12-08 18:49:17 -08:00
parent 8ee6467330
commit caebcff431
2 changed files with 221 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
Module/tempMonitor.c
View File

@ -1,36 +1,51 @@
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/ioctl.h>
/**************************************************************
* 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/random.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/fs.h>
#include <linux/err.h>
#include <linux/random.h>
#include <linux/uaccess.h>
#define DEVICE_NAME "temp_monitor"
#define IOCTL_GET_TEMP _IOR('t', 1, int)
// The CPU temperature will be accessed from thermal_zone0/temp
#define TEMP_SENSOR_PATH "/sys/class/thermal/thermal_zone0/temp"
#define BUF_LEN 100
static int major_number;
static struct class* temp_monitor_class = NULL;
static struct device* temp_monitor_device = NULL;
static struct class *temp_monitor_class = 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
* the user is in a virtual machine, a smulated temperature is returned */
static bool simulate_temp = false;
static int device_open(struct inode *inode, struct file *file) {
return 0;
}
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 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) {
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;
@ -38,13 +53,15 @@ static ssize_t device_read(struct file *file, char __user *buffer, size_t len, l
loff_t pos = 0;
bool is_simulated = false;
// Check if the temperature file exists
// 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));
temp = (temp % 40) + 10; // Simulate a temperature between 10 and 50 degrees
// Simulate a temperature between 10 and 50 degrees
temp = (temp % 40) + 10;
} else {
buf = kmalloc(16, GFP_KERNEL);
if (!buf) {
@ -55,19 +72,23 @@ static ssize_t device_read(struct file *file, char __user *buffer, size_t len, l
// Read the temperature
kernel_read(f, buf, 16, &pos);
sscanf(buf, "%d", &temp);
temp /= 1000; // Convert to degrees Celsius
// 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
temp = temp * 9 / 5 + 32;
// Convert to Fahrenheit
} else if (strcmp(temp_unit, "K") == 0) {
temp += 273; // Convert to Kelvin
temp += 273;
// Convert to Kelvin
}
snprintf(temp_str, BUF_LEN, "%d %s%s\n", temp, temp_unit, is_simulated ? " (simulated temperature)" : "");
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)) {
@ -77,17 +98,19 @@ static ssize_t device_read(struct file *file, char __user *buffer, size_t len, l
return strlen(temp_str) + 1;
}
static ssize_t device_write(struct file *file, const char __user *buffer, size_t len, loff_t *offset) {
static ssize_t device_write(struct file *file, const char __user *buffer,
size_t len, loff_t *offset) {
char msg[BUF_LEN];
// Check if input too long
if (len > BUF_LEN - 1) {
return -EINVAL; // Input too long
return -EINVAL;
}
if (copy_from_user(msg, buffer, len)) {
return -EFAULT;
}
msg[len] = '\0'; // Null-terminate the string
msg[len] = '\0';
if (strcmp(msg, "simulate") == 0) {
simulate_temp = true;
@ -101,11 +124,12 @@ static ssize_t device_write(struct file *file, const char __user *buffer, size_t
return len;
}
static long device_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
static long device_ioctl(struct file *file, unsigned int cmd,
unsigned long arg) {
switch (cmd) {
case IOCTL_GET_TEMP: {
int temp = 0;
// Retrieve the temperature data here
// Retrieve the temperature data
if (copy_to_user((int *)arg, &temp, sizeof(temp))) {
return -EACCES;
}
@ -137,14 +161,16 @@ static int __init temp_monitor_init(void) {
printk(KERN_ALERT "temp_monitor: Failed to register device class\n");
return PTR_ERR(temp_monitor_class);
}
temp_monitor_device = device_create(temp_monitor_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
temp_monitor_device = device_create(
temp_monitor_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
if (IS_ERR(temp_monitor_device)) {
class_destroy(temp_monitor_class);
unregister_chrdev(major_number, DEVICE_NAME);
printk(KERN_ALERT "temp_monitor: Failed to create the device\n");
return PTR_ERR(temp_monitor_device);
}
printk(KERN_INFO "temp_monitor: Device initialized with major number %d\n", major_number);
printk(KERN_INFO "temp_monitor: Device initialized with major number %d\n",
major_number);
return 0;
}
@ -159,6 +185,6 @@ static void __exit temp_monitor_exit(void) {
module_init(temp_monitor_init);
module_exit(temp_monitor_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A CPU Temperature Monitoring Kernel Module");
MODULE_AUTHOR("Uzair Hamed Mohammed");
MODULE_DESCRIPTION(
"An Awesome and Super Complex CPU Temperature Monitoring Kernel Module");

38
Test/Mohammed_UzairHamed_HW6_main.c
View File

@ -1,8 +1,23 @@
#include <stdio.h>
/**************************************************************
* 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 <unistd.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#define IOCTL_GET_TEMP _IOR('t', 1, int)
@ -12,22 +27,26 @@
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; // Exit the function if writing fails
return;
}
// Reading the temperature
bytes_read = read(fd, buffer, sizeof(buffer));
if (bytes_read < 0) {
return; // Exit the function if reading fails
return;
} else {
buffer[bytes_read] = '\0'; // Null-terminate the string
buffer[bytes_read] = '\0';
// Check if the temperature is simulated
// Check if the temperature is simulated. If it is, set flag here.
if (strstr(buffer, "(simulated temperature)") != NULL) {
is_simulated = 1;
}
@ -44,6 +63,7 @@ int main() {
int fd;
char choice;
// Access kernel module here
fd = open("/dev/temp_monitor", O_RDWR);
if (fd < 0) {
perror("Failed to open the device");
@ -55,10 +75,10 @@ int main() {
scanf(" %c", &choice);
if (choice == 'C' || choice == 'c') {
// Requesting the temperature in Celsius
// Request the kernel module provide temperature in Celsius
read_temp(fd, "C");
} else if (choice == 'F' || choice == 'f') {
// Requesting the temperature in Fahrenheit
// Request the kernel module provide the temperature in Fahrenheit
read_temp(fd, "F");
} else {
printf("Invalid choice. Please choose 'C' or 'F'.\n");