• What a device number is and how it is composed of a major and minor number
• How to use MKDEV(), MAJOR(), and MINOR() kernel macros
• How to statically allocate a device number with register_chrdev_region()
• What happens when you try to reuse an already-taken major number
• What happens when you reuse an existing device name with a different major number
• The maximum allowed major number (CHRDEV_MAJOR_MAX) and why exceeding 511 fails
• The maximum number of minor numbers (2²⁰) and what overflow looks like
• How to unregister a device number when your module exits
• Why static allocation is not recommended for production drivers

• Basic understanding of Linux kernel modules (insmod / rmmod / dmesg)
• Familiarity with writing a simple hello_init / hello_exit kernel module
• A Linux machine with kernel headers installed (tested on Linux 6.x)
• Basic C programming knowledge

In Linux, every character device and block device is identified by a device number. The device number is a single 32-bit integer of type dev_t that encodes two pieces of information:

• Major Number — identifies which driver is responsible for the device. All devices controlled by the same driver share the same major number.
• Minor Number — identifies a specific instance managed by that driver. For example, a single UART driver might manage /dev/ttyS0, /dev/ttyS1, /dev/ttyS2. Each of these gets a different minor number but shares the same major number.

When user space opens /dev/mydevice, the kernel reads the major number embedded in the device file’s inode, looks up the registered driver for that major number, and hands the open() call to that driver. The minor number is passed along so the driver knows which instance is being accessed.

The kernel provides three macros in <linux/kdev_t.h> to work with device numbers. You should never manipulate the bits of dev_t directly — always use these macros so your code remains portable across kernel versions.

To statically allocate a character device number you call register_chrdev_region(). The prototype is declared in <linux/fs.h>:

int register_chrdev_region(dev_t first, unsigned int count, const char *name);

Below is the complete static_alloc.c driver used in this tutorial. Read through it carefully — every line is explained in the sections that follow.

Build the module by running make in your source directory. You will get static_alloc.ko as output.

Before loading your module, always check which major numbers are already in use on your system:

cat /proc/devices

A typical output looks like this:

Character devices:
  1 mem
  4 /dev/vc/0
  4 tty
  5 /dev/tty
  5 /dev/console
 10 misc
 13 input
180 usb
...

The number on the left is the major number. The name on the right is the device name passed to register_chrdev_region(). Notice that major number 10 is taken by misc and major number 180 is taken by usb. These facts are central to the experiments below.

Major number 10 is already used by the misc driver in Linux. What happens if our module also tries to claim major 10?

This is the core problem with static allocation — you must know in advance which major numbers are free on the target system. A number that is free on your development machine may be taken on the production board. This is exactly why dynamic allocation (alloc_chrdev_region()) was introduced and is preferred for all production drivers.

Major number 180 is used by the usb driver. Now let us try: use a different major number (311) but give our device the same name as an existing one (“usb”). Will the kernel allow it?

The count parameter of register_chrdev_region() lets you reserve a range of consecutive minor numbers in a single call. Here we register 5 minor numbers starting from minor 0 under major 327.

Recall from the dev_t bit layout that the minor number field is 20 bits wide. This gives a maximum of:

In practice you will never need anywhere near this many minor numbers for a single driver. A driver managing 256 UART ports would use minors 0 through 255 — well within the limit. However if you accidentally pass a count or a starting minor_number that causes the range to exceed 2²⁰, you will observe an overflow: the upper bits of the minor number wrap around, producing an incorrect dev_t.

The major number field in dev_t is 12 bits wide, which theoretically allows values from 0 to 4095 (2¹²). However, the kernel artificially limits this to a lower value defined in include/linux/fs.h:

#define CHRDEV_MAJOR_MAX  512

This means the largest usable major number is 511. If you ask for anything from 512 upward the kernel rejects the request regardless of whether that number appears free.

Every successful call to register_chrdev_region() must be paired with a call to unregister_chrdev_region() when the module exits. Failure to do so will leave the device number permanently reserved until the next reboot, potentially preventing any other driver from claiming that major number.

void unregister_chrdev_region(dev_t first, unsigned int count);

Pass the same dev_t and count values that were used during registration. This is why devnum is declared as a global variable — so both hello_init() and hello_exit() can access the same value.

Now that you understand how static allocation works and its failure modes, you are ready to appreciate why dynamic allocation exists. Here is a side-by-side comparison:

• Always check the return value of register_chrdev_region() and return an error code from module_init() on failure — do not proceed with a partially-initialized driver.
• Use alloc_chrdev_region() for all production drivers. Static allocation is only acceptable for learning exercises or highly controlled embedded platforms where the major number assignment is part of a fixed BSP.
• Declare devnum as a module-level global so the same value is accessible in both the init and exit functions.
• Run cat /proc/devices before picking a static major number to avoid conflicts during development.
• Guard against count overflow — verify that minor_number + count ≤ 2²⁰ before calling the registration function.
• Match your MODULE_LICENSE() declaration to the license of your code. Using GPL gives access to more exported kernel symbols.

In this free Linux kernel driver tutorial you have seen static device number allocation from every angle: the structure of dev_t, how the kernel macros MKDEV, MAJOR, and MINOR work, and how to use register_chrdev_region() and unregister_chrdev_region() correctly. More importantly, you ran four real-hardware experiments that exposed the failure modes — a duplicate major number, a shared name, a range of minors, and a major exceeding the enforced limit of 511.

These experiments teach you the most important lesson: static allocation is fragile because it depends on a globally agreed assignment that must be coordinated across all drivers on a system. The Linux kernel community addressed this with alloc_chrdev_region(), which lets the kernel pick a free major number automatically. In the next lecture we will implement exactly that and complete the full character device registration flow.

1. dev_t bit-layout diagram ALT: Linux dev_t structure showing major and minor number bit layout in static device number allocation
2. register_chrdev_region() call flow screenshot ALT: Linux kernel register_chrdev_region static allocation function flow in char device driver
3. /proc/devices terminal screenshot showing major numbers ALT: /proc/devices output showing registered char device major numbers in Linux kernel driver tutorial
4. dmesg output showing device number registration success and failure ALT: dmesg output for Linux character device static allocation success and failure in kernel module
5. Static vs Dynamic allocation comparison diagram ALT: Static vs dynamic device number allocation comparison in Linux kernel character device driver

• Linux Kernel Documentation — Device Drivers
• Linux Source: include/linux/fs.h (CHRDEV_MAJOR_MAX definition)
• Linux Source: include/linux/kdev_t.h (MKDEV, MAJOR, MINOR macros)
• Linux Device Drivers, 3rd Edition (LDD3) — Free Online Book
• man7.org: proc(5) — /proc/devices documentation