ioctl 시스템 콜(System Call)

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

ioctl 개요와 역사

ioctl은 1970년대 Unix V7에서 터미널 장치 제어를 위해 도입되었습니다. read/write는 바이트 스트림 전달에 특화되어 있어, "보드레이트 변경", "버퍼(Buffer) 플러시(Flush)", "하드웨어 레지스터(Register) 설정" 같은 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 타이머(Timer) 설정 (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비트 사용자 프로세스(Process)가 ioctl을 호출하면, 포인터 크기와 구조체 패딩(Padding)이 다를 수 있습니다. 이를 처리하는 것이 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 핸들러가 시그널(Signal)에 의해 중단될 수 있는 대기를 포함하면, -ERESTARTSYS를 반환하여 시스템 콜을 자동 재시작(Reboot)할 수 있습니다:

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 프로파일링(Profiling)

# 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을 구현하는 완전한 커널 모듈(Kernel Module) 예제를 제공합니다. 온도 센서를 시뮬레이션하는 드라이버로, 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;
}

ioctl 번호 디코딩 실습

실제 ioctl 번호를 비트 단위로 분해하여 의미를 파악하는 방법을 실습합니다. strace 출력이나 커널 로그에서 16진수 ioctl 번호를 만났을 때 유용합니다.

셸에서 디코딩

#!/bin/bash
# ioctl 번호 디코더
decode_ioctl() {
    local cmd=$1
    local dir=$(( (cmd >> 30) & 0x3 ))
    local size=$(( (cmd >> 16) & 0x3FFF ))
    local type=$(( (cmd >> 8) & 0xFF ))
    local nr=$(( cmd & 0xFF ))

    local dir_str
    case $dir in
        0) dir_str="NONE (_IO)" ;;
        1) dir_str="WRITE (_IOW, 사용자→커널)" ;;
        2) dir_str="READ (_IOR, 커널→사용자)" ;;
        3) dir_str="READ|WRITE (_IOWR)" ;;
    esac

    printf "cmd=0x%08X\n" "$cmd"
    printf "  direction : %d (%s)\n" "$dir" "$dir_str"
    printf "  size      : %d bytes\n" "$size"
    printf "  type      : 0x%02X ('%c')\n" "$type" "$type"
    printf "  nr        : %d\n" "$nr"
}

# 예시: TCGETS = 0x5401 (구형, 인코딩 없음)
decode_ioctl 0x5401

# 예시: KVM_CREATE_VM = _IO(0xAE, 0x01) = 0x0000AE01
decode_ioctl 0xAE01

# 예시: KVM_GET_API_VERSION = _IO(0xAE, 0x00)
decode_ioctl 0xAE00

C 코드에서 디코딩

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

void decode_ioctl(unsigned int cmd)
{
    printf("cmd=0x%08X\n", cmd);
    printf("  dir  = %u\n", _IOC_DIR(cmd));
    printf("  type = 0x%02X ('%c')\n", _IOC_TYPE(cmd), _IOC_TYPE(cmd));
    printf("  nr   = %u\n", _IOC_NR(cmd));
    printf("  size = %u\n", _IOC_SIZE(cmd));
}

int main(void)
{
    /* V4L2 VIDIOC_QUERYCAP = _IOR('V', 0, struct v4l2_capability) */
    decode_ioctl(0x80685600);
    return 0;
}

고급 보안 패턴

ioctl 핸들러에서 발생할 수 있는 보안 취약점과 이를 방지하는 심층 방어(Defense-in-Depth) 패턴을 다룹니다.

TOCTOU 방지

사용자 공간 데이터를 두 번 읽으면 Time-of-Check-Time-of-Use(TOCTOU) 취약점이 발생할 수 있습니다:

/* ✗ 위험: TOCTOU — 두 번째 copy_from_user 사이에 값이 변경될 수 있음 */
if (copy_from_user(&hdr, uarg, sizeof(hdr)))
    return -EFAULT;
if (hdr.size > MAX_SIZE)   /* 검증 */
    return -EINVAL;
/* ... 다른 스레드가 hdr.size를 변경 가능 ... */
copy_from_user(buf, uarg, hdr.size);  /* 다시 읽으면 변경된 값! */

/* ✓ 안전: 한 번만 복사하고 커널 복사본 사용 */
if (copy_from_user(&hdr, uarg, sizeof(hdr)))
    return -EFAULT;
if (hdr.size > MAX_SIZE)
    return -EINVAL;
/* hdr.size는 커널 메모리에 있으므로 변경 불가 */
if (copy_from_user(buf, u64_to_user_ptr(hdr.data_ptr), hdr.size))
    return -EFAULT;

세밀한 Capability 검사

