ioctl 시스템 콜 심화

ioctl(input/output control)은 read/write로 표현하기 어려운 디바이스 고유 제어 명령을 사용자 공간에서 커널로 전달하는 범용 시스템 콜입니다. 명령 번호 인코딩 규약(_IO/_IOR/_IOW/_IOWR), VFS 디스패치 경로, file_operations.unlocked_ioctl 구현 패턴, 32-bit 호환(compat_ioctl), 터미널·네트워크·블록·GPU 등 주요 서브시스템 사례, 보안 검증, 대안 인터페이스(sysfs/netlink/configfs) 비교, strace/ftrace 기반 디버깅까지 실무 중심으로 상세히 다룹니다.

ioctl 개요와 역사

ioctl은 1970년대 Unix V7에서 터미널 장치 제어를 위해 도입되었습니다. read/write는 바이트 스트림 전달에 특화되어 있어, "보드레이트 변경", "버퍼 플러시", "하드웨어 레지스터 설정" 같은 out-of-band 제어를 표현할 방법이 없었습니다. ioctl은 이 공백을 채우는 범용 제어 시스템 콜로 자리잡았습니다.

위 다이어그램처럼 read/write는 데이터 바이트 스트림을 전달하는 반면, ioctl은 디바이스 고유 제어 명령을 전달합니다. 이 분리 덕분에 데이터 전송 경로를 변경하지 않고도 디바이스 동작 모드를 자유롭게 제어할 수 있습니다.

ioctl이 사용되는 대표적인 디바이스 클래스를 정리하면:

사용자 공간 API

glibc에서 제공하는 ioctl 함수 시그니처는 다음과 같습니다:

#include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, ...);
/*
 * fd      — 열려 있는 파일 디스크립터 (디바이스 파일, 소켓, 터미널 등)
 * request — 명령 번호 (direction | type | nr | size 인코딩)
 * ...     — 명령에 따라 포인터 또는 정수 인자 (가변 인자)
 *
 * 반환: 성공 시 0 (또는 양수), 실패 시 -1 (errno 설정)
 */

사용자 공간에서의 전형적인 호출 예시:

#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/fs.h>    /* BLKGETSIZE64 */

int main(void)
{
    int fd = open("/dev/sda", O_RDONLY);
    unsigned long long size;

    if (ioctl(fd, BLKGETSIZE64, &size) == 0)
        printf("디스크 크기: %llu 바이트\n", size);

    close(fd);
    return 0;
}

터미널 창 크기 조회 (TIOCGWINSZ)

#include <stdio.h>
#include <sys/ioctl.h>
#include <unistd.h>

int main(void)
{
    struct winsize ws;

    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0)
        printf("터미널 크기: %d행 × %d열\n",
               ws.ws_row, ws.ws_col);

    return 0;
}

네트워크 인터페이스 정보 조회 (SIOCGIFFLAGS)

#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <sys/socket.h>

int main(void)
{
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    struct ifreq ifr;

    strncpy(ifr.ifr_name, "eth0", IFNAMSIZ);

    if (ioctl(sock, SIOCGIFFLAGS, &ifr) == 0) {
        printf("eth0 플래그: 0x%x", ifr.ifr_flags);
        if (ifr.ifr_flags & IFF_UP)
            printf(" [UP]");
        if (ifr.ifr_flags & IFF_RUNNING)
            printf(" [RUNNING]");
        printf("\n");
    }
    close(sock);
    return 0;
}

Watchdog 타이머 설정 (WDIOC_SETTIMEOUT)

#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/watchdog.h>

int main(void)
{
    int fd = open("/dev/watchdog", O_WRONLY);
    int timeout = 30;   /* 30초 */

    /* 타임아웃 설정 — 커널이 지원 가능한 값으로 조정 */
    ioctl(fd, WDIOC_SETTIMEOUT, &timeout);
    printf("실제 설정된 타임아웃: %d초\n", timeout);

    /* keepalive 핑 */
    ioctl(fd, WDIOC_KEEPALIVE, 0);

    /* 매직 클로즈: 'V' 기록 후 close → watchdog 비활성화 */
    write(fd, "V", 1);
    close(fd);
    return 0;
}

명령 번호 인코딩 (ioctl command number)

