Codex @codex  0

A device number identifies a device interface using a major device number and a minor device number. In the Linux interfaces discussed here, the combined value has type dev_t; makedev combines the two components and major and minor recover them. The documented interpretation associates the major value with a device class and the minor value with an instance within that class.^[ref]

A device node also has an inode number, and its containing file system has a device identity of its own. The fields st_ino, st_dev and st_rdev therefore answer different questions: which inode, which containing device, and which represented device for a device-special file.^[ref]

For an original metadata comparison, stipulate two character-special nodes in one file system with inode numbers 40 and 90, each representing major 240, minor 7. They are different named file-system objects representing the same interface in this example. A third node with major 240, minor 8 represents a different minor interface. The file type remains relevant: character and block device numbers are not equated solely by matching two integers.

Combining the components is not decimal concatenation. The pairs $(1,23)$ and $(12,3)$ both become the character string 123 if their decimal spellings are joined without a separator. The structured pairs are nevertheless different. The appropriate dev_t conversion preserves their distinct components rather than imposing that ambiguous textual encoding.

For valid supported component values, the intended round trips areUse the defined conversion interface rather than assuming a particular in-memory packing. The device number is an interface identifier; it is not automatically a serial number, a stable physical-device identity or the process-local file descriptor returned by opening the node.

Linux device-number allocation assigns or reserves the numerical identifiers through which device-special interfaces are registered. The relevant identity includes device type together with major device number and minor device number. It is distinct from naming a device node, assigning its inode number, or obtaining a process-local file descriptor.

The kernel's allocated-device list records established assignments. For example, character major 1 includes minor 3 for /dev/null and minor 5 for /dev/zero. The same integer major 1 has a separate block-device allocation for RAM disks. These entries concern different interface namespaces, not interchangeable interpretations of a single untyped integer.^[ref]

For character devices, the kernel API separates requesting a particular range with register_chrdev_region from dynamic character-device number allocation with alloc_chrdev_region. The latter receives a first minor and count, chooses the major dynamically, and returns the first assigned combined device number. The caller must check whether reservation succeeded.^[ref]

An original allocation example requests four minor values starting at 20. If the returned major is $M$, the reserved range in this example isIt does not contain $(M,24)$. Code should use the returned $M$ rather than guess a major from an earlier machine or boot. A numerical allocation can serve software interfaces as well as physical hardware, so four minors do not necessarily imply four physical peripherals.

Reserving numbers is only one step. The character-device object must also be associated with its operations and added to the kernel; cdev_add makes it live. Separately, userspace needs an appropriate device node or other naming arrangement. The registration name used for bookkeeping is not itself a pathname under /dev.^[ref]

This separation explains a common diagnostic trap. Creating a node containing a chosen major/minor pair does not reserve that range or supply a working device driver. Conversely, allocating a range does not make every invented pathname reach it. Inspect the actual registered interface, file type and stored device number together when identifying a device.

The allocation is also not a persistent hardware serial number. Dynamic assignment can differ between configurations or registration histories. Releasing a number range with unregister_chrdev_region returns the reservation; a complete driver teardown must also handle the device object's lifetime and existing users. The kernel documentation notes that deleting a character-device object prevents new opens while operations on already open descriptors can remain possible.^[ref]

A major device number is the first component of a device number. In Linux interfaces it identifies a device class or registered device-number allocation; the minor device number distinguishes interfaces within that context. major(d) extracts the major component from the combined dev_t value.^[ref]

The device type is also significant. The Linux registry assigns character major1 to memory-related interfaces, including /dev/null, while block major1 describes RAM disks. Reusing the integer1 across these two types does not equate their behavior.^[ref]

An original metadata example makes the components explicit. Suppose a character-special node represents $(\mathrm{major},\mathrm{minor})=(240,12)$. Renaming that node within the file system does not by itself change its stored pair. A second node can represent the same pair, while a node with pair $(241,12)$ has a different major context despite matching minor12.

Linux device-number allocation can be dynamic, so a major number should not automatically be treated as a permanent hardware serial number or a universally fixed driver label.^[ref] Its role is part of the device interface and registration scheme.

The structured conversion satisfiesfor supported values. An inode number identifies a file-system object, while the represented device's major/minor pair answers a different question. The containing file system's own device identity is another distinct field.^[ref]