1. Why Dynamic Allocation? — The Problem with Static Registration

In the previous tutorial (Tutorial 09), we used register_chrdev_region() to statically reserve a fixed major number for our character device driver. While that works for learning and controlled environments, it has a real-world problem: major number conflicts.

Every Linux system has a fixed set of character device major numbers ranging from 0 to 511. Many of these are already reserved by well-known drivers — for example, major number 1 is for mem, major 4 for tty, major 8 for sd (SCSI disks), etc. When you statically pick a major number, there is no guarantee it is free on every system. Your driver may work perfectly on your development machine but fail on a production system or another developer’s laptop because that major number is already taken.

The solution is dynamic allocation of character device numbers: instead of telling the kernel “I want major number 244”, you ask the kernel “please give me any free major number”, and the kernel picks one for you at load time. This is the recommended approach in professional Linux driver development.

2. The alloc_chrdev_region() API — Dynamic Allocation of Character Device Numbers

The Linux kernel provides the alloc_chrdev_region() function for dynamic allocation of character device numbers. It is declared in <linux/fs.h>.

2.1 Function Prototype

int alloc_chrdev_region(dev_t *dev,
                        unsigned int baseminor,
                        unsigned int count,
                        const char *name);

2.2 Parameter Details

2.3 Return Value

2.4 The Companion Cleanup Function

Every successful call to alloc_chrdev_region() must be paired with a call to unregister_chrdev_region() when the module is removed, to release the reserved numbers back to the kernel.

void unregister_chrdev_region(dev_t from, unsigned int count);
/* from  – the first device number (your dev_t variable)
   count – same count you passed to alloc_chrdev_region() */

3. Understanding dev_t, MAJOR(), and MINOR()

Before writing the driver, it is essential to understand how the Linux kernel packs device numbers. dev_t is a 32-bit integer type (defined in <linux/kdev_t.h>) that encodes both the major and minor numbers in a single value.

dev_t devnum;

// After alloc_chrdev_region():
unsigned int major = MAJOR(devnum);   // extract major from dev_t
unsigned int minor = MINOR(devnum);   // extract minor from dev_t

// To compose a dev_t manually:
dev_t d = MKDEV(major, minor);        // pack major+minor → dev_t

3.1 Required Header Files

These four headers are the minimum required for any character device driver that uses dynamic allocation:

4. Complete Dynamic Allocation Character Driver — Step-by-Step

Now let’s build the complete driver. We will add module_param support so we can configure the minor number, device count, and device name from the command line when inserting the module — a very useful pattern in real drivers.

4.1 Full Source Code: dynamic.c

/* dynamic.c — Dynamic allocation of character device numbers
 * Tutorial 10 | EmbeddedPathashala
 * Free Linux Device Driver Course
 */

#include <linux/kernel.h>    /* printk, KERN_INFO */
#include <linux/module.h>    /* module_init, module_exit, module_param, MODULE_LICENSE */
#include <linux/kdev_t.h>    /* dev_t, MAJOR(), MINOR() */
#include <linux/fs.h>        /* alloc_chrdev_region, unregister_chrdev_region */

/* ─── Module parameters (can be overridden at insmod time) ─── */
static int bminor = 0;                  /* base minor number  */
static char *device_name = "mychdrv";  /* name shown in /proc/devices */
static int count = 1;                  /* how many minor numbers to reserve */

module_param(bminor, int, 0);          /* insmod dynamic.ko bminor=5   */
module_param(count, int, 0);           /* insmod dynamic.ko count=3    */
module_param(device_name, charp, 0);   /* insmod dynamic.ko device_name="mydev" */

MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeddedPathashala");
MODULE_DESCRIPTION("Dynamic char device number allocation example");

/* ─── dev_t variable to hold our assigned device number ─── */
static dev_t devnum;   /* kernel will write the allocated dev_t here */