Linux는 ioctl 명령 번호를 32비트로 구조화하여 방향(direction), 매직 타입(type), 일련번호(nr), 데이터 크기(size)를 인코딩합니다. 이 규약은 include/uapi/asm-generic/ioctl.h에 정의되어 있습니다:

/* include/uapi/asm-generic/ioctl.h */
#define _IOC_NRBITS    8
#define _IOC_TYPEBITS  8
#define _IOC_SIZEBITS  14
#define _IOC_DIRBITS   2

#define _IOC(dir, type, nr, size) \
    (((unsigned int)(dir)  << _IOC_DIRSHIFT)  | \
     ((unsigned int)(type) << _IOC_TYPESHIFT) | \
     ((unsigned int)(nr)   << _IOC_NRSHIFT)   | \
     ((unsigned int)(size) << _IOC_SIZESHIFT))

#define _IO(type, nr)          _IOC(_IOC_NONE, (type), (nr), 0)
#define _IOR(type, nr, size)   _IOC(_IOC_READ, (type), (nr), sizeof(size))
#define _IOW(type, nr, size)   _IOC(_IOC_WRITE, (type), (nr), sizeof(size))
#define _IOWR(type, nr, size)  _IOC(_IOC_READ|_IOC_WRITE, (type), (nr), sizeof(size))

주요 서브시스템의 매직 타입 할당 예시:

VFS ioctl 디스패치 경로

사용자 공간에서 ioctl(fd, cmd, arg)를 호출하면, 커널은 다음 경로를 따라 최종 드라이버 콜백에 도달합니다:

핵심 함수 호출 체인을 코드로 살펴보겠습니다:

/* fs/ioctl.c (Linux 6.x 기준, 핵심 경로만 발췌) */

long vfs_ioctl(struct file *filp,
               unsigned int cmd, unsigned long arg)
{
    int error = -ENOTTY;

    if (!filp->f_op->unlocked_ioctl)
        goto out;

    error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
    if (error == -ENOIOCTLCMD)
        error = -ENOTTY;
out:
    return error;
}

static int do_vfs_ioctl(struct file *filp,
                         unsigned int fd,
                         unsigned int cmd,
                         unsigned long arg)
{
    switch (cmd) {
    case FIOCLEX:       /* close-on-exec 설정 */
        set_close_on_exec(fd, 1);
        return 0;
    case FIONCLEX:       /* close-on-exec 해제 */
        set_close_on_exec(fd, 0);
        return 0;
    case FIONBIO:        /* 논블로킹 모드 전환 */
        return ioctl_fionbio(filp, (int __user *)arg);
    case FIOASYNC:       /* 비동기 통지 설정 */
        return ioctl_fioasync(fd, filp, (int __user *)arg);
    /* ... 기타 공통 ioctl ... */
    default:
        break;
    }
    /* 드라이버 고유 ioctl로 전달 */
    return vfs_ioctl(filp, cmd, arg);
}

드라이버 ioctl 구현 패턴

Character device 드라이버에서 ioctl을 구현하는 전형적인 패턴입니다:

/* 1. 명령 번호 정의 (uapi 헤더) */
#define MYDEV_MAGIC       'M'
#define MYDEV_RESET       _IO(MYDEV_MAGIC,  0)
#define MYDEV_GET_STATUS  _IOR(MYDEV_MAGIC, 1, struct mydev_status)
#define MYDEV_SET_CONFIG  _IOW(MYDEV_MAGIC, 2, struct mydev_config)
#define MYDEV_XFER_DATA  _IOWR(MYDEV_MAGIC, 3, struct mydev_xfer)

/* 2. ioctl 핸들러 구현 */
static long mydev_ioctl(struct file *filp,
                        unsigned int cmd,
                        unsigned long arg)
{
    struct mydev_priv *priv = filp->private_data;
    void __user *uarg = (void __user *)arg;

    switch (cmd) {
    case MYDEV_RESET:
        return mydev_hw_reset(priv);

    case MYDEV_GET_STATUS: {
        struct mydev_status st;
        mydev_read_status(priv, &st);
        if (copy_to_user(uarg, &st, sizeof(st)))
            return -EFAULT;
        return 0;
    }

    case MYDEV_SET_CONFIG: {
        struct mydev_config cfg;
        if (copy_from_user(&cfg, uarg, sizeof(cfg)))
            return -EFAULT;
        return mydev_apply_config(priv, &cfg);
    }

    case MYDEV_XFER_DATA: {
        struct mydev_xfer xfer;
        if (copy_from_user(&xfer, uarg, sizeof(xfer)))
            return -EFAULT;
        /* 양방향: 처리 후 결과를 다시 복사 */
        mydev_process_xfer(priv, &xfer);
        if (copy_to_user(uarg, &xfer, sizeof(xfer)))
            return -EFAULT;
        return 0;
    }

    default:
        return -ENOTTY;
    }
}

