C언어로 커널 모듈을 활용한 간단한 블록 디바이스 드라이버 작성

C언어로 커널 모듈에서 블록 디바이스 드라이버를 구현하는 것은 시스템 프로그래밍의 핵심 기술 중 하나입니다. 이를 통해 운영 체제와 디바이스 간의 효율적인 데이터 전송을 가능하게 하며, 다양한 저장 장치를 제어할 수 있습니다. 본 기사에서는 간단한 블록 디바이스 드라이버를 작성하기 위한 기본 개념부터 코드 작성, 테스트 및 디버깅 방법까지 단계별로 알아봅니다.

블록 디바이스 드라이버란?

블록 디바이스 드라이버는 운영 체제와 저장 장치(예: 하드 디스크, SSD, USB 드라이브) 사이에서 데이터를 주고받는 중간 역할을 하는 소프트웨어입니다.

블록 디바이스의 정의

블록 디바이스는 데이터를 고정된 크기의 블록 단위로 읽거나 쓸 수 있는 하드웨어 디바이스를 말합니다. 대표적인 예로 디스크 드라이브, CD-ROM, 플래시 메모리가 있습니다.

드라이버의 역할

블록 디바이스 드라이버는 다음과 같은 작업을 수행합니다:

• 디바이스와의 통신: 저장 장치의 하드웨어 인터페이스를 제어합니다.
• 데이터 관리: 읽기/쓰기 요청을 처리하고 데이터의 저장 및 검색을 관리합니다.
• 운영 체제와의 통합: 디바이스를 파일 시스템이나 애플리케이션에서 사용할 수 있도록 추상화합니다.

블록 디바이스 드라이버의 주요 기능

• 읽기 및 쓰기 연산 지원
• 요청 큐 관리
• 메모리 매핑
• 동기화 및 에러 핸들링

블록 디바이스 드라이버는 효율적이고 안정적인 시스템 작동에 필수적인 요소로, 이를 직접 구현하는 과정은 디바이스의 동작 원리와 운영 체제의 구조를 깊이 이해하는 데 도움을 줍니다.

필요한 개발 환경

커널 모듈에서 블록 디바이스 드라이버를 작성하려면 적절한 개발 환경을 구성하는 것이 중요합니다. 아래는 이를 위한 필수 구성 요소와 설정 방법입니다.

운영 체제

Linux 커널 기반의 운영 체제가 필요합니다. 다음 중 하나를 사용하는 것이 권장됩니다:

• Ubuntu
• Fedora
• CentOS

Linux 커널 소스 코드

드라이버 개발에 필요한 커널 소스를 다운로드하고 설정해야 합니다.

1. 시스템에 맞는 커널 버전을 확인합니다.

   uname -r

2. 커널 소스를 다운로드합니다.

   sudo apt install linux-source

필요한 소프트웨어 및 도구

1. GCC 컴파일러: 커널 모듈 코드를 컴파일합니다.

   sudo apt install build-essential

2. Make: Makefile을 사용해 코드를 빌드합니다.
3. Kernel headers: 현재 커널 버전에 맞는 헤더 파일이 필요합니다.

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

권장 편집기

드라이버 코드를 작성할 때 사용하는 편집기로는 다음이 적합합니다:

• VS Code
• Vim
• Emacs

권한 및 설정

1. 루트 권한이 필요합니다.

   sudo su

2. 드라이버를 테스트하기 위해 개발 환경이 VirtualBox나 VMware 같은 가상화 소프트웨어에서 설정된 경우, 디바이스 접근 권한을 추가로 구성해야 할 수 있습니다.

이 환경 구성이 완료되면 커널 모듈 작성과 드라이버 구현을 위한 준비가 완료됩니다.

기본 커널 모듈 작성

커널 모듈 개발의 첫걸음은 간단한 “Hello, World!” 커널 모듈을 작성하는 것입니다. 이를 통해 커널 모듈의 구조와 기본 작동 방식을 이해할 수 있습니다.

