proc interface & seq_file

 

proc 인터페이스 (procfs 또는 /proc)

proc 인터페이스는 다음과 같은 특징을 가지고 있다.

  • 커널 코어 및 디바이스 드라이버 개발자들이 내부 커널 정보 및 디바이스 정보를 유저 스페이스에 파일 형태로 제공한다.
  • 커널 내부에 procfs 라고 불리는 가상 파일 시스템을 제공한다. 사용자는 루트 파일 시스템에 마운트하여 사용할 수 있다.
  • procfs는 커널 메모리에서만 구성되므로 빠른 접근이 가능하다.
  • 대부분의 proc 파일 정보는 사용자가 쉽게 읽을 수 있도록 readable 텍스트 형태로 출력한다. (일부는 binary로만 제공하는 정보도 있다.)

 

 

seq_file 인터페이스

  • seq_file 인터페이스는 개발자 편의를 위해 proc 인터페이스에서 파일 출력의 iteration을 간편히 제공할 목적으로 설계되었다.

 

커널 옵션

  • CONFIG_PROC_FS
    • proc 파일 시스템을 사용하기 위해서는 이 옵션이 필요한다.
    • 만들어진 proc 파일 시스템(procfs)은 마운트하여 사용한다.
  • CONFIG_PROC_KCORE
    • ELF 포맷을 지원한다. 이 파일은 gdb나 ELF 툴을 사용하여 읽어낼 수 있다.
  • CONFIG_PROC_VMCORE
    • 크래시 커널 덤프 이미지를 elf 포맷으로 출력한다.
  • CONFIG_PROC_SYSCTL
    • /proc/sys을 통해 sysctl 인터페이스를 지원한다.
  • CONFIG_PROC_PAGE_MONITOR
    • 프로세스의 메모리 사용에 대한 모니터링을 할 수 있게 한다.
    • /proc/<pid>/
      • smaps
      • clear_refs
      • pagemap
    • /proc/kpagecount
    • /proc/kpageflags

 

 

proc 인터페이스 코어

proc 파일 시스템의 코어는 아래 그림과 같이 3개의 파일을 통해 구현되어 있다.

 

샘플 proc 인터페이스 개발

자신이 개발한 디바이스 드라이버에 proc 인터페이스를 추가하여 관련 정보를 간단히 출력할 수 있는 방법을 알아보자.

  • 커널 v3.10 버전부터 proc 인터페이스가 리팩토링되었다.
  • 커널 v3.10 이전 버전에서는 proc_create() 대신 create_proc_entry() 함수를 사용하였었는데 그 방법은 생략한다.

 

 

Makefile 준비

먼저 테스트용 디렉토리를 만들고 Makefile을 준비한다.  실전에서 사용할 수 있도록 다음과 같이 두 개의 소스를 구분하였다.

  • proc 인터페이스와 관계없이 모듈의 데이터 부분을 다루는 foo.c
  • proc 인터페이스를 만들고 출력하는 proc.c

 

모듈 프로그래밍을 자주해본 경험이 있다면 다음과 같이 make -C 플래그 옵션과 -M 플래그 옵션이 어떠한 일을 하는지 알 수 있다.

  • -C: 커널 위치(include 파일들과 버전이 서로 같은지 확인해서 진행해야 하므로 모듈 컴파일 시 반드시 필요하다)
  • -M: 현재 모듈 소스를 가리키기 위해 보통 현재 위치를 가리키는 $(PWD)를 사용한다.

 

$ mkdir foo-proc
$ cd foo-proc
$ cat Makefile
obj-m := foo-proc.o
foo-proc-objs := foo.o proc.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(foo.c, foo.h) 준비

foo.c 함수는 모듈에 대한 라이센스 및 개발자 정보를 기록하는 부분이 있고 그 후 다음과 같이 두 개의 파트로 구분되어 있다.

  • 첫 번째 파트:
    • 샘플 데이터 생성 및 삭제를 다룬 함수들이다.
    • 가상의 구조체 데이터 2개를 만들고 리스트에 넣는 과정이다.
  • 두 번째 파트:
    • 모듈 초기화 및 종료를 다룬 함수들이다.

 

다음 그림은 모듈 로딩시에 foo_info 구조체 2개에 샘플 데이터를 담아 foo_list에 추가한 과정을 보여준다.

 

foo-proc/foo.c – 1/2