/* 명령별 차등 권한 검사 패턴 */
static long mydev_ioctl(struct file *filp,
                        unsigned int cmd, unsigned long arg)
{
    /* 읽기 전용 명령 — 권한 불필요 */
    switch (cmd) {
    case MYDEV_GET_INFO:
    case MYDEV_GET_STATUS:
        break;  /* 누구나 호출 가능 */

    /* 설정 변경 — CAP_NET_ADMIN (네트워크 디바이스인 경우) */
    case MYDEV_SET_OFFLOAD:
    case MYDEV_SET_RING_SIZE:
        if (!capable(CAP_NET_ADMIN))
            return -EPERM;
        break;

    /* 하드웨어 직접 제어 — CAP_SYS_RAWIO */
    case MYDEV_REG_READ:
    case MYDEV_REG_WRITE:
        if (!capable(CAP_SYS_RAWIO))
            return -EPERM;
        break;

    /* 펌웨어/구성 영구 변경 — CAP_SYS_ADMIN */
    case MYDEV_FLASH_FW:
        if (!capable(CAP_SYS_ADMIN))
            return -EPERM;
        break;
    }

    /* ... 실제 처리 ... */
}

입력 데이터 검증 체크리스트

/* 종합 검증 패턴 */
static int validate_request(const struct mydev_request *req)
{
    /* 1. 구조체 크기 검증 (버전 호환) */
    if (req->size < MYDEV_REQUEST_MIN_SIZE)
        return -EINVAL;

    /* 2. 알 수 없는 플래그 거부 */
    if (req->flags & ~MYDEV_VALID_FLAGS)
        return -EINVAL;

    /* 3. 예약 필드가 0인지 확인 */
    if (req->__reserved[0] || req->__reserved[1])
        return -EINVAL;

    /* 4. 범위 검증 — 정수 오버플로 방지 */
    if (req->offset > MAX_OFFSET)
        return -EINVAL;
    if (req->length > MAX_LENGTH ||
        req->offset + req->length < req->offset)  /* 오버플로 검사 */
        return -EINVAL;

    /* 5. 정렬 검사 */
    if (req->offset & (MYDEV_ALIGN - 1))
        return -EINVAL;

    return 0;
}

ioctl 래퍼 라이브러리 설계

ioctl 인터페이스를 사용자 공간에서 안전하게 활용하려면 래퍼(Wrapper) 라이브러리를 설계하는 것이 좋습니다. 타입 안전성과 에러 처리를 일관되게 제공합니다.

/* libmydev.h — 타입 안전 래퍼 */
#ifndef LIBMYDEV_H
#define LIBMYDEV_H

#include <linux/mydev_uapi.h>

struct mydev_handle;

/* 디바이스 열기/닫기 */
struct mydev_handle *mydev_open(const char *path);
void mydev_close(struct mydev_handle *h);

/* 타입 안전 ioctl 래퍼 */
int mydev_get_status(struct mydev_handle *h,
                     struct mydev_status *out);
int mydev_set_config(struct mydev_handle *h,
                     const struct mydev_config *cfg);
int mydev_reset(struct mydev_handle *h);

/* 에러 정보 */
const char *mydev_strerror(int err);

#endif

/* libmydev.c — 구현 */
#include "libmydev.h"
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>

struct mydev_handle {
    int fd;
    int last_errno;
};

int mydev_get_status(struct mydev_handle *h,
                     struct mydev_status *out)
{
    int ret = ioctl(h->fd, MYDEV_GET_STATUS, out);
    if (ret < 0) {
        h->last_errno = errno;
        return -errno;
    }
    return 0;
}

int mydev_set_config(struct mydev_handle *h,
                     const struct mydev_config *cfg)
{
    /* 사용자 측에서도 사전 검증 */
    if (!cfg || cfg->interval_ms == 0)
        return -EINVAL;

    int ret = ioctl(h->fd, MYDEV_SET_CONFIG, cfg);
    if (ret < 0) {
        h->last_errno = errno;
        return -errno;
    }
    return 0;
}

ioctl 테스트 패턴

커널 ioctl 인터페이스를 체계적으로 검증하기 위한 테스트 패턴을 소개합니다.

네거티브 테스트

/* 잘못된 명령 번호 테스트 */
static void test_invalid_cmd(int fd)
{
    int ret;

    /* 존재하지 않는 ioctl 명령 */
    ret = ioctl(fd, _IO('M', 255), 0);
    assert(ret == -1 && errno == ENOTTY);

    /* NULL 포인터 전달 (포인터 인자 필수 명령) */
    ret = ioctl(fd, MYDEV_GET_STATUS, NULL);
    assert(ret == -1 && errno == EFAULT);

    /* 잘못된 fd */
    ret = ioctl(-1, MYDEV_RESET, 0);
    assert(ret == -1 && errno == EBADF);

    /* 범위 초과 값 */
    struct mydev_config cfg = { .interval_ms = 0 };  /* 0은 무효 */
    ret = ioctl(fd, MYDEV_SET_CONFIG, &cfg);
    assert(ret == -1 && errno == EINVAL);
}

