Linux – Does udev load kernel modules

The kernel knows device numbers because it decides device numbers. Each driver registers the device numbers that it manages. The numbers are either hard-coded in the source code, or, in some cases, allocated dynamically. The sysfs filesystem allows applications such as udev to discover the devices supported by the kernel. See How does udev get device numbers for the devices it creates? for more details.

The driver's initialization code probes for the hardware, and registers devices based on what hardware it found during probing. Some types of hardware don't support probing; for example, the ISA bus (a largely outdated bus on PC-type computers) provides no way to list connected hardware, so the driver can only try to communicate and pray that there isn't a different peripheral attached at the same address. On some platforms, the bootloader includes a device tree describing the available peripherals and where they are mapped, and the Linux kernel activates drivers based on this information. There are three ways a driver may be loaded for a peripheral.

• The driver may be included as part of the kernel image.
• The driver may be compiled as a module, and loaded explicitly (e.g. by including it in /etc/modules or in an initramfs).
• There is a mechanism for automatically loading certain drivers based on information reported by bus types that can list connected peripherals together with a universal identification number, such as PCI (the main bus in modern PC) and USB. The kernel runs modprobe and passes it a symbolic name that encodes the peripheral's identification, which is an alias for the “real” name of the driver module. See Are driver modules loaded and unloaded automatically?

The uevent message contains information about the device (example). This information contains registered vendor and model identification for devices connected to buses such as PCI and USB. Udev parses these events and constructs a fixed-form module name which it passes to modprobe. modprobe looks under /lib/modules/VERSION for a file called depmod.alias which is generated when the kernel is installed and that maps the fixed-form module names to actual driver module file names. See Are driver modules loaded and unloaded automatically? for more details about the process — that answer describes the earlier days when the kernel called modprobe directly, but the way modprobe and module aliases work hasn't changed.

See also Michael Opdenacker's presentation “Hotplugging with udev” which has more examples and describes other aspects of device management with udev, and the Linux from scratch guide which has a section on how the fixed-form module names are defined.

modprobe loads a module by calling the init_module system call. It doesn't interact with sysfs in any way. When the module is loaded, the kernel creates an entry for it in /sys/module. Any entry that appears elsewhere in sysfs is up to the code in the module (e.g. a module with a driver for a type of USB devices will call some generic USB support code that adds an entry under /sys/bus/usb/drivers).