/* ─────────────────────────────────────────────────────────── */
/*  Module init                                               */
/* ─────────────────────────────────────────────────────────── */
static int __init hello_init(void)
{
    printk(KERN_INFO "dynamic: Loading module...\n");
    printk(KERN_INFO "dynamic: baseminor   = %d\n", bminor);
    printk(KERN_INFO "dynamic: count       = %d\n", count);
    printk(KERN_INFO "dynamic: device_name = %s\n", device_name);

    /*
     * alloc_chrdev_region() — ask the kernel to pick a free major number
     *
     * &devnum      — output: kernel writes assigned dev_t here
     * bminor       — starting minor number (we choose, default 0)
     * count        — how many consecutive minor numbers to reserve
     * device_name  — name that appears in /proc/devices
     *
     * Returns 0 on success, negative errno on failure.
     */
    if (alloc_chrdev_region(&devnum, bminor, count, device_name) == 0) {
        printk(KERN_INFO "dynamic: Device number registered successfully\n");
        printk(KERN_INFO "dynamic: Major number = %d\n", MAJOR(devnum));
        printk(KERN_INFO "dynamic: Minor number = %d\n", MINOR(devnum));
    } else {
        printk(KERN_ERR "dynamic: Device number registration FAILED\n");
        return -EINVAL;
    }

    return 0;  /* 0 = success; non-zero = module load fails */
}

/* ─────────────────────────────────────────────────────────── */
/*  Module exit                                               */
/* ─────────────────────────────────────────────────────────── */
static void __exit hello_exit(void)
{
    /*
     * Always release the device numbers in the exit function.
     * Pass the same dev_t and count used during allocation.
     */
    unregister_chrdev_region(devnum, count);
    printk(KERN_INFO "dynamic: Device number released. Module unloaded.\n");
}

module_init(hello_init);
module_exit(hello_exit);

4.2 Line-by-Line Explanation

5. The Makefile — Building the Kernel Module

# Makefile for dynamic char driver
# Tutorial 10 | EmbeddedPathashala

obj-m += dynamic.o          # Tell the kernel build system to build dynamic.ko

KDIR = /lib/modules/$(shell uname -r)/build   # Path to running kernel build tree
PWD  = $(shell pwd)                           # Current working directory

all:
	make -C $(KDIR) M=$(PWD) modules         # Invoke kernel Makefile with our dir

clean:
	make -C $(KDIR) M=$(PWD) clean           # Remove build artifacts

Build the module with:

$ make
# Successful build produces: dynamic.ko

6. Loading, Verifying, and Unloading the Driver

6.1 Insert the Module

$ sudo insmod ./dynamic.ko

6.2 Check Kernel Log with dmesg

$ dmesg | tail -10

# Expected output:
[ 1462.540674] dynamic: Loading module...
[ 1462.540675] dynamic: baseminor   = 0
[ 1462.540676] dynamic: count       = 1
[ 1462.540677] dynamic: device_name = mychdrv
[ 1462.540678] dynamic: Device number registered successfully
[ 1462.540679] dynamic: Major number = 511
[ 1462.540680] dynamic: Minor number = 0

Notice that the kernel assigned major number 511. This is not random — it reflects the kernel’s internal algorithm for picking dynamic major numbers. We will explore this algorithm in the next section.

6.3 Verify in /proc/devices

$ cat /proc/devices

# You will see your device listed under "Character devices":
Character devices:
  1 mem
  4 /dev/vc/0
  ...
511 mychdrv      <-- Your dynamically allocated driver!

6.4 Insert with Custom Parameters

# Override device name and starting minor number:
$ sudo insmod ./dynamic.ko device_name="myep" bminor=10 count=2

# dmesg will show:
[ ... ] dynamic: baseminor   = 10
[ ... ] dynamic: count       = 2
[ ... ] dynamic: device_name = myep
[ ... ] dynamic: Major number = 510   (next available)

6.5 Remove the Module

$ sudo rmmod dynamic

# After rmmod, check /proc/devices:
$ cat /proc/devices
# "mychdrv" is GONE — the major number has been released back to the kernel pool

7. Deep Dive — How the Kernel Picks Dynamic Major Numbers (find_dynamic_major())

This section takes you under the hood of the kernel. Understanding how the kernel picks major numbers will help you reason about driver behaviour, especially in embedded systems where resources are constrained.

When you call alloc_chrdev_region(), the kernel internally calls a static function called find_dynamic_major(), located in /linux/fs/char_dev.c.