#include <linux/slab.h>
#include <linux/module.h>       /* for module programming */
#include "foo.h"
#include "proc.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Youngil, Moon <jake9999@dreamwiz.com>");
MODULE_DESCRIPTION("A sample driver");
MODULE_LICENSE("Dual BSD/GPL");

/*--------------------------------------------------------*/
/* 1) Generate sample data                                */
/*--------------------------------------------------------*/

DEFINE_MUTEX(foo_lock);
LIST_HEAD(foo_list);

static int add_data(int a, int b)
{
        struct foo_info *info;

        printk(KERN_INFO "%s %d, %d\n", __func__, a, b);

        info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return -ENOMEM;

        INIT_LIST_HEAD(&info->list);
        info->a = a;
        info->b = b;

        mutex_lock(&foo_lock);
        list_add(&info->list, &foo_list);
        mutex_unlock(&foo_lock);

        return 0;
}

static int add_sample_data(void)
{
        if (add_data(10, 20))
                return -ENOMEM;
        if (add_data(30, 40))
                return -ENOMEM;
        return 0;
}

static int remove_sample_data(void)
{
        struct foo_info *tmp;
        struct list_head *node, *q;

        list_for_each_safe(node, q, &foo_list){
                tmp = list_entry(node, struct foo_info, list);
                list_del(node);
                kfree(tmp);
        }

        return 0;
}

 

아래 __init 및 __exit 부분에서 컴파일 에러가 발생하면 제거하고 사용해도 된다. (커널 옵션에 따라 결정된다)

foo-proc/foo.c – 2/2

/*--------------------------------------------------------*/
/* 2) Module part                                         */
/*--------------------------------------------------------*/

static int __init foo_init(void)
{
        if (add_sample_data())
        {
                printk(KERN_INFO "add_sample_data() failed.\n");
                return -ENOMEM;
        }

        return foo_proc_init();
}

static void __exit foo_exit(void)
{
        remove_sample_data();
        foo_proc_exit();

        return;
}

module_init(foo_init);
module_exit(foo_exit);

 

foo.h 헤더 파일에서는 2 개의 정수를 담고 foo_list라는 이름의 리스트로 연결될 수 있도록 최대한 간단히 표현하였다. foo_lock 뮤텍스는 리스트에 추가하거나 제거할 때 사용하기 위한 동기화 함수이다. (아래 예제에서는 실제 데이터 접근에 대해 동기화 할 필요 없는 상황이라 뮤텍스 코드는 제거해도 된다.  그냥 실전과 같이 리스트를 보호하기 위해 습관적으로 사용하였다.

foo-proc/foo.h

#ifndef _FOO_H_
#define _FOO_H_

#include <linux/mutex.h>
#include <linux/list.h>

struct foo_info {
        int a;
        int b;
        struct list_head list;
};

extern struct mutex foo_lock;
extern struct list_head foo_list;

#endif /* _FOO_H_ */

 

소스-2(proc.c, proc.h) 준비

proc 인터페이스를 구현하기 위해서는  파일 인터페이스(file 구조체를 사용하고, 오페레이션 구현을 위해 file_operations 구조체 사용)를 사용해야 한다. 랜덤(llseek)하게 데이터에 접근하여 데이터를 출력할 필요가 없고, 순차 처리된 데이터에만 접근하여 처리해도 되는 경우 파일 인터페이스에 끼워 간단하게 규격화하여 처리할 수 있는 새로운 방법이 있다. 여기에서는 이 새로운 시퀀스 파일 인터페이스(seq_file 구조체를 사용하고, 오퍼레이션 구현을 위해 seq_operations 구조체 사용)를 소개한다.  아울러 시퀀스 파일 인터페이스를 사용하지만 시퀀스 데이터에 대한 이동에 전혀 관여하지 않고, 단순하게 한 번의 함수 호출에서 데이터를 처리하길 바란다면 시퀀스 오퍼레이션을 구현하지 않을 수도 있다. 이 방법은 single_open() 함수를 사용하는 방법으로 proc 인터페이스 구현 중 가장 단순한 방법이다.

 

proc 인터페이스를 구현하는 방법은 다음 3가지로 구분할 수 있다. (사용자들은 구현이 간편한 시퀀스 파일 인터페이스를 가장 많이 사용한다. 따라서 샘플 코드는 B 방법과 C 방법만을 소개한다)

  • A) file_operations를 구현하여 사용하는 방법
    • 랜덤하게 데이터에 접근하여 데이터를 반복 처리할 수 있도록 iteration을 지원한다.
    • 시작(open) -> llseek -> show -> llseek -> show -> llseek -> show -> 끝(close)
  • B) file_operations 에 단순히 시퀀스 파일(seq_file) 인터페이스를 연결하고 seq_operations를 구현하여 구현하여 사용하는 방법
    • 단방향 순서대로만 데이터에 접근하여 반복 처리할 수 있는 iteration만을 지원한다.
    • 시작(open) -> next -> show -> next -> show -> next -> show -> 끝(close)
  • C) file_operations에 단순히 시퀀스 파일(seq_file) 인터페이스를  연결하고 seq_operatons는 사용하지 않는 single_open()을 사용하여 처리하는 방법
    • 반복 처리할 수 있는 iteration을 지원하지 않고, 단순히 한 번의 출력 함수 호출을 통해서 처리하므로 구현이 가장 간단하다.
    • 시작(open) -> show -> 끝(close)

 