커널 모듈의 구조

커널 모듈은 기본적으로 다음과 같은 두 가지 함수로 구성됩니다:

1. init 함수: 모듈이 커널에 로드될 때 실행됩니다.
2. exit 함수: 모듈이 커널에서 제거될 때 실행됩니다.

샘플 코드

아래는 간단한 “Hello, World!” 커널 모듈의 예제입니다:

#include <linux/init.h>   // init 및 exit 매크로
#include <linux/module.h> // 커널 모듈 매크로 및 함수

MODULE_LICENSE("GPL");              // 모듈 라이선스
MODULE_AUTHOR("Your Name");         // 작성자
MODULE_DESCRIPTION("Hello World Module"); // 모듈 설명

// 모듈 로드 시 호출되는 함수
static int __init hello_init(void) {
    printk(KERN_INFO "Hello, World! Kernel Module Loaded.\n");
    return 0; // 성공적으로 로드 시 0 반환
}

// 모듈 제거 시 호출되는 함수
static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye, World! Kernel Module Unloaded.\n");
}

// init 및 exit 함수 등록
module_init(hello_init);
module_exit(hello_exit);

Makefile 작성

커널 모듈을 빌드하려면 Makefile이 필요합니다. 아래는 해당 모듈의 Makefile 예제입니다:

obj-m += hello.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

모듈 빌드와 로드

1. 모듈 빌드:

   make

2. 모듈 로드:

   sudo insmod hello.ko

3. 로그 확인:
   커널 로그에서 메시지를 확인합니다.

   dmesg | tail

4. 모듈 제거:

   sudo rmmod hello

결과 확인

위 과정을 완료하면, 커널 로그에 “Hello, World!” 메시지가 출력되고, 모듈이 정상적으로 작동했음을 확인할 수 있습니다.

이 과정을 통해 커널 모듈 개발의 기본을 익히고, 다음 단계로 진행할 준비를 마칠 수 있습니다.

주요 블록 디바이스 드라이버 인터페이스

블록 디바이스 드라이버를 작성하려면 커널에서 제공하는 주요 인터페이스와 데이터 구조를 이해하는 것이 중요합니다. 이 섹션에서는 블록 디바이스와 관련된 핵심 요소를 설명합니다.

블록 디바이스 구조

블록 디바이스 드라이버는 block_device_operations 구조체를 통해 구현됩니다. 이 구조체는 디바이스와의 주요 인터페이스를 정의합니다.

struct block_device_operations {
    int (*open) (struct block_device *, fmode_t);
    void (*release) (struct gendisk *, fmode_t);
    int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
    /* 더 많은 함수 포인터가 필요에 따라 정의됨 */
};

gendisk 구조체

gendisk는 블록 디바이스를 나타내는 주요 구조체입니다. 디바이스 이름, 크기, 파티션 정보 등을 포함합니다.

struct gendisk {
    int major;                       // 주 번호
    int first_minor;                 // 첫 번째 부 번호
    char disk_name[32];              // 디스크 이름
    struct block_device_operations *fops; // 디바이스 작업
    struct request_queue *queue;     // 요청 큐
    unsigned long capacity;          // 디스크 크기
};

요청 큐(Request Queue)

요청 큐는 I/O 요청을 관리하는 구조체로, 블록 디바이스 드라이버의 핵심입니다. 디바이스와 애플리케이션 간의 I/O 작업을 효율적으로 처리합니다.

• 요청 생성: I/O 요청은 request 구조체로 관리됩니다.
• 요청 처리: 드라이버는 요청 큐를 탐색하며 작업을 처리합니다.

주요 함수

블록 디바이스 드라이버에서 자주 사용하는 주요 함수는 다음과 같습니다:

1. register_blkdev
   블록 디바이스를 커널에 등록합니다.

   int register_blkdev(unsigned int major, const char *name);

2. add_disk
   디스크를 커널에 추가합니다.

   void add_disk(struct gendisk *gd);

