Why are drivers compiled into the kernel? Why aren't more drivers distributed as dynamic kernel modules?

Question

I'm still new to understanding the Linux kernel so please forgive the basic question. If you could point me to resources that I could read/watch that would be greatly appreciated.

Coming from Windows, the hardware driver workflow appears to be that you install the core operating system first, then install drivers separately.

With Linux it appears that all the drivers are compiled into the kernel directly - does that mean an installed Linux distro comes with support for all supported hardware, even if you only use a subset of that?

Does that mean installing something like the proprietary NVIDIA driver (which is not included in the kernel) will actually require recompiling the kernel with the NVIDIA driver - where distros like Ubuntu and Fedora provide pre-compiled kernels with the driver built in?

I recently installed a driver on my Linux install that added support for the Xbox wireless dongle. It used "DKMS" to add the driver to my system without compiling it into the kernel.

Is DKMS a method to add micro-kernel features to Linux? Why aren't all drivers distributed as dynamic modules? Aren't kernel modules already dynamic as they are installed under /ib/modules?

How do dynamic kernel modules affect secure boot in the context of a self-signed Linux install?

Answer 1

I think you're conflating two related but different concepts: how drivers used by the kernel (statically compiled in, dynamically loaded), and how they're developed (in-tree, out-of-tree).

Drivers that are developed in-tree can be compiled into the kernel or loaded dynamically. Most are dynamically loaded. Drivers developed out of tree are almost always going to be dynamically loaded, simply because they're not going to be in the kernel source code of most distributions, so they can't be compiled in at all. If you have to install a driver separately, then it's developed out-of-kernel.

Drivers depend on a lot of internal APIs of the kernel, and as I understand it, Linux doesn't care about backwards compatibility of these APIs. The preference is for clean code, not maintaining a kludgy mess of ancient cruft and modern code for the sake of backwards compatibility (in a sense). So they prefer having drivers in-tree - if someone does some refactoring of an API, they are also expected to fix up any users of that API, and which they can do, since all users are in the same source code.

Of course, this can't be done for out-of-tree drivers. So they have to be compiled for a specific kernel version, as other versions may break the APIs they're depending on. For NVIDIA, and possibly others, the driver is basically a shim that wraps around a proprietary binary. (The shim supports multiple kernel versions.) This means that for distributions, you have to have a package of the driver for each packaged kernel version.

DKMS is a mechanism to help such out-of-tree kernels - instead of having a version of the driver packaged for each version of the kernel, DKMS will compile the driver for each installed kernel version.