다음 그림은 시퀀스 operations를 사용한 방법과 single_open() 방식을 사용한 방법의 처리 차이를 보여준다.

 

다음 코드는 시퀀스 오퍼레이션 처리에 관련된 코드들이다. 만일 simple_open() 방식을 사용하고자하면 #define USE_SINGLE_OPEN을 선언하여 seq_file에 대한 seq_operations 구현을 사용하지 않게 한다.

foo-proc/proc.c – 1/3.

// #define USE_SINGLE_OPEN

/*--------------------------------------------------------*/
/* 1) seq_file operations part                            */
/*--------------------------------------------------------*/
#ifdef USE_SINGLE_OPEN
#else
static void *foo_seq_start(struct seq_file *s, loff_t *pos)
{
        printk(KERN_INFO "%s", __func__);
        mutex_lock(&foo_lock);
        s->private = "";

        return seq_list_start(&foo_list, *pos);
}

static void *foo_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
        printk(KERN_INFO "%s", __func__);
        s->private = "\n";

        return seq_list_next(v, &foo_list, pos);
}

static void foo_seq_stop(struct seq_file *s, void *v)
{
        mutex_unlock(&foo_lock);
        printk(KERN_INFO "%s", __func__);
}

static int foo_seq_show(struct seq_file *m, void *v)
{
        struct foo_info *info = list_entry(v, struct foo_info, list);

        printk(KERN_INFO "%s", __func__);
        seq_printf(m, "%d + %d = %d\n", info->a, info->b, info->a + info->b);

        return 0;
}

static const struct seq_operations foo_seq_ops = {
        .start  = foo_seq_start,
        .next   = foo_seq_next,
        .stop   = foo_seq_stop,
        .show   = foo_seq_show
};
#endif

 

file_opeations를 구현에 seq_file 인터페이스를 사용하였다. 이 코드에서도 USE_SINGLE_OPEN 선언을 사용하는 경우 시퀀스 오퍼레이션을 사용하지 않음을 알 수 있다.

foo-proc/proc.c – 2/3

/*--------------------------------------------------------*/
/* 2) proc operations part                                */
/*--------------------------------------------------------*/

#ifdef USE_SINGLE_OPEN
static int foo_simple_show(struct seq_file *s, void *unused)
{
        struct foo_info *info;

        list_for_each_entry(info, &foo_list, list)
                seq_printf(s, "%d + %d = %d\n", info->a, info->b, info->a + info->b);

        return 0;
}
#endif

static int foo_proc_open(struct inode *inode, struct file *file)
{
#ifdef USE_SINGLE_OPEN
        return single_open(file, foo_simple_show, NULL);
#else
        return seq_open(file, &foo_seq_ops);
#endif
}


static const struct file_operations foo_proc_ops = {
        .owner          = THIS_MODULE,
        .open           = foo_proc_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = seq_release,
};

 

아래 파트는 /proc 디렉토리에 하위 디렉토리 및 이 모듈에 연결된 파일을 생성하는 과정을 보여준다.

foo-proc/proc.c – 3/3

/*--------------------------------------------------------*/
/* 3) proc interface part  (/proc/foo-dir/foo)            */
/*--------------------------------------------------------*/

#define FOO_DIR "foo-dir"
#define FOO_FILE "foo"