/* 3. file_operations에 등록 */
static const struct file_operations mydev_fops = {
    .owner          = THIS_MODULE,
    .open           = mydev_open,
    .release        = mydev_release,
    .read           = mydev_read,
    .write          = mydev_write,
    .unlocked_ioctl = mydev_ioctl,       /* BKL-free ioctl */
    .compat_ioctl   = compat_ptr_ioctl,  /* 포인터 크기만 다른 경우 */
};

compat_ioctl — 32/64비트 호환

64비트 커널에서 32비트 사용자 프로세스가 ioctl을 호출하면, 포인터 크기와 구조체 패딩이 다를 수 있습니다. 이를 처리하는 것이 compat_ioctl 콜백입니다:

/* compat_ioctl이 필요한 경우: 구조체에 포인터가 포함될 때 */
struct mydev_buf_native {
    __u32  size;
    void  *data;    /* 64-bit: 8바이트, 32-bit: 4바이트 */
};

struct mydev_buf_compat {
    __u32          size;
    compat_uptr_t data;  /* 항상 4바이트 */
};

static long mydev_compat_ioctl(struct file *filp,
                               unsigned int cmd,
                               unsigned long arg)
{
    switch (cmd) {
    case MYDEV_SUBMIT_BUF: {
        struct mydev_buf_compat cb;
        struct mydev_buf_native nb;

        if (copy_from_user(&cb, compat_ptr(arg), sizeof(cb)))
            return -EFAULT;

        nb.size = cb.size;
        nb.data = compat_ptr(cb.data);  /* 32→64 포인터 변환 */

        return mydev_submit_buf_internal(filp, &nb);
    }
    default:
        /* 포인터 없는 명령은 네이티브 핸들러로 직접 전달 */
        return mydev_ioctl(filp, cmd, arg);
    }
}

주요 서브시스템 ioctl 사례

터미널 (TTY) ioctl

블록 디바이스 ioctl

네트워크 소켓 ioctl

GPU / DRM ioctl

DRM(Direct Rendering Manager) 서브시스템은 GPU 버퍼 할당, 명령 제출, 모드 설정을 모두 ioctl로 수행합니다. 단일 서브시스템에서 100개 이상의 ioctl을 정의하는 대표적인 사례입니다:

V4L2 비디오 캡처 ioctl 플로우

V4L2는 ioctl을 가장 체계적으로 사용하는 서브시스템 중 하나입니다. 카메라에서 프레임을 캡처하는 전체 ioctl 시퀀스:

KVM ioctl 계층 구조

KVM은 ioctl을 3단계 파일 디스크립터 계층으로 구조화한 대표적인 사례입니다. 각 fd에서 사용 가능한 ioctl 집합이 다릅니다:

NVMe 관리 명령 패스스루

#include <linux/nvme_ioctl.h>

/* NVMe Identify Controller 명령 패스스루 */
struct nvme_admin_cmd cmd = {
    .opcode  = 0x06,       /* Identify */
    .nsid    = 0,
    .addr    = (__u64)(uintptr_t)buf,  /* __u64 포인터 패턴 */
    .data_len = 4096,
    .cdw10   = 1,          /* CNS=1: Controller */
};
ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd);
/* buf에 4096바이트 Identify Controller 데이터 수신됨 */

Watchdog ioctl 커널 내부