3. alloc_disk
   gendisk 구조체를 동적으로 할당합니다.

   struct gendisk *alloc_disk(int minors);

4. del_gendisk
   디스크를 커널에서 제거합니다.

   void del_gendisk(struct gendisk *gd);

5. unregister_blkdev
   블록 디바이스를 커널에서 제거합니다.

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

작동 원리

1. 드라이버가 커널에 등록됩니다.
2. 요청 큐가 초기화되고, 디스크가 생성됩니다.
3. I/O 요청이 요청 큐로 전달되고, 처리된 후 완료됩니다.

이러한 인터페이스를 활용하면 블록 디바이스 드라이버를 효율적으로 설계하고 운영 체제와의 통합을 원활히 수행할 수 있습니다.

간단한 블록 디바이스 드라이버 구현

이 섹션에서는 간단한 블록 디바이스 드라이버를 작성하는 방법을 샘플 코드를 통해 단계별로 설명합니다.

샘플 블록 디바이스 드라이버

아래는 간단한 블록 디바이스 드라이버 예제입니다. 이 드라이버는 가상 디스크 역할을 하며, 데이터를 메모리에 저장합니다.

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

#define DEVICE_NAME "simple_block"
#define SECTOR_SIZE 512
#define NUM_SECTORS 1024

static int major_num;                    // 주 번호
static struct gendisk *gd;               // 디스크 구조체
static struct request_queue *queue;      // 요청 큐
static unsigned char *device_data;       // 가상 디스크 데이터

// I/O 작업 처리 함수
static void simple_block_request(struct request_queue *q) {
    struct request *req;
    while ((req = blk_fetch_request(q)) != NULL) {
        if (blk_rq_is_passthrough(req)) {
            printk(KERN_NOTICE "Skip non-fs request\n");
            blk_end_request_all(req, -EIO);
            continue;
        }
        unsigned long start_sector = blk_rq_pos(req);
        unsigned long num_sectors = blk_rq_cur_sectors(req);
        unsigned char *buffer = bio_data(req->bio);
        if (rq_data_dir(req) == WRITE) {
            memcpy(device_data + start_sector * SECTOR_SIZE, buffer, num_sectors * SECTOR_SIZE);
        } else if (rq_data_dir(req) == READ) {
            memcpy(buffer, device_data + start_sector * SECTOR_SIZE, num_sectors * SECTOR_SIZE);
        }
        blk_end_request_all(req, 0);
    }
}

// 블록 디바이스 작업 정의
static struct block_device_operations simple_block_ops = {
    .owner = THIS_MODULE,
};

// 모듈 초기화
static int __init simple_block_init(void) {
    device_data = vmalloc(NUM_SECTORS * SECTOR_SIZE);
    if (!device_data) return -ENOMEM;

    major_num = register_blkdev(0, DEVICE_NAME);
    if (major_num <= 0) {
        printk(KERN_ERR "Unable to register block device\n");
        vfree(device_data);
        return -EBUSY;
    }

    queue = blk_init_queue(simple_block_request, NULL);
    if (!queue) {
        unregister_blkdev(major_num, DEVICE_NAME);
        vfree(device_data);
        return -ENOMEM;
    }

    gd = alloc_disk(1);
    if (!gd) {
        blk_cleanup_queue(queue);
        unregister_blkdev(major_num, DEVICE_NAME);
        vfree(device_data);
        return -ENOMEM;
    }

    gd->major = major_num;
    gd->first_minor = 0;
    gd->fops = &simple_block_ops;
    gd->queue = queue;
    snprintf(gd->disk_name, 32, DEVICE_NAME);
    set_capacity(gd, NUM_SECTORS);
    add_disk(gd);

    printk(KERN_INFO "Simple block device initialized\n");
    return 0;
}

// 모듈 종료
static void __exit simple_block_exit(void) {
    del_gendisk(gd);
    put_disk(gd);
    blk_cleanup_queue(queue);
    unregister_blkdev(major_num, DEVICE_NAME);
    vfree(device_data);
    printk(KERN_INFO "Simple block device removed\n");
}