static struct proc_dir_entry *foo_proc_dir = NULL;
static struct proc_dir_entry *foo_proc_file = NULL;

int foo_proc_init(void)
{
        foo_proc_dir = proc_mkdir(FOO_DIR, NULL);
        if (foo_proc_dir == NULL)
        {
                printk("Unable to create /proc/%s\n", FOO_DIR);
                return -1;
        }

        foo_proc_file = proc_create(FOO_FILE, 0, foo_proc_dir, &foo_proc_ops); /* S_IRUGO */
        if (foo_proc_file == NULL)
        {
                printk("Unable to create /proc/%s/%s\n", FOO_DIR, FOO_FILE);
                remove_proc_entry(FOO_DIR, NULL);
                return -1;
        }

        printk(KERN_INFO "Created /proc/%s/%s\n", FOO_DIR, FOO_FILE);
        return 0;
}

void foo_proc_exit(void)
{
        /* remove directory and file from procfs */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0)
        remove_proc_entry(FOO_FILE, foo_proc_dir);
        remove_proc_entry(FOO_DIR, NULL);
#else
        remove_proc_subtree(FOO_DIR, NULL);
#endif

        /* remove proc_dir_entry instance */
        proc_remove(foo_proc_file);
        proc_remove(foo_proc_dir);

        printk(KERN_INFO "Removed /proc/%s/%s\n", FOO_DIR, FOO_FILE);
}

 

foo-proc/proc.h – 3/3

#ifndef _PROC_H_
#define _PROC_H_

int foo_proc_init(void);
void foo_proc_exit(void);

#endif /* _PROC_H */

 

빌드

먼저 커널 v3.10 및 4.10 버전을 사용하는 시스템에서 빌드를 하고 테스트를 해보았다.

$ ls
Makefile  foo.c  foo.h  proc.c  proc.h

$ make
make -C /lib/modules/4.10.0-42-generic/build M=/home/jake/workspace/test/foo-proc modules
make[1]: Entering directory `/usr/src/linux-headers-4.10.0-42-generic'
  CC [M]  /home/jake/workspace/test/foo-proc/foo.o
  CC [M]  /home/jake/workspace/test/foo-proc/proc.o
  LD [M]  /home/jake/workspace/test/foo-proc/foo-proc.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/jake/workspace/test/foo-proc/foo-proc.mod.o
  LD [M]  /home/jake/workspace/test/foo-proc/foo-proc.ko
make[1]: Leaving directory `/usr/src/linux-headers-4.10.0-42-generic'

$ ls
Makefile  Module.symvers  foo-proc.ko  foo-proc.mod.c  foo-proc.mod.o  foo-proc.o  foo.c  foo.h  foo.o  modules.order  proc.c  proc.h  proc.o

 

테스트

빌드가 끝났 후 생성된 foo-proc.ko 커널 모듈을 로딩해보고 생성된 /proc/foo-dir/foo 파일을 출력해본다. 마지막으로 언로딩한다.

$ sudo insmod foo-proc.ko
$ cat /proc/foo-dir/foo
30 + 40 = 70
10 + 20 = 30
$ sudo rmmod foo-proc.ko

 

먼저 보여줄 다음은 시퀀스 오퍼레이션을 처리한 방법이다.(proc.c 파일에서 USE_SINGLE_OPEN 미사용) 커널 로그를 보고 호출되는 두 건의 데이터를 통해 foo_seq_show() 함수가 두 번 호출됨을 알 수 있다.

$ dmesg
add_data 10, 20
add_data 30, 40
Created /proc/foo-dir/foo
foo_seq_start
foo_seq_show
foo_seq_next
foo_seq_show
foo_seq_next
foo_seq_stop
foo_seq_start
foo_seq_stop
Removed /proc/foo-dir/foo

 

simple_open() 사용 방법으로 테스트

이 번 방법은 single_open() 방식이다. 먼저 proc.c 에서 USE_SINGILE_OPEN 선언을 사용하는 것으로 수정한 후, 다시 빌드한다. 그 후 생성된 모듈을 로딩한 후 테스트 해보자.  다음 커널 로그를 보는 것과 같이 foo_simple_show() 함수가 한 번만 호출된 것을 알 수 있다.

$ dmesg
add_data 10, 20
add_data 30, 40
Created /proc/foo-dir/foo
foo_simple_show
Removed /proc/foo-dir/foo

 

참고

댓글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다