/* drivers/watchdog/watchdog_dev.c — 커널 watchdog ioctl 핸들러 (발췌) */
static long watchdog_ioctl(struct file *file,
                           unsigned int cmd,
                           unsigned long arg)
{
    struct watchdog_core_data *wd_data = file->private_data;
    struct watchdog_device *wdd;
    void __user *argp = (void __user *)arg;
    int val;

    mutex_lock(&wd_data->lock);
    wdd = wd_data->wdd;

    switch (cmd) {
    case WDIOC_GETSUPPORT:
        return copy_to_user(argp, wdd->info,
                            sizeof(struct watchdog_info))
               ? -EFAULT : 0;

    case WDIOC_SETTIMEOUT:
        if (get_user(val, (int __user *)argp))
            return -EFAULT;
        /* 드라이버가 실제 적용한 값으로 갱신 */
        wdd->ops->set_timeout(wdd, val);
        wdd->timeout = val;
        /* 설정된 값을 반환 (하드웨어 제한으로 요청과 다를 수 있음) */
        return put_user(wdd->timeout, (int __user *)argp);

    case WDIOC_KEEPALIVE:
        return watchdog_ping(wdd);
    }
    mutex_unlock(&wd_data->lock);
}

ioctl 보안 고려사항

ioctl은 디바이스에 대한 직접 제어를 허용하므로 보안 검증이 필수입니다:

/* 보안 검증 패턴 예시 */
static long mydev_ioctl(struct file *filp,
                        unsigned int cmd,
                        unsigned long arg)
{
    switch (cmd) {
    case MYDEV_FIRMWARE_UPDATE:
        /* 펌웨어 업데이트는 특권 필요 */
        if (!capable(CAP_SYS_ADMIN))
            return -EPERM;
        /* ... */
        break;

    case MYDEV_SET_BUFFER_SIZE: {
        __u32 size;
        if (get_user(size, (__u32 __user *)arg))
            return -EFAULT;
        /* 범위 검증: 4KB ~ 16MB */
        if (size < 4096 || size > (16 << 20))
            return -EINVAL;
        /* ... */
        break;
    }
    }
    return 0;
}

seccomp-BPF를 이용한 ioctl 필터링

컨테이너 환경에서 특정 ioctl 명령만 허용하는 seccomp-BPF 필터 예시:

#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/prctl.h>

/*
 * seccomp-BPF 필터: ioctl 시스템 콜의 두 번째 인자(cmd)를 검사하여
 * TIOCSTI (터미널 입력 삽입) 명령을 차단합니다.
 * 컨테이너 탈출 방지를 위해 Docker 기본 seccomp 프로필에도 포함됨.
 */
struct sock_filter filter[] = {
    /* syscall 번호 로드 */
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
             offsetof(struct seccomp_data, nr)),

    /* ioctl(16)이 아니면 ALLOW */
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_ioctl, 0, 3),

    /* ioctl 두 번째 인자(cmd) 로드 */
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
             offsetof(struct seccomp_data, args[1])),

    /* TIOCSTI(0x5412)이면 KILL */
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, TIOCSTI, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | EPERM),

    /* 그 외 모든 syscall/ioctl 허용 */
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
};

struct sock_fprog prog = {
    .len    = ARRAY_SIZE(filter),
    .filter = filter,
};

prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

ioctl vs. 대안 인터페이스

고급 ioctl 구현 패턴

restartable ioctl (ERESTARTSYS)

ioctl 핸들러가 시그널에 의해 중단될 수 있는 대기를 포함하면, -ERESTARTSYS를 반환하여 시스템 콜을 자동 재시작할 수 있습니다:

case MYDEV_WAIT_EVENT: {
    int ret;

    ret = wait_event_interruptible(priv->wq,
                                   priv->event_ready);
    if (ret)
        return -ERESTARTSYS; /* 시그널 수신 시 자동 재시작 */

    /* 이벤트 데이터를 사용자 공간으로 복사 */
    if (copy_to_user(uarg, &priv->event, sizeof(priv->event)))
        return -EFAULT;
    return 0;
}

ioctl 테이블 디스패치 (DRM 스타일)

많은 ioctl을 관리해야 하는 서브시스템은 테이블 기반 디스패치를 사용합니다. DRM 서브시스템의 drm_ioctl()이 대표적입니다:

/* DRM 스타일: 테이블 기반 ioctl 디스패치 */
struct mydev_ioctl_desc {
    unsigned int cmd;
    int          flags;  /* AUTH_REQUIRED, ROOT_ONLY 등 */
    long (*func)(struct file *, void *);
    size_t       data_size;
};

