In
Unix-like
A Unix-like (sometimes referred to as UN*X, *nix or *NIX) operating system is one that behaves in a manner similar to a Unix system, although not necessarily conforming to or being certified to any version of the Single UNIX Specification. A Uni ...
operating systems, a device file, device node, or special file is an
interface to a
device driver that appears in a
file system as if it were an ordinary
file. There are also special files in
DOS,
OS/2
OS/2 is a Proprietary software, proprietary computer operating system for x86 and PowerPC based personal computers. It was created and initially developed jointly by IBM and Microsoft, under the leadership of IBM software designer Ed Iacobucci, ...
, and
Windows. These special files allow an application program to interact with a device by using its device driver via standard
input/output
In computing, input/output (I/O, i/o, or informally io or IO) is the communication between an information processing system, such as a computer, and the outside world, such as another computer system, peripherals, or a human operator. Inputs a ...
system calls. Using standard system calls simplifies many programming tasks, and leads to consistent user-space I/O mechanisms regardless of device features and functions.
Overview
Device files usually provide simple interfaces to standard devices (such as printers and serial ports), but can also be used to access specific unique resources on those devices, such as
disk partitions. Additionally, device files are useful for accessing
system resources that have no connection with any actual device, such as
data sinks and
random number generators.
There are two general kinds of device files in Unix-like operating systems, known as ''character special files'' and ''block special files''. The difference between them lies in how much data is read and written by the operating system and hardware. These together can be called device special files in contrast to
named pipes, which are not connected to a device but are not ordinary files either.
MS-DOS borrowed the concept of special files from Unix but renamed them ''devices''.
[ Because early versions of MS-DOS did not support a directory hierarchy, devices were distinguished from regular files by making their names reserved words that cannot be used as folder or file names; for example: the word ]CON
is a reserved word. These were chosen for a degree of compatibility with CP/M and are still present in modern Windows for backwards compatibility. Names are not case-sensitive, so "con", "Con", and "CON" are all invalid names.
In Windows XP
Windows XP is a major release of Microsoft's Windows NT operating system. It was released to manufacturing on August 24, 2001, and later to retail on October 25, 2001. It is a direct successor to Windows 2000 for high-end and business users a ...
, entering "Con" into the Run command returns the error message, "This file does not have a program associated with it for performing this action. Create an association in the Folder Options control panel." Attempting to rename any file or folder using a reserved name silently reverts the file or folder to its previous name (or "New Folder", "New Text Document", etc.), with no notification or error message. In Windows Vista
Windows Vista is a major release of the Windows NT operating system developed by Microsoft. It was the direct successor to Windows XP, released five years earlier, which was then the longest time span between successive releases of Microsoft W ...
and later, attempting to use a reserved name for a file or folder brings up an error message saying, "The specified device name is invalid."[
In some Unix-like systems, most device files are managed as part of a virtual file system traditionally mounted at ]/dev
, possibly associated with a controlling daemon, which monitors hardware addition and removal at run time, making corresponding changes to the device file system if that's not automatically done by the kernel, and possibly invoking scripts in system or user space to handle special device needs. The FreeBSD, DragonFly BSD and Darwin have a dedicated file system ''devfs''; device nodes are managed automatically by this file system, in kernel space. Linux used to have a similar ''devfs'' implementation, but it was abandoned later, and then removed since version 2.6.17; Linux now primarily uses a user space implementation known as '' udev'', but there are many variants.
In Unix systems which support chroot process isolation, such as Solaris Containers, typically each chroot environment needs its own /dev
; these mount points will be visible on the host OS at various nodes in the global file system tree. By restricting the device nodes populated into chroot instances of /dev
, hardware isolation can be enforced by the chroot environment (a program can not meddle with hardware that it can neither see nor nameāan even stronger form of access control
In physical security and information security, access control (AC) is the action of deciding whether a subject should be granted or denied access to an object (for example, a place or a resource). The act of ''accessing'' may mean consuming ...
than Unix file system permissions).
MS-DOS managed hardware device contention (see terminate-and-stay-resident program
A terminate-and-stay-resident program (commonly TSR) is a computer program running under DOS that uses a system call to return control to DOS as though it has finished, but remains in computer memory so it can be reactivated later. This techni ...
) by making each device file exclusive open. An application attempting to access a device already in use would discover itself unable to open the device file node. A variety of device driver semantics are implemented in Unix and Linux concerning concurrent access.
Unix and Unix-like systems
Device nodes correspond to resources that an operating system's kernel has already allocated. Unix identifies those resources by a ''major number'' and a ''minor number'', both stored as part of the structure of a node. The assignment of these numbers occurs uniquely in different operating system
An operating system (OS) is system software that manages computer hardware and software resources, and provides common daemon (computing), services for computer programs.
Time-sharing operating systems scheduler (computing), schedule tasks for ...
s and on different computer platforms. Generally, the major number identifies the device driver and the minor number identifies a particular device (possibly out of many) that the driver controls: in this case, the system may pass the minor number to a driver. However, in the presence of dynamic number allocation, this may not be the case (e.g. on FreeBSD 5 and up).
As with other special file types, the computer system accesses device nodes using standard system calls and treats them like regular computer files. Two standard types of device files exist; unfortunately their names are rather counter-intuitive for historical reasons, and explanations of the difference between the two are often incorrect as a result.
Character devices
''Character special files'' or ''character devices'' provide unbuffered, direct access to the hardware device. They do not necessarily allow programs to read or write single characters at a time; that is up to the device in question. The character device for a hard disk, for example, will normally require that all reads and writes be aligned to block boundaries and most certainly will not allow reading a single byte.
Character devices are sometimes known as '' raw devices'' to avoid the confusion surrounding the fact that a character device for a piece of block-based hardware will typically require programs to read and write aligned blocks.
Block devices
''Block special files'' or ''block devices'' provide buffered access to hardware devices, and provide some abstraction from their specifics. Unlike character devices, block devices will always allow the programmer to read or write a block of any size (including single characters/bytes) and any alignment. The downside is that because block devices are buffered, the programmer does not know how long it will take before written data is passed from the kernel's buffers to the actual device, or indeed in what order two separate writes will arrive at the physical device. Additionally, if the same hardware exposes both character and block devices, there is a risk of data corruption due to clients using the character device being unaware of changes made in the buffers of the block device.
Most systems create both block and character devices to represent hardware like hard disks. FreeBSD and Linux notably do not; the former has removed support for block devices, while the latter creates only block devices. To get the effect of a character device from a block device on Linux, one must open the device with the Linux-specific flag.
Pseudo-devices
Device nodes on Unix-like systems do not necessarily have to correspond to physical devices. Nodes that lack this correspondence are called ''pseudo-devices''. They provide various functions handled by the operating system. Some of the most commonly used (character-based) pseudo-devices include:
* accepts and discards all input written to it; provides an end-of-file indication when read from.
* accepts and discards all input written to it; produces a continuous stream of null characters (zero-value bytes) as output when read from.
* produces a continuous stream of null characters (zero-value bytes) as output when read from, and generates an ("disk full") error when attempting to write to it.
* produces bytes generated by the kernel's cryptographically secure pseudorandom number generator. Its exact behavior varies by implementation, and sometimes variants such as or are also provided.
* , , access the process's standard streams.
* ''n'' accesses the process's file descriptor ''n''.
Additionally, BSD-specific pseudo-devices with an interface may also include:
* allows userland processes to control PF through an interface.
* provides access to devices otherwise not found as nodes, used by to implement RAID
RAID (; redundant array of inexpensive disks or redundant array of independent disks) is a data storage virtualization technology that combines multiple physical Computer data storage, data storage components into one or more logical units for th ...
management in OpenBSD and NetBSD.
* used by NetBSD's envsys framework for hardware monitoring, accessed in the userland through by the utility.[
*]
Node creation
Nodes are created by the system call. The command-line program for creating nodes is also called . Nodes can be moved or deleted by the usual filesystem system calls (, ) and commands (, ).
Some Unix versions include a script named ''makedev'' or ''MAKEDEV'' to create all necessary devices in the directory . It only makes sense on systems whose devices are statically assigned major numbers (e.g., by means of hardcoding it in their kernel module).
Some other Unix systems such as FreeBSD use kernel-based device node management via devfs only and do not support manual node creation. system call and command exist to keep compatibility with POSIX, but manually created device nodes outside devfs will not function at all.
Naming conventions
The following prefixes are used for the names of some devices in the hierarchy, to identify the type of device:
* : line printers (compare lp)
* : pseudo-terminals
* : terminals
Some additional prefixes have come into common use in some operating systems:
* : frame buffer
* : (platform) floppy disks, though this same abbreviation is also commonly used to refer to file descriptor
* : ("classic") IDE driver (previously used for ATA hard disk drive
A hard disk drive (HDD), hard disk, hard drive, or fixed disk is an electro-mechanical data storage device that stores and retrieves digital data using magnetic storage with one or more rigid rapidly rotating hard disk drive platter, pla ...
, ATAPI optical disc drives, etc.)
** : the primary device on the first ATA channel (usually identified by major number 3 and minor number 0)
** : the secondary device on the first ATA channel
** : the primary device on the second ATA channel
** : the secondary device on the second ATA channel
* , : parallel ports
* : Main memory (character device)
* : Network block device: Abstraction that represents block devices that are mounted through the network (or from images using qemu-nbd)
* NVMe driver:
** : first registered device's device controller (character device)
** : first registered device's first namespace (block device)
** : first registered device's first namespace's first partition (block device)
* MMC driver:
** : storage driver for MMC media ( SD cards, eMMC chips on laptops, etc.)
*** : first registered device
*** : first registered device's first partition
* SCSI driver, also used by libATA (modern PATA/ SATA driver), USB, IEEE 1394, etc.:
** : mass-storage driver (block device)
*** : first registered device
*** , etc.: second, third, etc. registered devices
** : Enclosure driver
** : generic SCSI layer
** : "ROM" driver (data-oriented optical disc drives; scd is just a secondary alias)
** : magnetic tape
Magnetic tape is a medium for magnetic storage made of a thin, magnetizable coating on a long, narrow strip of plastic film. It was developed in Germany in 1928, based on the earlier magnetic wire recording from Denmark. Devices that use magnetic ...
driver
* : terminals
** : (platform) serial port
A serial port is a serial communication Interface (computing), interface through which information transfers in or out sequentially one bit at a time. This is in contrast to a parallel port, which communicates multiple bits simultaneously in Pa ...
driver
** : USB serial converters, modems, etc.
The canonical list of the prefixes used in Linux can be found in the Linux Device List, the official registry of allocated device numbers and directory nodes for the Linux operating system.
For most devices, this prefix is followed by a number uniquely identifying the particular device. For hard drives, a letter is used to identify devices and is followed by a number to identify partitions. Thus a file system may "know" an area on a disk as , for example, or "see" a networked terminal session as associated with .
On disks using the typical PC master boot record
A master boot record (MBR) is a type of boot sector in the first block of disk partitioning, partitioned computer mass storage devices like fixed disks or removable drives intended for use with IBM PC-compatible systems and beyond. The concept ...
, the device numbers of primary and the optional extended partition are numbered 1 through 4, while the indexes of any logical partitions are 5 and onwards, regardless of the layout of the former partitions (their parent extended partition does not need to be the fourth partition on the disk, nor do all four primary partitions have to exist).
Device names are usually not portable between different Unix-like system variants, for example, on some BSD systems, the IDE devices are named , , etc.
devfs
devfs is a specific implementation of a device file system on Unix-like operating systems, used for presenting device files. The underlying mechanism of implementation may vary, depending on the OS.
Maintaining these special files on a physically-implemented file system such as a hard drive is inconvenient, and as it needs kernel assistance anyway, the idea arose of a special-purpose logical file system that is not physically stored.
Defining when devices are ready to appear is not trivial. The devfs approach is for the device driver to request creation and deletion of devfs entries related to the devices it enables and disables.
PC DOS, TOS, OS/2, and Windows
A device file is a reserved keyword used in PC DOS, TOS, OS/2
OS/2 is a Proprietary software, proprietary computer operating system for x86 and PowerPC based personal computers. It was created and initially developed jointly by IBM and Microsoft, under the leadership of IBM software designer Ed Iacobucci, ...
, and Windows systems to allow access to certain ports and devices.
MS-DOS borrowed the concept of special files from Unix but renamed them ''devices''. Because early versions of MS-DOS did not support a directory hierarchy, devices were distinguished from regular files by making their names reserved words. This means that certain file names were reserved for devices, and should not be used to name new files or directories.
The reserved names themselves were chosen to be compatible with "special files" handling of PIP
command in CP/M. There were two kinds of devices in DOS: Block Devices (used for disk drives) and Character Devices (generally all other devices, including COM and PRN devices).
DOS uses device files for accessing printers and ports. Most versions of Windows also contain this support, which can cause confusion when trying to make files and folders of certain names, as they cannot have these names. Versions 2.x of MS-DOS provide the AVAILDEV
CONFIG.SYS parameter that, if set to FALSE
, makes these special names only active if prefixed with \DEV\
, thus allowing ordinary files to be created with these names.
GEMDOS, the DOS-like part of Atari TOS, supported similar device names to DOS, but unlike DOS it required a trailing ":" character (on DOS, this is optional) to identify them as devices as opposed to normal filenames (thus "CON:" would work on both DOS and TOS, but "CON" would name an ordinary file on TOS but the console device on DOS). In MiNT and MagiC, a special UNIX-like unified filesystem view accessed via the "U:" drive letter also placed device files in "U:\DEV".
Using shell redirection and pipes, data can be sent to or received from a device. For example, typing the following will send the file c:\data.txt
to the printer:
TYPE c:\data.txt > PRN
PIPE, MAILSLOT, and MUP are other standard Windows devices.
IOCS
The 8-bit operating system of Sharp pocket computers like the PC-E500, PC-E500S etc. consists of a BASIC
Basic or BASIC may refer to:
Science and technology
* BASIC, a computer programming language
* Basic (chemistry), having the properties of a base
* Basic access authentication, in HTTP
Entertainment
* Basic (film), ''Basic'' (film), a 2003 film
...
interpreter, a DOS 2-like File Control System (FCS) implementing a rudimentary 12-bit FAT-like filesystem, and a BIOS-like Input/Output Control System (IOCS) implementing a number of standard character and block device drivers as well as special file devices including STDO:/SCRN: (display), STDI:/KYBD: (keyboard), COM: (serial I/O), STDL:/PRN: (printer), CAS: (cassette tape), E:/F:/G: (memory file), S1:/S2:/S3: (memory card), X:/Y: (floppy), SYSTM: (system), and NIL: (function).
Implementations
See also
* devfsd
* sysfs
* Block size
* Blocking
* Data buffer
* File system
* Hardware abstraction
* Storage area network
* User space and kernel space
* Unix file types
* udev
References
Further reading
*
*
*
*
*
*
*
*
*
*
*
{{DEFAULTSORT:Device File System
Interfaces of the Linux kernel
Pseudo file systems supported by the Linux kernel
Special-purpose file systems
Unix file system technology