module_init(simple_block_init);
module_exit(simple_block_exit);

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

코드 설명

1. 가상 디스크 데이터: device_data는 메모리에 생성된 가상 디스크입니다.
2. I/O 요청 처리: simple_block_request 함수에서 READ/WRITE 요청을 처리합니다.
3. 드라이버 초기화: simple_block_init 함수는 디바이스를 초기화하고 커널에 등록합니다.
4. 드라이버 종료: simple_block_exit 함수는 디바이스를 제거하고 자원을 해제합니다.

빌드와 테스트

1. 코드 빌드:

   make

2. 모듈 로드:

   sudo insmod simple_block.ko

3. 디바이스 파일 생성:

   sudo mknod /dev/simple_block b <major_num> 0

4. 테스트:
   디바이스에 데이터를 쓰고 읽어 확인합니다.

   dd if=/dev/zero of=/dev/simple_block bs=512 count=1
   dd if=/dev/simple_block of=/tmp/output bs=512 count=1

이 코드는 간단한 블록 디바이스 드라이버의 동작 방식을 이해하고 테스트하는 데 유용합니다.

디바이스 파일 생성과 테스트

블록 디바이스 드라이버를 구현한 후, 이를 사용하려면 디바이스 파일을 생성하고 드라이버를 테스트해야 합니다. 이 섹션에서는 디바이스 파일 생성 방법과 테스트 절차를 설명합니다.

디바이스 파일 생성

디바이스 파일은 /dev 디렉터리에 생성되며, 드라이버와 사용자 공간 애플리케이션 간의 인터페이스 역할을 합니다. 디바이스 파일을 생성하려면 mknod 명령어를 사용합니다.

1. 드라이버 로드 후 주 번호 확인
   모듈을 로드한 후, 드라이버의 주 번호를 확인합니다.

   sudo insmod simple_block.ko
   dmesg | grep "Simple block device"

출력 예:

   Simple block device initialized with major number 251

여기서 251이 주 번호입니다.

2. 디바이스 파일 생성
   디바이스 파일을 생성하려면 다음 명령어를 실행합니다:

   sudo mknod /dev/simple_block b <major_number> 0

예를 들어, 주 번호가 251이라면:

   sudo mknod /dev/simple_block b 251 0

3. 파일 권한 설정
   생성된 디바이스 파일에 읽기/쓰기 권한을 부여합니다:

   sudo chmod 666 /dev/simple_block

드라이버 테스트

드라이버가 올바르게 작동하는지 확인하기 위해 다양한 테스트를 수행합니다.

1. 쓰기 테스트
   /dev/simple_block 디바이스에 데이터를 씁니다:

   echo "Test Data" | sudo dd of=/dev/simple_block bs=512 count=1

2. 읽기 테스트
   디바이스에서 데이터를 읽어 확인합니다:

   sudo dd if=/dev/simple_block bs=512 count=1

3. 디스크 상태 확인
   lsblk 명령어로 디바이스 상태를 확인합니다:

   lsblk

생성된 디바이스가 목록에 표시됩니다.

4. 데이터 확인
   데이터를 디바이스에서 읽고 파일에 저장한 후 확인합니다:

   sudo dd if=/dev/simple_block of=/tmp/output bs=512 count=1
   cat /tmp/output

모듈 제거

테스트 후에는 디바이스 파일을 제거하고 모듈을 언로드합니다.

1. 디바이스 파일 제거:

   sudo rm /dev/simple_block

2. 모듈 언로드:

   sudo rmmod simple_block

결과 확인

테스트가 성공적으로 완료되면, 블록 디바이스 드라이버가 올바르게 작동하고 데이터를 읽고 쓰는 작업을 처리할 수 있음을 확인할 수 있습니다.

디버깅 및 문제 해결