/* 권한 테스트 */
static void test_privilege(int fd)
{
    /* 비특권 사용자로 특권 명령 호출 */
    int ret = ioctl(fd, MYDEV_FLASH_FW, &fw_data);
    if (getuid() != 0)
        assert(ret == -1 && errno == EPERM);
}

/* 스트레스 테스트: 다중 스레드에서 ioctl 동시 호출 */
static void *stress_worker(void *arg)
{
    int fd = *(int *)arg;
    for (int i = 0; i < 10000; i++) {
        struct mydev_status st;
        ioctl(fd, MYDEV_GET_STATUS, &st);
    }
    return NULL;
}

32비트 호환 테스트

# 64비트 커널에서 32비트 바이너리로 ioctl 테스트
# 크로스 컴파일:
gcc -m32 -o test_ioctl_32 test_ioctl.c
./test_ioctl_32

# strace로 compat_ioctl 경로 확인
strace -e trace=ioctl ./test_ioctl_32 2>&1
# compat_ioctl이 올바르게 호출되는지 확인

# ioctl 구조체 크기가 32/64비트에서 동일한지 확인
# (C 코드에서 sizeof 비교)
gcc -m32 -o check32 -c check_sizeof.c
gcc -m64 -o check64 -c check_sizeof.c
# 출력이 동일하면 compat_ptr_ioctl로 충분

ioctl 퍼징(Fuzzing)

syzkaller는 ioctl을 포함한 시스템 콜 퍼징(Fuzzing)을 위한 대표적인 커널 퍼저입니다:

# syzkaller용 ioctl 디스크립션 예시
resource fd_mydev[fd]

openat$mydev(fd const[AT_FDCWD], file ptr[in, string["/dev/mydev"]],
             flags flags[open_flags]) fd_mydev

ioctl$MYDEV_RESET(fd fd_mydev, cmd const[MYDEV_RESET])
ioctl$MYDEV_GET_STATUS(fd fd_mydev, cmd const[MYDEV_GET_STATUS],
                       arg ptr[out, mydev_status])
ioctl$MYDEV_SET_CONFIG(fd fd_mydev, cmd const[MYDEV_SET_CONFIG],
                       arg ptr[in, mydev_config])

mydev_status {
    value   int32
    flags   int32
}

mydev_config {
    interval_ms int32[1:10000]
    threshold   int32[0:100000]
    flags       flags[mydev_config_flags]
    reserved    const[0, int32]
}

mydev_config_flags = MYDEV_FLAG_AUTO, MYDEV_FLAG_VERBOSE

io_uring_cmd와 ioctl 통합

Linux 5.19+에서 도입된 io_uring_cmd를 통해 기존 ioctl 명령을 비동기로 실행할 수 있습니다. 드라이버 측에서 두 경로를 모두 지원하는 패턴입니다.

/* ioctl과 io_uring_cmd를 통합 지원하는 드라이버 */
static int mydev_do_cmd(struct mydev_priv *priv,
                       unsigned int cmd,
                       void __user *uarg,
                       bool async)
{
    /* 공통 명령 처리 로직 */
    switch (cmd) {
    case MYDEV_SUBMIT: {
        struct mydev_submit sub;
        if (copy_from_user(&sub, uarg, sizeof(sub)))
            return -EFAULT;
        return mydev_submit_cmd(priv, &sub, async);
    }
    default:
        return -ENOTTY;
    }
}

/* 전통적 ioctl 경로 (동기) */
static long mydev_ioctl(struct file *filp,
                        unsigned int cmd, unsigned long arg)
{
    return mydev_do_cmd(filp->private_data, cmd,
                        (void __user *)arg, 0);
}

/* io_uring passthrough 경로 (비동기) */
static int mydev_uring_cmd(struct io_uring_cmd *ioucmd,
                          unsigned int issue_flags)
{
    struct file *filp = ioucmd->file;
    unsigned int cmd = ioucmd->cmd_op;
    void __user *uarg = io_uring_sqe_cmd(ioucmd->sqe);

    return mydev_do_cmd(filp->private_data, cmd, uarg, 1);
}

static const struct file_operations mydev_fops = {
    .owner          = THIS_MODULE,
    .unlocked_ioctl = mydev_ioctl,
    .uring_cmd      = mydev_uring_cmd,     /* io_uring passthrough */
    .uring_cmd_iopoll = mydev_uring_poll,  /* 폴링 모드 (선택) */
};

고급 디버깅 기법

ioctl 관련 문제를 추적하기 위한 고급 기법을 소개합니다.

ftrace로 ioctl 핸들러 추적

