lkmpg/examples/chardev2.c

222 lines
6.4 KiB
C
Raw Normal View History

2021-07-22 06:35:24 +08:00
/*
* chardev2.c - Create an input/output character device
2021-07-22 06:35:24 +08:00
*/
#include <linux/cdev.h>
2021-07-22 06:35:24 +08:00
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
2021-07-22 06:35:24 +08:00
#include <linux/irq.h>
#include <linux/kernel.h> /* We are doing kernel work */
#include <linux/module.h> /* Specifically, a module */
2021-07-22 06:35:24 +08:00
#include <linux/poll.h>
#include "chardev.h"
#define SUCCESS 0
#define DEVICE_NAME "char_dev"
#define BUF_LEN 80
2021-08-12 15:43:38 +08:00
/* Is the device open right now? Used to prevent concurrent access into
* the same device
2021-07-22 06:35:24 +08:00
*/
static int open_device_cnt = 0;
2021-07-22 06:35:24 +08:00
/* The message the device will give when asked */
static char message[BUF_LEN];
2021-07-22 06:35:24 +08:00
/* How far did the process reading the message get? Useful if the message
* is larger than the size of the buffer we get to fill in device_read.
2021-07-22 06:35:24 +08:00
*/
static char *message_ptr;
2021-07-22 06:35:24 +08:00
static struct class *cls;
/* This is called whenever a process attempts to open the device file */
2021-07-22 06:35:24 +08:00
static int device_open(struct inode *inode, struct file *file)
{
pr_info("device_open(%p)\n", file);
2021-07-22 06:35:24 +08:00
/* We don't want to talk to two processes at the same time. */
if (open_device_cnt)
2021-07-22 06:35:24 +08:00
return -EBUSY;
open_device_cnt++;
/* Initialize the message */
message_ptr = message;
2021-07-22 06:35:24 +08:00
try_module_get(THIS_MODULE);
return SUCCESS;
}
static int device_release(struct inode *inode, struct file *file)
{
pr_info("device_release(%p,%p)\n", inode, file);
/* We're now ready for our next caller */
open_device_cnt--;
2021-07-22 06:35:24 +08:00
module_put(THIS_MODULE);
return SUCCESS;
}
/* This function is called whenever a process which has already opened the
2021-07-22 06:35:24 +08:00
* device file attempts to read from it.
*/
static ssize_t device_read(struct file *file, /* see include/linux/fs.h */
char __user *buffer, /* buffer to be filled */
size_t length, /* length of the buffer */
loff_t *offset)
2021-07-22 06:35:24 +08:00
{
/* Number of bytes actually written to the buffer */
2021-07-22 06:35:24 +08:00
int bytes_read = 0;
2021-07-22 10:55:14 +08:00
pr_info("device_read(%p,%p,%ld)\n", file, buffer, length);
2021-07-22 06:35:24 +08:00
/* If at the end of message, return 0 (which signifies end of file). */
if (*message_ptr == 0)
2021-07-22 06:35:24 +08:00
return 0;
/* Actually put the data into the buffer */
while (length && *message_ptr) {
/* Because the buffer is in the user data segment, not the kernel
2021-08-08 01:50:42 +08:00
* data segment, assignment would not work. Instead, we have to
* use put_user which copies data from the kernel data segment to
* the user data segment.
*/
put_user(*(message_ptr++), buffer++);
length--;
bytes_read++;
}
2021-07-22 06:35:24 +08:00
2021-07-22 10:55:14 +08:00
pr_info("Read %d bytes, %ld left\n", bytes_read, length);
2021-07-22 06:35:24 +08:00
/* Read functions are supposed to return the number of bytes actually
* inserted into the buffer.
2021-07-22 06:35:24 +08:00
*/
return bytes_read;
}
/* called when somebody tries to write into our device file. */
static ssize_t device_write(struct file *file, const char __user *buffer,
size_t length, loff_t *offset)
2021-07-22 06:35:24 +08:00
{
int i;
2021-07-22 10:55:14 +08:00
pr_info("device_write(%p,%s,%ld)", file, buffer, length);
2021-07-22 06:35:24 +08:00
for (i = 0; i < length && i < BUF_LEN; i++)
get_user(message[i], buffer + i);
2021-07-22 06:35:24 +08:00
message_ptr = message;
2021-07-22 06:35:24 +08:00
/* Again, return the number of input characters used. */
2021-07-22 06:35:24 +08:00
return i;
}
/* This function is called whenever a process tries to do an ioctl on our
2021-07-22 06:35:24 +08:00
* device file. We get two extra parameters (additional to the inode and file
* structures, which all device functions get): the number of the ioctl called
* and the parameter given to the ioctl function.
*
* If the ioctl is write or read/write (meaning output is returned to the
* calling process), the ioctl call returns the output of this function.
*/
long device_ioctl(struct file *file, /* ditto */
unsigned int ioctl_num, /* number and param for ioctl */
2021-07-22 06:35:24 +08:00
unsigned long ioctl_param)
{
int i;
char *temp;
char ch;
/* Switch according to the ioctl called */
2021-07-22 06:35:24 +08:00
switch (ioctl_num) {
case IOCTL_SET_MSG:
/* Receive a pointer to a message (in user space) and set that to
2021-08-08 01:50:42 +08:00
* be the device's message. Get the parameter given to ioctl by
* the process.
2021-07-22 06:35:24 +08:00
*/
temp = (char *)ioctl_param;
2021-07-22 06:35:24 +08:00
/* Find the length of the message */
get_user(ch, temp);
for (i = 0; ch && i < BUF_LEN; i++, temp++)
get_user(ch, temp);
2021-07-22 06:35:24 +08:00
device_write(file, (char *)ioctl_param, i, 0);
break;
2021-07-22 06:35:24 +08:00
case IOCTL_GET_MSG:
/* Give the current message to the calling process - the parameter
2021-08-08 01:50:42 +08:00
* we got is a pointer, fill it.
2021-07-22 06:35:24 +08:00
*/
i = device_read(file, (char *)ioctl_param, 99, 0);
2021-07-22 06:35:24 +08:00
/* Put a zero at the end of the buffer, so it will be properly
2021-08-08 01:50:42 +08:00
* terminated.
2021-07-22 06:35:24 +08:00
*/
put_user('\0', (char *)ioctl_param + i);
2021-07-22 06:35:24 +08:00
break;
case IOCTL_GET_NTH_BYTE:
/* This ioctl is both input (ioctl_param) and output (the return
2021-08-08 01:50:42 +08:00
* value of this function).
2021-07-22 06:35:24 +08:00
*/
return message[ioctl_param];
2021-07-22 06:35:24 +08:00
break;
}
return SUCCESS;
}
/* Module Declarations */
/* This structure will hold the functions to be called when a process does
* something to the device we created. Since a pointer to this structure
* is kept in the devices table, it can't be local to init_module. NULL is
* for unimplemented functions.
2021-07-22 06:35:24 +08:00
*/
struct file_operations fops = {
.read = device_read,
.write = device_write,
.unlocked_ioctl = device_ioctl,
.open = device_open,
.release = device_release, /* a.k.a. close */
2021-07-22 06:35:24 +08:00
};
/* Initialize the module - Register the character device */
static int __init chardev2_init(void)
2021-07-22 06:35:24 +08:00
{
/* Register the character device (atleast try) */
int ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &fops);
2021-07-22 06:35:24 +08:00
/* Negative values signify an error */
2021-07-22 06:35:24 +08:00
if (ret_val < 0) {
pr_alert("%s failed with %d\n",
"Sorry, registering the character device ", ret_val);
return ret_val;
}
cls = class_create(THIS_MODULE, DEVICE_FILE_NAME);
device_create(cls, NULL, MKDEV(MAJOR_NUM, 0), NULL, DEVICE_FILE_NAME);
2021-07-22 06:35:24 +08:00
pr_info("Device created on /dev/%s\n", DEVICE_FILE_NAME);
return 0;
}
/* Cleanup - unregister the appropriate file from /proc */
static void __exit chardev2_exit(void)
2021-07-22 06:35:24 +08:00
{
device_destroy(cls, MKDEV(MAJOR_NUM, 0));
2021-07-22 06:35:24 +08:00
class_destroy(cls);
/* Unregister the device */
unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
2021-07-22 06:35:24 +08:00
}
module_init(chardev2_init);
module_exit(chardev2_exit);
2021-07-22 06:35:24 +08:00
MODULE_LICENSE("GPL");