블록 디바이스 드라이버 개발 중 발생할 수 있는 문제를 디버깅하고 해결하는 방법을 소개합니다. 커널 모듈은 사용자 공간 애플리케이션과 달리 디버깅 도구가 제한적이므로, 체계적인 접근 방식이 필요합니다.

커널 로그 확인

커널 로그는 드라이버 실행 중 발생한 오류와 상태 정보를 확인하는 가장 기본적인 방법입니다.

• 로그 출력:
  드라이버 코드에서 printk를 사용해 로그 메시지를 기록합니다.

  printk(KERN_INFO "Message: %s\n", "Debugging info");

• 로그 확인:
  dmesg 명령어를 사용해 로그를 확인합니다.

  dmesg | tail -n 20

gdb를 사용한 커널 디버깅

가상 머신 환경에서 gdb를 활용하면 커널 디버깅이 가능합니다.

1. gdb 서버 시작:
   QEMU와 같은 가상 머신에서 커널 실행 시 -s -S 옵션을 사용해 gdb 서버를 시작합니다.

   qemu-system-x86_64 -kernel bzImage -s -S

2. gdb 연결:
   로컬 터미널에서 gdb를 실행하고 연결합니다.

   gdb vmlinux
   target remote :1234

동적 디버깅

Linux 커널은 동적 디버깅을 지원하며, 이 기능을 활성화하면 특정 함수나 코드 경로에 대한 정보를 얻을 수 있습니다.

• 동적 디버깅 활성화:

  echo "module simple_block +p" > /sys/kernel/debug/dynamic_debug/control

주요 디버깅 도구

1. strace
   사용자 공간에서 디바이스 파일에 접근할 때 호출되는 시스템 호출을 추적합니다.

   strace dd if=/dev/simple_block of=/tmp/output bs=512 count=1

2. ftrace
   커널 내부 함수 호출을 추적할 수 있는 강력한 도구입니다.

• ftrace 활성화:
  bash echo function > /sys/kernel/debug/tracing/current_tracer echo simple_block_request > /sys/kernel/debug/tracing/set_ftrace_filter

2. kdb 및 kgdb
   커널 디버깅에 특화된 인터페이스로, 실행 중인 커널의 상태를 확인하고 디버깅할 수 있습니다.

문제 해결 사례

1. 모듈 로드 실패

• 로그에서 “No such device” 메시지가 출력되는 경우, 디바이스 초기화 함수에서 오류가 발생했는지 확인합니다.
• 커널 헤더가 올바르게 설치되었는지 확인합니다.

1. 읽기/쓰기 오류

• 요청 큐(request_queue) 설정을 확인합니다.
• 데이터 메모리 영역(device_data)의 초기화 여부를 확인합니다.

1. I/O 성능 저하

• 요청 큐의 스케줄러를 조정합니다.
• 대량 데이터 처리를 위한 DMA(Direct Memory Access) 사용을 고려합니다.

문제 예방

• 코드 분석: 정적 분석 도구를 사용해 잠재적인 버그를 사전에 식별합니다.
• 테스트 환경 구성: 가상 머신을 사용해 안전한 테스트 환경을 구축합니다.
• 모듈 언로드 테스트: 항상 모듈 언로드 시 자원 해제가 올바르게 수행되는지 확인합니다.

체계적인 디버깅과 문제 해결 방법을 활용하면 드라이버 개발 중 발생하는 대부분의 문제를 효과적으로 해결할 수 있습니다.

확장 가능한 기능 추가

블록 디바이스 드라이버는 기본적인 읽기/쓰기 기능 외에도 다양한 확장 기능을 추가하여 성능과 유용성을 향상시킬 수 있습니다. 이 섹션에서는 드라이버에 추가할 수 있는 기능과 구현 방법을 설명합니다.

읽기/쓰기 성능 최적화

1. I/O 스케줄링
   요청 큐의 스케줄러를 설정하거나 사용자 정의 스케줄러를 구현해 I/O 성능을 개선할 수 있습니다.

