Ioctl

Hardware device configuration

A common use of ioctl is to control hardware devices.

For example, on Win32 systems, ioctl calls can communicate with USB devices, or they can discover drive-geometry information of the attached storage-devices.

On OpenBSD and NetBSD, ioctl is used by the bio(4) pseudo-device driver and the bioctl utility to implement RAID volume management in a unified vendor-agnostic interface similar to ifconfig.^[1][2]

On NetBSD, ioctl is also used by the sysmon framework.^[3]

Terminals

One use of ioctl in code exposed to end-user applications is terminal I/O.

Unix operating systems have traditionally made heavy use of command-line interfaces, originally with hardware text terminals such as VT100s attached to serial ports, and later with terminal emulators and remote login servers using pseudoterminals. Serial port devices and pseudoterminals are both controlled and configured using ioctl calls. For instance, the display size is set using the TIOCSWINSZ call. The TIOCSTI (terminal I/O control, simulate terminal input) ioctl function can push a character into a device stream.^[4]

Kernel extensions

When applications need to extend the kernel, for instance to accelerate network processing, ioctl calls provide a convenient way to bridge userspace code to kernel extensions. Kernel extensions can provide a location in the filesystem that can be opened by name, through which an arbitrary number of ioctl calls can be dispatched, allowing the extension to be programmed without adding system calls to the operating system.

Unix

The ioctl system call first appeared in Version 7 Unix, as a replacement for the stty^[9] and gtty system calls, with an additional request code argument. An ioctl call takes as parameters:

1. an open file descriptor
2. a request code number
3. an untyped pointer to data (either going to the driver, coming back from the driver, or both).

The kernel generally dispatches an ioctl call straight to the device driver, which can interpret the request number and data in whatever way required. The writers of each driver document request numbers for that particular driver and provide them as constants in a header file.

Request numbers usually combine a code identifying the device or class of devices for which the request is intended and a number indicating the particular request; the code identifying the device or class of devices is usually a single ASCII character. Some Unix systems, including 4.2BSD and later BSD releases, operating systems derived from those releases, and Linux, have conventions that also encode within the request number the size of the data to be transferred to/from the device driver and the direction of the data transfer. Regardless of whether any such conventions are followed, the kernel and the driver collaborate to deliver a uniform error code (denoted by the symbolic constant ENOTTY) to an application which makes a request of a driver which does not recognise it.

The mnemonic ENOTTY (traditionally associated with the textual message "Not a typewriter") derives from the earliest systems that incorporated an ioctl call, where only the teletype (tty) device raised this error. Though the symbolic mnemonic is fixed by compatibility requirements, some modern systems more helpfully render a more general message such as "Inappropriate device control operation" (or a localization thereof).

TCSETS exemplifies an ioctl call on a serial port. The normal read and write calls on a serial port receive and send data bytes. An ioctl(fd,TCSETS,data) call, separate from such normal I/O, controls various driver options like handling of special characters, or the output signals on the port (such as the DTR signal).

Win32

A Win32 DeviceIoControl takes as parameters:

1. an open object handle (the Win32 equivalent of a file descriptor)
2. a request code number (the "control code")
3. a buffer for input parameters
4. length of the input buffer
5. a buffer for output results
6. length of the output buffer
7. an OVERLAPPED structure, if overlapped I/O is being used.

The Win32 device control code takes into consideration the mode of the operation being performed.

There are 4 defined modes of operation, impacting the security of the device driver -

1. METHOD_IN_DIRECT: The buffer address is verified to be readable by the user mode caller.
2. METHOD_OUT_DIRECT: The buffer address is verified to be writable by the user mode caller.
3. METHOD_NEITHER: User mode virtual addresses are passed to the driver without mapping or validation.
4. METHOD_BUFFERED: IO Manager controlled shared buffers are used to move data to and from user mode.

Other vectored call interfaces

Devices and kernel extensions may be linked to userspace using additional new system calls, although this approach is rarely taken, because operating system developers try to keep the system call interface focused and efficient.