static const struct mydev_ioctl_desc mydev_ioctls[] = {
    [0] = { MYDEV_GET_STATUS,  0,             mydev_get_status,  sizeof(struct mydev_status) },
    [1] = { MYDEV_SET_CONFIG,  AUTH_REQUIRED, mydev_set_config,  sizeof(struct mydev_config) },
    [2] = { MYDEV_XFER_DATA,  AUTH_REQUIRED, mydev_xfer_data,   sizeof(struct mydev_xfer) },
};

static long mydev_ioctl(struct file *filp,
                        unsigned int cmd, unsigned long arg)
{
    unsigned int nr = _IOC_NR(cmd);
    const struct mydev_ioctl_desc *desc;
    char kdata[128];  /* 스택 버퍼 (작은 구조체용) */

    if (nr >= ARRAY_SIZE(mydev_ioctls))
        return -ENOTTY;

    desc = &mydev_ioctls[nr];
    if (!desc->func)
        return -ENOTTY;

    /* 방향에 따라 copy_from_user 또는 memset */
    if (_IOC_DIR(cmd) & _IOC_WRITE) {
        if (copy_from_user(kdata, (void __user *)arg, desc->data_size))
            return -EFAULT;
    } else {
        memset(kdata, 0, desc->data_size);
    }

    long ret = desc->func(filp, kdata);

    if (!ret && (_IOC_DIR(cmd) & _IOC_READ)) {
        if (copy_to_user((void __user *)arg, kdata, desc->data_size))
            ret = -EFAULT;
    }
    return ret;
}

ioctl 구조체 설계 가이드

ioctl 인터페이스를 올바르게 설계하려면 ABI 안정성, 32/64비트 호환성, 확장성을 고려해야 합니다. 커널 커뮤니티에서 검증된 설계 원칙을 정리합니다:

1. __u64 포인터 패턴 (compat_ioctl 회피)

/* ✗ 나쁜 설계: 포인터 직접 사용 → 32/64비트 크기 달라짐 */
struct bad_ioctl_data {
    __u32 count;
    void *buffer;    /* 4 or 8 bytes! */
};

/* ✓ 좋은 설계: __u64로 포인터 대체 → 항상 동일한 크기 */
struct good_ioctl_data {
    __u32 count;
    __u32 __reserved;    /* 명시적 패딩 */
    __u64 buffer_ptr;    /* 사용자 공간 포인터를 __u64로 */
};

/* 사용자 공간에서: */
data.buffer_ptr = (__u64)(uintptr_t)my_buffer;

/* 커널에서: */
void __user *ubuf = u64_to_user_ptr(data.buffer_ptr);

2. 예약 필드와 플래그를 이용한 확장

/* 확장 가능한 구조체 설계 패턴 */
struct mydev_ioctl_v1 {
    __u32 size;        /* sizeof(struct), 버전 식별 */
    __u32 flags;       /* 비트 플래그 (확장 지점) */
    __u64 data_ptr;
    __u32 data_len;
    __u32 __reserved[3]; /* 향후 확장용, 0으로 설정 필수 */
};

/* 커널 검증: */
if (req.size < sizeof(struct mydev_ioctl_v1))
    return -EINVAL;

/* 예약 필드가 0이 아니면 거부 → 미래 확장 시 호환성 보장 */
if (req.__reserved[0] || req.__reserved[1] || req.__reserved[2])
    return -EINVAL;

/* 알 수 없는 플래그 비트 거부 */
if (req.flags & ~MYDEV_KNOWN_FLAGS)
    return -EINVAL;

3. 정렬 규칙

/* ✗ 나쁜 예: 암묵 패딩, long 사용, packed */
struct bad_layout {
    char   type;      /* offset 0, 7바이트 패딩 발생! */
    long   value;     /* 4 or 8 bytes (아키텍처 의존) */
};

/* ✓ 좋은 예: 명시적 패딩, 고정 크기 타입 */
struct good_layout {
    __u8   type;
    __u8   __pad[3];  /* 명시적 패딩 */
    __u32  flags;
    __u64  value;     /* 8바이트 경계에 정렬 */
}; /* total: 16 bytes, 32/64비트 동일 */

ioctl 디버깅 기법

strace를 이용한 추적

사용자 공간에서 어떤 ioctl이 호출되는지 가장 빠르게 확인하는 방법입니다:

