C언어로 문자 디바이스 드라이버 구현하기: 개념과 실습

   wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.x.tar.xz
   tar -xvf linux-5.x.tar.xz
   cd linux-5.x

   sudo apt-get install linux-headers-$(uname -r)

   sudo apt-get install build-essential

   sudo apt-get install qemu-kvm

   obj-m := char_driver.o

   all:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

   clean:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

   make

   dmesg | tail

   sudo mknod /dev/my_char_device c <major_number> 0

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "my_char_device"

// 전역 변수
static int major_number; // 메이저 번호
static struct cdev my_cdev; // 문자 디바이스 구조체
static char device_buffer[1024]; // 디바이스 버퍼

// 함수 프로토타입
static int device_open(struct inode *inode, struct file *file);
static int device_release(struct inode *inode, struct file *file);
static ssize_t device_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset);
static ssize_t device_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset);

// 파일 연산 구조체
static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = device_open,
    .release = device_release,
    .read = device_read,
    .write = device_write,
};

// 드라이버 초기화 함수
static int __init char_device_init(void) {
    // 메이저 번호 할당
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        pr_err("Failed to register char device\n");
        return major_number;
    }
    pr_info("Char device registered with major number %d\n", major_number);

    // cdev 구조체 초기화
    cdev_init(&my_cdev, &fops);
    my_cdev.owner = THIS_MODULE;

    // cdev 추가
    if (cdev_add(&my_cdev, MKDEV(major_number, 0), 1) < 0) {
        unregister_chrdev(major_number, DEVICE_NAME);
        pr_err("Failed to add cdev\n");
        return -1;
    }
    pr_info("Char device initialized\n");
    return 0;
}

// 드라이버 종료 함수
static void __exit char_device_exit(void) {
    cdev_del(&my_cdev); // cdev 삭제
    unregister_chrdev(major_number, DEVICE_NAME); // 메이저 번호 해제
    pr_info("Char device unregistered\n");
}

// 드라이버 오픈 함수
static int device_open(struct inode *inode, struct file *file) {
    pr_info("Device opened\n");
    return 0;
}

// 드라이버 릴리즈 함수
static int device_release(struct inode *inode, struct file *file) {
    pr_info("Device closed\n");
    return 0;
}

// 드라이버 읽기 함수
static ssize_t device_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset) {
    size_t bytes_to_copy = min(count, (size_t)(1024 - *offset));
    if (bytes_to_copy == 0)
        return 0;
    if (copy_to_user(user_buffer, device_buffer + *offset, bytes_to_copy))
        return -EFAULT;
    *offset += bytes_to_copy;
    return bytes_to_copy;
}

// 드라이버 쓰기 함수
static ssize_t device_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset) {
    size_t bytes_to_copy = min(count, (size_t)(1024 - *offset));
    if (bytes_to_copy == 0)
        return -ENOSPC;
    if (copy_from_user(device_buffer + *offset, user_buffer, bytes_to_copy))
        return -EFAULT;
    *offset += bytes_to_copy;
    return bytes_to_copy;
}

module_init(char_device_init);
module_exit(char_device_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Basic Character Device Driver");

   int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops);

   void unregister_chrdev(unsigned int major, const char *name);

   void cdev_init(struct cdev *cdev, const struct file_operations *fops);
   int cdev_add(struct cdev *cdev, dev_t dev, unsigned int count);

   int copy_to_user(void __user *to, const void *from, unsigned long n);
   int copy_from_user(void *to, const void __user *from, unsigned long n);

   module_init(init_function);
   module_exit(exit_function);

   struct file_operations {
       struct module *owner;
       int (*open)(struct inode *, struct file *);
       int (*release)(struct inode *, struct file *);
       ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
       ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
   };

   struct cdev {
       struct kobject kobj;
       struct module *owner;
       const struct file_operations *ops;
   };

   typedef unsigned int dev_t;

   int major_number = register_chrdev(0, "my_char_device", &fops);
   if (major_number < 0) {
       pr_err("Failed to register char device\n");
       return major_number;
   }

   device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
   if (!device_buffer) {
       unregister_chrdev(major_number, "my_char_device");
       return -ENOMEM;
   }

   pr_info("Char device driver initialized with major number %d\n", major_number);

   unregister_chrdev(major_number, "my_char_device");

   kfree(device_buffer);

   pr_info("Char device driver removed\n");

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>

#define DEVICE_NAME "my_char_device"
#define BUFFER_SIZE 1024

static int major_number;
static char *device_buffer;

// 초기화 함수
static int __init char_device_init(void) {
    // 디바이스 등록
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        pr_err("Failed to register char device\n");
        return major_number;
    }

    // 메모리 할당
    device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!device_buffer) {
        unregister_chrdev(major_number, DEVICE_NAME);
        return -ENOMEM;
    }

    pr_info("Char device driver initialized with major number %d\n", major_number);
    return 0;
}

// 종료 함수
static void __exit char_device_exit(void) {
    // 메모리 해제
    kfree(device_buffer);

    // 디바이스 등록 해제
    unregister_chrdev(major_number, DEVICE_NAME);

    pr_info("Char device driver removed\n");
}

module_init(char_device_init);
module_exit(char_device_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple Character Device Driver");

   sudo insmod my_char_device.ko

   sudo rmmod my_char_device

   dmesg | tail

  int copy_to_user(void __user *to, const void *from, unsigned long n);

  int copy_from_user(void *to, const void __user *from, unsigned long n);

   static ssize_t device_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset) {
       size_t bytes_to_copy = min(count, (size_t)(BUFFER_SIZE - *offset));
       if (bytes_to_copy == 0) {
           return 0; // End of file
       }

       if (copy_to_user(user_buffer, device_buffer + *offset, bytes_to_copy)) {
           return -EFAULT; // Error during copy
       }

       *offset += bytes_to_copy;
       return bytes_to_copy;
   }

   static ssize_t device_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset) {
       size_t bytes_to_copy = min(count, (size_t)(BUFFER_SIZE - *offset));
       if (bytes_to_copy == 0) {
           return -ENOSPC; // No space left in buffer
       }

       if (copy_from_user(device_buffer + *offset, user_buffer, bytes_to_copy)) {
           return -EFAULT; // Error during copy
       }

       *offset += bytes_to_copy;
       return bytes_to_copy;
   }

   sudo mknod /dev/my_char_device c <major_number> 0
   sudo chmod 666 /dev/my_char_device

   echo "Hello, Kernel!" > /dev/my_char_device

   cat /dev/my_char_device

   printk(KERN_INFO "Driver loaded successfully\n");

   dmesg | tail

   proc_create("my_char_device", 0, NULL, &proc_fops);

   echo function > /sys/kernel/debug/tracing/current_tracer

   int fd = open("/dev/my_char_device", O_RDWR);
   write(fd, "Testing", 7);
   char buffer[8];
   read(fd, buffer, 7);
   close(fd);

   dd if=/dev/zero of=/dev/my_char_device bs=1024 count=2