-
Notifications
You must be signed in to change notification settings - Fork 0
/
my_char_kernel_module_1.c
189 lines (165 loc) · 9.64 KB
/
my_char_kernel_module_1.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#include <linux/init.h> // Macros used to mark up functions e.g. __init __exit
#include <linux/module.h> // Core header for loading LKMs into the kernel
#include <linux/device.h> // Header to support the kernel Driver Model
#include <linux/kernel.h> // Contains types, macros, functions for the kernel
#include <linux/fs.h> // Header for the Linux file system support
#include <asm/uaccess.h> // Required for the copy to user function
#include <linux/slab.h> // Required for kmalloc()
#include <linux/mutex.h> /// Required for the mutex functionality
#define DEVICE_NAME "my_char_kernel_module_1" ///< The device will appear at /dev/my_char_kernel_module_1 using this value
#define CLASS_NAME "my_kmods" ///< The device class -- this is a character device driver
MODULE_LICENSE("GPL"); ///< The license type -- this affects available functionality
MODULE_AUTHOR("Lorenzo Maiorfi"); ///< The author -- visible when you use modinfo
MODULE_DESCRIPTION("A simple Linux char driver"); ///< The description -- see modinfo
MODULE_VERSION("1.0"); ///< A version number to inform users
static int majorNumber; ///< Stores the device number -- determined automatically
static char message[256] = {0}; ///< Memory for the string that is passed from userspace
static short size_of_message; ///< Used to remember the size of the string stored
static int numberOpens = 0; ///< Counts the number of times the device is opened
static struct class* kmClass = NULL; ///< The device-driver class struct pointer
static struct device* kmDevice = NULL; ///< The device-driver device struct pointer
// The prototype functions for the character driver -- must come before the struct definition
static int dev_open(struct inode *, struct file *);
static int dev_release(struct inode *, struct file *);
static ssize_t dev_read(struct file *, char *, size_t, loff_t *);
static ssize_t dev_write(struct file *, const char *, size_t, loff_t *);
static DEFINE_MUTEX(my_char_kernel_module_1_mutex); /// A macro that is used to declare a new mutex that is visible in this file
/// results in a semaphore variable my_char_kernel_module_1_mutex with value 1 (unlocked)
/// DEFINE_MUTEX_LOCKED() results in a variable with value 0 (locked)
/** @brief Devices are represented as file structure in the kernel. The file_operations structure from
* /linux/fs.h lists the callback functions that you wish to associated with your file operations
* using a C99 syntax structure. char devices usually implement open, read, write and release calls
*/
static struct file_operations fops =
{
.open = dev_open,
.read = dev_read,
.write = dev_write,
.release = dev_release,
};
/** @brief The LKM initialization function
* The static keyword restricts the visibility of the function to within this C file. The __init
* macro means that for a built-in driver (not a LKM) the function is only used at initialization
* time and that it can be discarded and its memory freed up after that point.
* @return returns 0 if successful
*/
static int __init my_char_kernel_module_1_init(void){
printk(KERN_INFO "EBBChar: Initializing the my_char_kernel_module_1 LKM\n");
// Try to dynamically allocate a major number for the device -- more difficult but worth it
majorNumber = register_chrdev(0, DEVICE_NAME, &fops);
if (majorNumber<0){
printk(KERN_ALERT "my_char_kernel_module_1 failed to register a major number\n");
return majorNumber;
}
printk(KERN_INFO "my_char_kernel_module_1: registered correctly with major number %d\n", majorNumber);
// Register the device class
kmClass = class_create(THIS_MODULE, CLASS_NAME);
if (IS_ERR(kmClass)){ // Check for error and clean up if there is
unregister_chrdev(majorNumber, DEVICE_NAME);
printk(KERN_ALERT "Failed to register device class\n");
return PTR_ERR(kmClass); // Correct way to return an error on a pointer
}
printk(KERN_INFO "my_char_kernel_module_1: device class registered correctly\n");
// Register the device driver
kmDevice = device_create(kmClass, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME);
if (IS_ERR(kmDevice)){ // Clean up if there is an error
class_destroy(kmClass); // Repeated code but the alternative is goto statements
unregister_chrdev(majorNumber, DEVICE_NAME);
printk(KERN_ALERT "Failed to create the device\n");
return PTR_ERR(kmDevice);
}
mutex_init(&my_char_kernel_module_1_mutex); /// Initialize the mutex lock dynamically at runtime
printk(KERN_INFO "my_char_kernel_module_1: device class created correctly\n"); // Made it! device was initialized
return 0;
}
/** @brief The LKM cleanup function
* Similar to the initialization function, it is static. The __exit macro notifies that if this
* code is used for a built-in driver (not a LKM) that this function is not required.
*/
static void __exit my_char_kernel_module_1_exit(void)
{
mutex_destroy(&my_char_kernel_module_1_mutex); /// destroy the dynamically-allocated mutex
device_destroy(kmClass, MKDEV(majorNumber, 0)); // remove the device
class_unregister(kmClass); // unregister the device class
class_destroy(kmClass); // remove the device class
unregister_chrdev(majorNumber, DEVICE_NAME); // unregister the major number
printk(KERN_INFO "my_char_kernel_module_1: Goodbye from the LKM!\n");
}
/** @brief The device open function that is called each time the device is opened
* This will only increment the numberOpens counter in this case.
* @param inodep A pointer to an inode object (defined in linux/fs.h)
* @param filep A pointer to a file object (defined in linux/fs.h)
*/
static int dev_open(struct inode *inodep, struct file *filep)
{
if(!mutex_trylock(&my_char_kernel_module_1_mutex)){ /// Try to acquire the mutex (i.e., put the lock on/down)
/// returns 1 if successful and 0 if there is contention
printk(KERN_ALERT "my_char_kernel_module_1: Device in use by another process");
return -EBUSY;
}
numberOpens++;
printk(KERN_INFO "my_char_kernel_module_1: Device has been opened %d time(s)\n", numberOpens);
return 0;
}
/** @brief The device release function that is called whenever the device is closed/released by
* the userspace program
* @param inodep A pointer to an inode object (defined in linux/fs.h)
* @param filep A pointer to a file object (defined in linux/fs.h)
*/
static int dev_release(struct inode *inodep, struct file *filep)
{
mutex_unlock(&my_char_kernel_module_1_mutex); /// Releases the mutex (i.e., the lock goes up)
printk(KERN_INFO "my_char_kernel_module_1: Device successfully closed\n");
return 0;
}
/** @brief This function is called whenever device is being read from user space i.e. data is
* being sent from the device to the user. In this case is uses the copy_to_user() function to
* send the buffer string to the user and captures any errors.
* @param filep A pointer to a file object (defined in linux/fs.h)
* @param buffer The pointer to the buffer to which this function writes the data
* @param len The length of the b
* @param offset The offset if required
*/
static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset){
int error_count = 0;
// copy_to_user has the format ( * to, *from, size) and returns 0 on success
error_count = copy_to_user(buffer, message, len > size_of_message ? size_of_message+1 : len);
if (error_count==0)
{ // if true then have success
printk(KERN_INFO "my_char_kernel_module_1: Sent '%s' (len=%zu) to the user\n", message, size_of_message);
message[0]='\0';
return (size_of_message=0); // clear the position to the start and return 0
}
else
{
printk(KERN_INFO "my_char_kernel_module_1: Failed to send %d characters to the user\n", error_count);
return -EFAULT; // Failed -- return a bad address message (i.e. -14)
}
}
/** @brief This function is called whenever the device is being written to from user space i.e.
* data is sent to the device from the user. The data is copied to the message[] array in this
* LKM using the sprintf() function along with the length of the string.
* @param filep A pointer to a file object
* @param buffer The buffer to that contains the string to write to the device
* @param len The length of the array of data that is being passed in the const char buffer
* @param offset The offset if required
*/
static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset){
int error_count = 0;
char* kbuffer;
kbuffer=kmalloc(len+1, GFP_KERNEL);
error_count = copy_from_user(kbuffer,buffer,len);
kbuffer[len]='\0';
printk(KERN_INFO "my_char_kernel_module_1: Received '%s' (len=%u) from user\n", kbuffer, len);
sprintf(message, "%s,%zu", kbuffer, len); // appending received string with its length
size_of_message = strlen(message); // store the length of the stored message
printk(KERN_INFO "my_char_kernel_module_1: Stored '%s' (len=%zu)\n", message, size_of_message);
kfree(kbuffer);
return len+1;
}
/** @brief A module must use the module_init() module_exit() macros from linux/init.h, which
* identify the initialization function at insertion time and the cleanup function (as
* listed above)
*/
module_init(my_char_kernel_module_1_init);
module_exit(my_char_kernel_module_1_exit);