# 특정 프로세스의 ioctl 호출만 필터링
strace -e ioctl -p 1234

# 출력 예시:
# ioctl(3, TCGETS, {B9600 opost isig icanon echo ...}) = 0
# ioctl(4, BLKGETSIZE64, [1000204886016])            = 0
# ioctl(5, SIOCGIFFLAGS, {ifr_name="eth0", ...})     = 0

# 알려지지 않은 ioctl은 16진수로 표시됨
# ioctl(6, _IOC(_IOC_READ, 0x4d, 0x01, 0x10), ...) = 0

ftrace를 이용한 커널 내부 추적

# do_vfs_ioctl 함수 진입 추적
echo "do_vfs_ioctl" > /sys/kernel/debug/tracing/set_ftrace_filter
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
# ... 테스트 실행 ...
cat /sys/kernel/debug/tracing/trace

커널 로그 기반 디버깅

/* 드라이버 내 디버그 출력 */
static long mydev_ioctl(struct file *filp,
                        unsigned int cmd,
                        unsigned long arg)
{
    dev_dbg(priv->dev,
            "ioctl cmd=0x%x dir=%u type=0x%x nr=%u size=%u\n",
            cmd, _IOC_DIR(cmd), _IOC_TYPE(cmd),
            _IOC_NR(cmd), _IOC_SIZE(cmd));
    /* ... */
}

bpftrace를 이용한 ioctl 프로파일링

# 1. 프로세스별 ioctl 호출 빈도 히스토그램
bpftrace -e 'tracepoint:syscalls:sys_enter_ioctl {
    @[comm] = count();
}'

# 2. 특정 디바이스의 ioctl 명령 번호 추적
bpftrace -e 'tracepoint:syscalls:sys_enter_ioctl /comm == "qemu-system-x86"/ {
    printf("pid=%d fd=%d cmd=0x%x\n", pid, args->fd, args->cmd);
}'

# 3. ioctl 지연 시간 측정 (마이크로초)
bpftrace -e '
tracepoint:syscalls:sys_enter_ioctl { @start[tid] = nsecs; }
tracepoint:syscalls:sys_exit_ioctl /@start[tid]/ {
    @usecs = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 4. ioctl cmd 디코딩 (방향/타입/번호/크기)
bpftrace -e 'tracepoint:syscalls:sys_enter_ioctl /pid == $1/ {
    $cmd = args->cmd;
    $dir  = ($cmd >> 30) & 0x3;
    $size = ($cmd >> 16) & 0x3fff;
    $type = ($cmd >> 8) & 0xff;
    $nr   = $cmd & 0xff;
    printf("cmd=0x%x dir=%d type=0x%x nr=%d size=%d\n",
           $cmd, $dir, $type, $nr, $size);
}'

perf trace를 이용한 시스템 콜 프로파일링

# ioctl 시스템 콜만 추적하며 지연 시간 표시
perf trace -e ioctl -p 1234 --duration 0.1

# 출력 예시:
#  0.024 ( 0.003 ms): qemu/1234 ioctl(fd: 11, cmd: KVM_RUN) = 0
#  0.156 ( 0.001 ms): qemu/1234 ioctl(fd: 11, cmd: KVM_RUN) = 0
# --duration 0.1: 0.1ms 이상 걸린 호출만 필터링

# ioctl 호출 통계 요약
perf trace -s -e ioctl -p 1234 -- sleep 5
# 5초간 호출 횟수, 평균/최대 지연 시간 등 요약 출력

성능 고려사항

ioctl은 시스템 콜이므로 사용자↔커널 모드 전환 비용이 발생합니다. 고빈도 제어가 필요한 경우의 최적화 전략:

NVMe 4K 랜덤 읽기 기준 대략적인 성능 비교 (참고 수치):

실제 커널 코드 분석

KVM ioctl — 가상 머신 생성

/* virt/kvm/kvm_main.c — KVM ioctl 핸들러 (발췌) */
static long kvm_dev_ioctl(struct file *filp,
                           unsigned int ioctl,
                           unsigned long arg)
{
    switch (ioctl) {
    case KVM_GET_API_VERSION:
        return KVM_API_VERSION;  /* 정수 직접 반환 */

    case KVM_CREATE_VM:
        return kvm_dev_ioctl_create_vm(arg);

    case KVM_CHECK_EXTENSION:
        return kvm_vm_ioctl_check_extension_generic(NULL, arg);

    default:
        return -EINVAL;
    }
}