7.1 The Four Key Macros

7.2 Visualising the Allocation Segments

7.3 The find_dynamic_major() Source Code

Here is the actual kernel source code from /linux/fs/char_dev.c that implements the two-stage search:

/* From: linux/fs/char_dev.c */
static int find_dynamic_major(void)
{
    int i;
    struct char_device_struct *cd;

    /* ── Stage 1: Scan the STANDARD dynamic major range ──
     * Start from slot 511 (ARRAY_SIZE(chrdevs)-1) and
     * scan downward to CHRDEV_MAJOR_DYN_END (234).
     * chrdevs[] is an array of 512 pointers.
     * If a slot is NULL, that major number is free → return it.
     */
    for (i = ARRAY_SIZE(chrdevs) - 1; i >= CHRDEV_MAJOR_DYN_END; i--) {
        if (chrdevs[i] == NULL)
            return i;   /* ← Found a free slot in standard range */
    }

    /* ── Stage 2: Scan the EXTENDED dynamic major range ──
     * When majors above 255 need to share hash slots (because
     * chrdevs[] has only 512 entries but majors can theoretically
     * go higher via 12-bit encoding), we scan from
     * CHRDEV_MAJOR_DYN_EXT_START (511) down to
     * CHRDEV_MAJOR_DYN_EXT_END (384).
     *
     * For each candidate major, walk the linked list at
     * chrdevs[major_to_index(i)]. If no node matches this
     * exact major, it's available.
     */
    for (i = CHRDEV_MAJOR_DYN_EXT_START; i > CHRDEV_MAJOR_DYN_EXT_END; i--) {
        for (cd = chrdevs[major_to_index(i)]; cd; cd = cd->next)
            if (cd->major == i)
                break;

        if (cd == NULL || cd->major != i)
            return i;   /* ← Found a free slot in extended range */
    }

    return -EBUSY;  /* ← All dynamic major numbers are exhausted */
}

7.4 Step-by-Step Walk Through the Algorithm

7.5 Experiment: Exhausting the Dynamic Major Pool

Your draft mentioned a very interesting experiment: load a module 512 times in a loop. Here is what happens and why you need a reboot to recover:

/* experiment_exhaust.c — Demonstrate dynamic major number exhaustion */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>

#define MAX_DEVS 512

static dev_t devnums[MAX_DEVS];
static int allocated = 0;

static int __init exhaust_init(void)
{
    int i, ret;
    char name[32];

    for (i = 0; i < MAX_DEVS; i++) {
        snprintf(name, sizeof(name), "mychardev_%d", i);
        ret = alloc_chrdev_region(&devnums[i], 0, 1, name);
        if (ret < 0) {
            printk(KERN_ERR "exhaust: FAILED at iteration %d: %d\n", i, ret);
            /* You will see the error message from char_dev.c:
             * CHRDEV "mychardev_NNN" dynamic allocation region is full */
            break;
        }
        printk(KERN_INFO "exhaust: [%d] major=%d\n", i, MAJOR(devnums[i]));
        allocated++;
    }
    printk(KERN_INFO "exhaust: Total allocated: %d\n", allocated);
    return 0;
}

static void __exit exhaust_exit(void)
{
    int i;
    for (i = 0; i < allocated; i++)
        unregister_chrdev_region(devnums[i], 1);
}

module_init(exhaust_init);
module_exit(exhaust_exit);
MODULE_LICENSE("GPL");

8. Creating Device Nodes — The mknod Command

After successfully loading the driver and registering device numbers, the kernel knows about your driver. But userspace applications cannot access it yet because there is no device file (also called a device node) in the /dev/ directory. Device files are the interface between userspace and the kernel driver.

There are two ways to create device files:

1. Manual — using the mknod command (covered in this section)
2. Automatic — using udev with class_create() and device_create() (covered in a later tutorial)

8.1 The mknod Syntax

$ mknod -m <permissions> <path> <type> <major> <minor>

8.2 Complete mknod Example

# Step 1: Load the module and find the assigned major number
$ sudo insmod ./dynamic.ko
$ dmesg | grep "Major number"
[...] dynamic: Major number = 511

