캐릭터 드라이버 작성 — file_operations·cdev·register_chrdev

1
static struct file_operations fops = {
2
    .owner   = THIS_MODULE,
3
    .open    = my_open,
4
    .release = my_release,
5
    .read    = my_read,
6
    .write   = my_write,
7
    .unlocked_ioctl = my_ioctl,
8
};

1
#include <linux/module.h>
2
#include <linux/fs.h>
3
#include <linux/cdev.h>
4
#include <linux/uaccess.h>
5
#include <linux/device.h>
6

7
#define DEV_NAME "mychar"
8
static dev_t devno;
9
static struct cdev mycdev;
10
static struct class *mycls;
11

12
static ssize_t my_read(struct file *f, char __user *buf, size_t cnt, loff_t *off) {
13
    const char msg[] = "hello\n";
14
    size_t len = strlen(msg);
15
    if (*off >= len) return 0;
16
    if (cnt > len - *off) cnt = len - *off;
17
    if (copy_to_user(buf, msg + *off, cnt)) return -EFAULT;
18
    *off += cnt;
19
    return cnt;
20
}
21

22
static struct file_operations fops = {
23
    .owner = THIS_MODULE,
24
    .read  = my_read,
25
};
26

27
static int __init mod_init(void) {
28
    alloc_chrdev_region(&devno, 0, 1, DEV_NAME);
29
    cdev_init(&mycdev, &fops);
30
    mycdev.owner = THIS_MODULE;
31
    cdev_add(&mycdev, devno, 1);
32

33
    mycls = class_create("mychar");
34
    device_create(mycls, NULL, devno, NULL, DEV_NAME);
35
    return 0;
36
}
37

38
static void __exit mod_exit(void) {
39
    device_destroy(mycls, devno);
40
    class_destroy(mycls);
41
    cdev_del(&mycdev);
42
    unregister_chrdev_region(devno, 1);
43
}
44

45
module_init(mod_init);
46
module_exit(mod_exit);
47
MODULE_LICENSE("GPL");

1
static ssize_t my_write(struct file *f, const char __user *buf, size_t cnt, loff_t *off) {
2
    char kbuf[64];
3
    if (cnt > sizeof(kbuf)) cnt = sizeof(kbuf);
4
    if (copy_from_user(kbuf, buf, cnt))
5
        return -EFAULT;
6
    process(kbuf, cnt);
7
    return cnt;
8
}

1
#define MYDEV_IOC_MAGIC 'k'
2
#define MYDEV_GET_VAL   _IOR(MYDEV_IOC_MAGIC, 1, int)
3
#define MYDEV_SET_VAL   _IOW(MYDEV_IOC_MAGIC, 2, int)
4

5
static long my_ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
6
    int val;
7
    switch (cmd) {
8
    case MYDEV_GET_VAL:
9
        val = current_value();
10
        if (copy_to_user((int __user *)arg, &val, sizeof(val))) return -EFAULT;
11
        break;
12
    case MYDEV_SET_VAL:
13
        if (copy_from_user(&val, (int __user *)arg, sizeof(val))) return -EFAULT;
14
        set_value(val);
15
        break;
16
    default:
17
        return -ENOTTY;
18
    }
19
    return 0;
20
}

1
static DECLARE_WAIT_QUEUE_HEAD(rq);
2
static int data_ready;
3

4
static ssize_t my_read(struct file *f, char __user *buf, size_t cnt, loff_t *off) {
5
    if (wait_event_interruptible(rq, data_ready))
6
        return -ERESTARTSYS;
7
    data_ready = 0;
8
    return copy_data(buf, cnt);
9
}
10

11
static irqreturn_t my_isr(int irq, void *dev) {
12
    data_ready = 1;
13
    wake_up_interruptible(&rq);
14
    return IRQ_HANDLED;
15
}

1
static __poll_t my_poll(struct file *f, poll_table *wait) {
2
    poll_wait(f, &rq, wait);
3
    return data_ready ? (EPOLLIN | EPOLLRDNORM) : 0;
4
}
5

6
static struct file_operations fops = {
7
    ...
8
    .poll = my_poll,
9
};

1
#include <linux/miscdevice.h>
2

3
static struct miscdevice my_misc = {
4
    .minor = MISC_DYNAMIC_MINOR,
5
    .name  = "mychar",
6
    .fops  = &fops,
7
};
8

9
static int __init init(void) { return misc_register(&my_misc); }
10
static void __exit exit(void) { misc_deregister(&my_misc); }

1
static int my_open(struct inode *ino, struct file *f) {
2
    int idx = iminor(ino);
3
    f->private_data = &my_instances[idx];
4
    return 0;
5
}

1
연산                              시간 (x86_64)
2
syscall (open/close)              ~600 ns
3
read (1 byte from char driver)    ~700 ns
4
copy_to_user (1 KB)               ~400 ns
5
ioctl                             ~500 ns
6
mmap → user 직접 접근             initial 1 µs, 이후 0

1
RAM 사용량
2
char driver (cdev)                ~64 B per device
3
misc device                       ~96 B (cdev 내장)
4
class + device entry              ~수백 B (udev attribute 포함)

1
static ssize_t my_read(... char __user *buf, ...) {
2
    buf[0] = 'h';   /* kernel oops 또는 보안 사고 */
3
}

1
cdev_add(&c, ...);
2
if (oh_no) return -ENOMEM;   /* unregister_chrdev_region 누락 */

1
static int g_counter;
2
static ssize_t my_write(...) { g_counter++; }    /* race */

1
static ssize_t my_write(...) {
2
    char buf[8192];   /* 8 KB on kernel stack — overflow */
3
}

1
register_chrdev(123, ...);   /* fixed major — 이미 사용 중일 수 있음 */