/* 사용자 공간 (QEMU): */
/* int kvm_fd = open("/dev/kvm", O_RDWR);         */
/* int vm_fd  = ioctl(kvm_fd, KVM_CREATE_VM, 0);  */
/* int vcpu_fd = ioctl(vm_fd, KVM_CREATE_VCPU, 0); */

블록 디바이스 — BLKGETSIZE64

/* block/ioctl.c — 블록 디바이스 공통 ioctl (발췌) */
static int blkdev_common_ioctl(struct block_device *bdev,
                                unsigned int cmd,
                                unsigned long arg,
                                fmode_t mode)
{
    switch (cmd) {
    case BLKGETSIZE64:
        return put_user(bdev_nr_bytes(bdev),
                        (u64 __user *)arg);

    case BLKSSZGET:
        return put_user(bdev_logical_block_size(bdev),
                        (int __user *)arg);

    case BLKFLSBUF:
        return blkdev_flushbuf(bdev, mode, cmd, arg);
    /* ... */
    }
}

V4L2 ioctl 디스패치 구조

/* drivers/media/v4l2-core/v4l2-ioctl.c (발췌)
 * V4L2는 video_ioctl2()를 통해 테이블 디스패치를 사용합니다.
 * 각 ioctl은 v4l2_ioctls[] 테이블에 정의됩니다.
 */
struct v4l2_ioctl_info {
    unsigned int ioctl;
    u32          flags;       /* INFO_FL_PRIO, INFO_FL_CTRL 등 */
    const char  *name;        /* 디버그용 이름 */
    union {
        int (*func)(const struct v4l2_ioctl_ops *ops,
                    struct file *file, void *fh,
                    void *p);
    } u;
};

/* 테이블 예시 (약 80개 항목 중 일부) */
static const struct v4l2_ioctl_info v4l2_ioctls[] = {
    IOCTL_INFO(VIDIOC_QUERYCAP,   v4l_querycap,    0),
    IOCTL_INFO(VIDIOC_S_FMT,      v4l_s_fmt,       INFO_FL_PRIO),
    IOCTL_INFO(VIDIOC_REQBUFS,    v4l_reqbufs,     INFO_FL_PRIO),
    IOCTL_INFO(VIDIOC_QBUF,       v4l_qbuf,        0),
    IOCTL_INFO(VIDIOC_DQBUF,      v4l_dqbuf,       0),
    IOCTL_INFO(VIDIOC_STREAMON,   v4l_streamon,    INFO_FL_PRIO),
    IOCTL_INFO(VIDIOC_STREAMOFF,  v4l_streamoff,   INFO_FL_PRIO),
    /* ... */
};

DRM ioctl 보안 플래그

/* include/drm/drm_ioctl.h — DRM ioctl 플래그 시스템 */
#define DRM_AUTH       0x1   /* 인증된 클라이언트만 (DRM Master) */
#define DRM_MASTER     0x2   /* DRM Master 전용 */
#define DRM_ROOT_ONLY  0x4   /* root만 (사실상 미사용) */
#define DRM_RENDER_ALLOW 0x20 /* /dev/dri/renderD* 에서 허용 */

/* DRM ioctl 테이블 (발췌) */
static const struct drm_ioctl_desc drm_ioctls[] = {
    DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE,
                  drm_gem_close_ioctl,
                  DRM_RENDER_ALLOW),
    DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC,
                  drm_mode_setcrtc,
                  DRM_MASTER),        /* Master만 디스플레이 설정 */
    DRM_IOCTL_DEF(DRM_IOCTL_PRIME_FD_TO_HANDLE,
                  drm_prime_fd_to_handle_ioctl,
                  DRM_RENDER_ALLOW | DRM_AUTH),
};

실전 튜토리얼: 완전한 ioctl 드라이버

이 섹션에서는 character device에 ioctl을 구현하는 완전한 커널 모듈 예제를 제공합니다. 온도 센서를 시뮬레이션하는 드라이버로, 3가지 ioctl을 지원합니다:

uapi 헤더 (사용자·커널 공유)