# Step 2: Create the device node manually
$ sudo mknod -m 0644 /dev/mydevice c 511 0
#                    ↑              ↑ ↑   ↑
#                    permissions    | |   minor
#                                   | char type
#                                   major from dmesg

# Step 3: Verify the device file was created
$ ls -l /dev/mydevice
crw-r--r-- 1 root root 511, 0 Jun 01 10:45 /dev/mydevice
#  ↑                   ↑    ↑
#  c = char device    511   0
#                  major   minor

# Step 4: Check /proc/devices (driver listed here)
$ cat /proc/devices | grep mychdrv
511 mychdrv

# NOTE: /dev/mydevice appears in ls /dev/ but NOT in /proc/devices
# /proc/devices shows DRIVERS (kernel side)
# /dev/ shows DEVICE FILES (filesystem side)

8.3 Deleting the Device Node

# Device nodes created with mknod are regular files — delete with rm
$ sudo rm /dev/mydevice

# Or to remove all files matching the pattern:
$ sudo rm /dev/mydevice*

9. Key Concept — Device File vs. Device Driver

Your draft notes asked: “What is the difference between a device file and a device driver?” This is an excellent conceptual question that trips up many beginners.

10. /proc/devices vs /dev/ — Clearing the Confusion

Many beginners confuse these two. After your hands-on experiments you will notice:

• /dev/mydevice appears in ls /dev/ — but you will NOT see it in cat /proc/devices
• mychdrv appears in cat /proc/devices — but you need ls /dev/ to see the device file

11. Common Mistakes and How to Avoid Them

12. Best Practices for Dynamic Character Device Registration

13. Complete Hands-On Workflow — From Source to Device Node

# ─── Step 1: Create project directory ───
$ mkdir ~/ep_dynamic_driver && cd ~/ep_dynamic_driver

# ─── Step 2: Create dynamic.c and Makefile (shown in sections 4 and 5) ───

# ─── Step 3: Build the kernel module ───
$ make
# Produces: dynamic.ko

# ─── Step 4: Insert the module ───
$ sudo insmod ./dynamic.ko
# OR with custom params:
$ sudo insmod ./dynamic.ko device_name="ep_char" bminor=0 count=1

# ─── Step 5: Check the assigned major number ───
$ dmesg | tail -5
# Note the Major number (e.g., 511)

# ─── Step 6: Verify in /proc/devices ───
$ cat /proc/devices | grep -E "ep_char|mychdrv"
511 mychdrv

# ─── Step 7: Create the device node ───
$ sudo mknod -m 0666 /dev/ep_char c 511 0

# ─── Step 8: Verify device node ───
$ ls -l /dev/ep_char
crw-rw-rw- 1 root root 511, 0 Jun 01 10:50 /dev/ep_char

# ─── Step 9: Test (basic — no file_ops implemented yet) ───
$ cat /dev/ep_char
# Will fail with "Operation not supported" — expected! No read() implemented yet.

# ─── Step 10: Cleanup ───
$ sudo rm /dev/ep_char          # delete device node first
$ sudo rmmod dynamic            # then unload the module
$ dmesg | tail -3               # verify unregister message

14. Summary & Key Takeaways

15. Conclusion

In this free Linux device driver tutorial from EmbeddedPathashala, you have mastered the complete concept of dynamic allocation of character device numbers. You started from understanding why dynamic allocation is necessary, learned the alloc_chrdev_region() API in depth, explored the actual kernel source code of find_dynamic_major() to understand the two allocation segments (standard: 511→235, extended: 511→385), built and tested a real kernel module with module_param support, and finally learned how to manually create device nodes using mknod.

You also clarified a conceptual distinction that confuses many engineers: the difference between a device file in /dev/ and a device driver in kernel memory. These are two separate entities that the kernel’s VFS bridges at runtime using the major number as the key.

The next logical step is to move beyond just reserving device numbers and actually implement the file_operations structure — the open, read, write, and release handlers that make your driver actually do something. That is covered in Tutorial 11 on our free Linux kernel development course at EmbeddedPathashala.

16. Frequently Asked Questions (FAQ)