# 1. 특정 ioctl 핸들러의 함수 호출 그래프
cd /sys/kernel/debug/tracing
echo function_graph > current_tracer
echo mydev_ioctl > set_graph_function
echo 1 > tracing_on

# 사용자 공간에서 ioctl 호출
./test_mydev

# 결과 확인
cat trace
#  1)               |  mydev_ioctl() {
#  1)   0.245 us    |    _copy_from_user();
#  1)               |    mydev_apply_config() {
#  1)   1.032 us    |      mutex_lock();
#  1)   0.150 us    |      mydev_hw_write();
#  1)   0.098 us    |      mutex_unlock();
#  1)   2.540 us    |    }
#  1)   3.890 us    |  }

echo 0 > tracing_on

strace 고급 활용

# ioctl 호출만 필터링, 16진수 값 포함
strace -e trace=ioctl -v -x ./my_app 2>&1

# 특정 fd의 ioctl만 필터 (fd=3)
strace -e trace=ioctl -e inject=ioctl:when=1..5 ./my_app

# 타임스탬프와 소요 시간 포함
strace -e trace=ioctl -r -T ./my_app

# ioctl 에러 원인 분석 (errno 포함)
strace -e trace=ioctl -Z ./my_app 2>&1 | head -20
# 출력 예시:
# ioctl(3, _IOC(_IOC_WRITE, 0x4d, 0x02, 0x10), 0x7ffd..) = -1 EPERM (Operation not permitted)

# perf를 이용한 ioctl 지연 시간 측정
perf trace -e ioctl --duration 100 ./my_app

kprobe를 이용한 동적 추적

# mydev_ioctl 진입 시 cmd 인자 로깅
cd /sys/kernel/debug/tracing
echo 'p:myioctl mydev_ioctl cmd=%si:x32' > kprobe_events
echo 1 > events/kprobes/myioctl/enable
echo 1 > tracing_on

# 테스트 후 확인
cat trace_pipe
# test_app-1234  [001] ....  1234.567: myioctl: (mydev_ioctl+0x0/0x1a0) cmd=0x40104d02

# 정리
echo 0 > events/kprobes/myioctl/enable
echo '-:myioctl' > kprobe_events

ioctl 에러 코드 참조

ioctl에서 반환하는 주요 에러 코드와 올바른 사용 시나리오를 정리합니다:

ioctl 커널 버전별 주요 변화

copy_struct_from_user() — 확장 가능 구조체 복사

커널 5.5+에서 도입된 copy_struct_from_user()는 구조체 버전 차이를 자동 처리합니다:

/* 확장 가능 구조체 복사 — 구 커널 사용자/신 커널, 신 커널 사용자/구 커널 모두 처리 */
struct mydev_cmd_v2 cmd = {};  /* 먼저 0으로 초기화 */

/* ksize: 커널이 아는 구조체 크기
 * usize: 사용자 공간이 전달한 크기 (cmd.size 필드)
 *
 * usize < ksize → 새 필드를 0으로 유지 (하위 호환)
 * usize > ksize → 초과 부분이 0인지 확인 (상위 호환)
 * usize == ksize → 그대로 복사
 */
int err = copy_struct_from_user(&cmd, sizeof(cmd),
                                uarg, usize);
if (err)
    return err;

자주 묻는 질문 (FAQ)

참고자료

커널 공식 문서

• ioctl based interfaces — ioctl 기반 인터페이스 공식 문서
• ioctl number — ioctl 번호 할당 규칙 및 기존 매직 넘버 목록
• ioctl — Driver ioctl — 드라이버 ioctl 핸들러 작성 가이드
• Adding a New System Call — 새 시스템 콜 추가 방법 (ioctl 대안 검토 시 참고)

커널 소스 코드

• include/uapi/asm-generic/ioctl.h — _IO, _IOR, _IOW, _IOWR 매크로 정의
• fs/ioctl.c — vfs_ioctl, do_vfs_ioctl 구현
• include/linux/fs.h — unlocked_ioctl, compat_ioctl 함수 포인터 정의
• include/uapi/linux/kd.h — 콘솔 ioctl 명령 예시 (KDSETMODE 등)
• include/uapi/linux/fb.h — 프레임버퍼 ioctl 명령 예시 (FBIOGET_VSCREENINFO 등)
• include/uapi/linux/videodev2.h — V4L2 ioctl 명령 예시 (VIDIOC_* 매크로)
• fs/compat_ioctl.c — 32비트 호환 ioctl 처리

외부 자료

• The new way of ioctl() — BKL 제거와 unlocked_ioctl 도입 배경
• ioctl(): not dead yet — ioctl 인터페이스의 장단점과 미래 전망
• LDD3 Chapter 6: Advanced Char Driver Operations — ioctl, blocking I/O, poll 등 고급 문자 디바이스 기법
• ioctl() in drivers: do it right — 드라이버에서 ioctl을 올바르게 구현하는 방법