/* include/uapi/linux/thermal_sim.h */
#ifndef _UAPI_THERMAL_SIM_H
#define _UAPI_THERMAL_SIM_H

#include <linux/ioctl.h>
#include <linux/types.h>

#define TSIM_MAGIC  'Z'

struct tsim_temp {
    __s32 celsius_m;    /* 밀리섭씨 (예: 42500 = 42.5°C) */
    __u32 flags;         /* 상태 플래그 */
};

struct tsim_config {
    __u32 interval_ms;   /* 샘플링 주기 (밀리초) */
    __u32 threshold_m;   /* 경고 임계값 (밀리섭씨) */
    __u32 flags;
    __u32 __reserved;    /* 확장용, 0 필수 */
};

#define TSIM_GET_TEMP    _IOR(TSIM_MAGIC, 0, struct tsim_temp)
#define TSIM_SET_CONFIG  _IOW(TSIM_MAGIC, 1, struct tsim_config)
#define TSIM_RESET       _IO(TSIM_MAGIC,  2)

#define TSIM_FLAG_CRITICAL  (1 << 0)
#define TSIM_FLAG_ENABLED   (1 << 1)

#endif

커널 모듈 ioctl 핸들러

/* thermal_sim.c — 핵심 ioctl 핸들러 부분 */
static long tsim_ioctl(struct file *filp,
                       unsigned int cmd,
                       unsigned long arg)
{
    struct tsim_dev *dev = filp->private_data;
    void __user *uarg = (void __user *)arg;

    switch (cmd) {
    case TSIM_GET_TEMP: {
        struct tsim_temp temp;

        mutex_lock(&dev->lock);
        temp.celsius_m = dev->current_temp;
        temp.flags = 0;
        if (dev->current_temp >= dev->threshold)
            temp.flags |= TSIM_FLAG_CRITICAL;
        mutex_unlock(&dev->lock);

        if (copy_to_user(uarg, &temp, sizeof(temp)))
            return -EFAULT;
        return 0;
    }

    case TSIM_SET_CONFIG: {
        struct tsim_config cfg;

        if (copy_from_user(&cfg, uarg, sizeof(cfg)))
            return -EFAULT;

        /* 예약 필드 검증 */
        if (cfg.__reserved)
            return -EINVAL;

        /* 범위 검증 */
        if (cfg.interval_ms < 100 || cfg.interval_ms > 60000)
            return -EINVAL;
        if (cfg.threshold_m > 125000)  /* 최대 125°C */
            return -EINVAL;

        mutex_lock(&dev->lock);
        dev->interval = cfg.interval_ms;
        dev->threshold = cfg.threshold_m;
        mutex_unlock(&dev->lock);
        return 0;
    }

    case TSIM_RESET:
        mutex_lock(&dev->lock);
        dev->current_temp = 25000;  /* 25.0°C */
        dev->interval = 1000;       /* 1초 */
        dev->threshold = 85000;     /* 85.0°C */
        mutex_unlock(&dev->lock);
        return 0;

    default:
        return -ENOTTY;
    }
}

static const struct file_operations tsim_fops = {
    .owner          = THIS_MODULE,
    .open           = tsim_open,
    .release        = tsim_release,
    .unlocked_ioctl = tsim_ioctl,
    .compat_ioctl   = compat_ptr_ioctl,
};

사용자 공간 테스트 프로그램

#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "thermal_sim.h"

int main(void)
{
    int fd = open("/dev/tsim0", O_RDWR);
    struct tsim_temp temp;
    struct tsim_config cfg = {
        .interval_ms = 500,
        .threshold_m = 70000,  /* 70.0°C */
    };

    /* 설정 변경 */
    if (ioctl(fd, TSIM_SET_CONFIG, &cfg) < 0)
        perror("SET_CONFIG");

    /* 온도 조회 */
    if (ioctl(fd, TSIM_GET_TEMP, &temp) == 0)
        printf("온도: %d.%03d°C%s\n",
               temp.celsius_m / 1000,
               temp.celsius_m % 1000,
               (temp.flags & TSIM_FLAG_CRITICAL)
                   ? " [경고!]" : "");

    /* 리셋 */
    ioctl(fd, TSIM_RESET, 0);

    close(fd);
    return 0;
}

자주 묻는 질문 (FAQ)