On Unix operating systems, two other vectored call interfaces are popular: the fcntl ("file control") system call configures open files, and is used in situations such as enabling non-blocking I/O; and the setsockopt ("set socket option") system call configures open network sockets, a facility used to configure the ipfw packet firewall on BSD Unix systems.

Memory mapping

Unix

Device interfaces and input/output capabilities are sometimes provided using memory-mapped files. Applications that interact with devices open a location on the filesystem corresponding to the device, as they would for an ioctl call, but then use memory mapping system calls to tie a portion of their address space to that of the kernel. This interface is a far more efficient way to provide bulk data transfer between a device and a userspace application; individual ioctl or read/write system calls inflict overhead due to repeated userspace-to-kernel transitions, where access to a memory-mapped range of addresses incurs no such overhead.

Win32

Buffered IO methods or named file mapping objects can be used; however, for simple device drivers the standard DeviceIoControl METHOD_ accesses are sufficient.

Netlink

Netlink is a socket-like mechanism for inter-process communication (IPC), designed to be a more flexible successor to ioctl.

Complexity

ioctl calls minimize the complexity of the kernel's system call interface. However, by providing a place for developers to "stash" bits and pieces of kernel programming interfaces, ioctl calls complicate the overall user-to-kernel API. A kernel that provides several hundred system calls may provide several thousand ioctl calls.

Though the interface to ioctl calls appears somewhat different from conventional system calls, there is in practice little difference between an ioctl call and a system call; an ioctl call is simply a system call with a different dispatching mechanism. Many of the arguments against expanding the kernel system call interface could therefore be applied to ioctl interfaces.

To application developers, system calls appear no different from application subroutines; they are simply function calls that take arguments and return values. The core libraries (e.g. libc) mask the complexity involved in invoking system calls. The same is true for ioctls, where driver interfaces usually come with a user space library. (E.g. Mesa for the Direct Rendering Infrastructure of graphics drivers.)

Libpcap and libdnet are two examples of third-party wrapper Unix libraries designed to mask the complexity of ioctl interfaces, for packet capture and packet I/O, respectively.

Security

This section does not cite any sources. (December 2024)

In traditional design, kernels resided in ring 0, separated from device drivers in ring 1, and in microkernels, also from each other. This has largely been given up due adding the same overhead of transitioning between rings to driver/kernel interfaces, that syscalls impose on kernel/user space interfaces. This has led to the difficult-in-practice requirement that all drivers, which now reside in ring 0 as well, must uphold the same level of security as the kernel core.

While the user-to-kernel interfaces of mainstream operating systems are often audited heavily for code flaws and security vulnerabilities prior to release, these audits typically focus on the well-documented system call interfaces. For instance, auditors might ensure that sensitive security calls such as changing user IDs are only available to administrative users.
Because the handler for an ioctl call also resides directly in ring 0, the input from userspace should be validated just as carefully. As vulnerabilities in device drivers can be exploited by local users, e.g. by passing invalid buffers to ioctl calls.
In practice, this is not the case. ioctl interfaces are larger, more diverse, and less well defined, and thus harder to audit than system calls. Furthermore, because ioctl calls can be provided by third-party developers, often after the core operating system has been released, ioctl call implementations may generally receive less scrutiny and thus harbor more vulnerabilities. Finally, some ioctl calls, particularly for third-party device drivers, can be entirely undocumented.

Varying fixes for this have been created, with the goal of achieving an equivalent to the former security, while keeping the gained speed.
Win32 and Unix operating systems can protect a userspace device name from access by applications with specific access controls applied to the device. Security problems can arise when device driver developers do not apply appropriate access controls to the userspace accessible object.
Some modern operating systems protect the kernel from hostile userspace code (such as applications that have been infected by buffer overflow exploits) using system call wrappers. System call wrappers implement role-based access control by specifying which system calls can be invoked by which applications; wrappers can, for instance, be used to "revoke" the right of a mail program to spawn other programs. ioctl interfaces complicate system call wrappers because there are large numbers of them, each taking different arguments, some of which may be required by normal programs.
Furthermore, such solutions negate the gained reduction of overhead.