• 요청 큐 스케줄러 변경:
  bash echo noop > /sys/block/simple_block/queue/scheduler
• 사용자 정의 스케줄러는 커널 소스의 스케줄링 관련 코드를 수정하여 추가합니다.

1. 캐싱 구현
   자주 사용되는 데이터를 메모리에 캐싱하여 I/O 요청 처리 속도를 향상시킵니다.

   static struct bio_vec *cache;
   // 데이터 요청 시 캐시를 먼저 확인하도록 수정

동적 디스크 크기 조정

드라이버를 수정하여 디스크 크기를 동적으로 조정할 수 있도록 기능을 추가합니다.

• 디스크 크기 변경:
  커널 함수 set_capacity를 호출해 디스크 크기를 동적으로 업데이트합니다.

  set_capacity(gd, new_capacity);

• ioctl 인터페이스 추가:
  사용자 공간에서 디스크 크기를 변경할 수 있도록 ioctl 명령을 구현합니다.

멀티 디바이스 지원

하나의 드라이버에서 여러 디바이스를 관리하도록 확장할 수 있습니다.

• 다중 gendisk 구조체 사용:
  각 디바이스에 대해 별도의 gendisk 구조체를 생성하고 관리합니다.
• 동적 디바이스 번호 할당:
  alloc_disk를 사용해 여러 디바이스를 동적으로 생성합니다.

로그 및 통계 기능 추가

디바이스 사용 통계를 기록하고 사용자에게 제공하는 기능을 추가합니다.

• I/O 요청 수 통계:
  I/O 요청 수를 기록하고 /proc 또는 /sys 파일 시스템을 통해 조회할 수 있도록 구현합니다.

  static unsigned long read_count = 0, write_count = 0;
  if (rq_data_dir(req) == READ) read_count++;
  else if (rq_data_dir(req) == WRITE) write_count++;

보안 기능

1. 접근 제어
   특정 사용자나 그룹만 디바이스를 사용할 수 있도록 접근 제어 기능을 추가합니다.

• check_permission 함수 구현으로 접근 제한.

1. 암호화 지원
   데이터 저장 및 전송 시 암호화를 적용합니다.

• 암호화 라이브러리(Kernel Crypto API)를 활용합니다.
  c struct crypto_cipher *cipher; cipher = crypto_alloc_cipher("aes", 0, 0);

파일 시스템 통합

블록 디바이스 드라이버를 파일 시스템과 통합하여 고급 기능을 제공합니다.

• 루프백 디바이스 기능:
  일반 파일을 블록 디바이스처럼 사용할 수 있도록 기능 추가.
• 특정 파일 시스템과의 최적화:
  Ext4, XFS 등 특정 파일 시스템에 최적화된 I/O 경로를 구현.

확장 기능 구현 시 주의 사항

• 호환성: 추가 기능이 기존 드라이버 동작과 충돌하지 않도록 주의합니다.
• 성능 검증: 기능 추가 후 I/O 성능이 저하되지 않는지 확인합니다.
• 리소스 관리: 동적 자원 할당 시 메모리 누수를 방지하기 위해 철저히 관리합니다.

이러한 확장 기능을 추가하면 드라이버의 성능과 유용성이 크게 향상되며, 다양한 환경에서 더 넓은 범위의 요구를 충족할 수 있습니다.

요약

본 기사에서는 C언어를 활용해 간단한 블록 디바이스 드라이버를 작성하는 방법을 설명했습니다. 블록 디바이스 드라이버의 기본 개념부터, 커널 모듈 작성, 디바이스 파일 생성, 드라이버 테스트, 디버깅, 그리고 확장 가능한 기능 추가까지 단계적으로 다루었습니다.

블록 디바이스 드라이버 구현을 통해 운영 체제와 하드웨어 간의 동작 원리를 이해하고, 성능 최적화 및 기능 확장 방법을 학습할 수 있습니다. 이를 기반으로 실제 프로젝트에 응용 가능한 드라이버를 개발할 수 있습니다.