Debian – Explanation of the building process of the kernel on Ubuntu/Debian systems

compilingdebiankernelUbuntu

I'm getting into Linux kernel programming and I have successfully built my own kernel several times now. However, I have done it using step by step guides found from the internet and I don't really understand what happens in the build process. So far I've found several different ways to build the kernel. One is:

make-kpkg -j5 --initrd kernel-image kernel-headers

As I understand it, make-kpkg is a Debian program designed for building and packaging kernel related stuff. –initrd is used to generate initrd image automatically. What are the last two arguments (kernel-image and kernel-headers) for?

Another way to build the kernel is just

make deb-pkg

What does this command do as compared to the first command?

Also, in this guide, building the kernel is done by:

fakeroot debian/rules clean
fakeroot debian/rules binary-headers binary-generic

Which is the recommended way to build the kernel on Ubuntu? What exactly happens when I execute one of the commands above? If I wished to do everything one of the commands above does manually, what steps would I have to take?

Best Answer

make-kpkg is a command from the package kernel-package, which used to be part of the official packaging infrastructure for the kernel packages that get shipped in the Debian distribution. It is not being used for that purpose anymore because the current maintainer for the kernel packages inside the Debian distribution chose to stop using it; however, the authors of the kernel-package package have not stopped maintaining it, so it is still an officially supported way of creating your own Debian packaged version of a kernel. It has various options and targets; the most important ones are the ones you refer to in your question, i.e., kernel-image (which builds a package containing the kernel and modules that you selected during make config), and kernel-headers (which contains the include files that you might need if you want to compile an out-of-tree module). The kernel-package package is maintained as part of the Debian (or derivative, like Ubuntu) release with which it was released, so as a result if things change in the Debian infrastructure then newer versions of kernel-package will be updated to incorporate it, and they will ship with that version of Debian. As a result, a kernel package created by the kernel-package package is always tailored best for the version of Debian on which it was created. However, if things change within the Linux kernel in a way that makes kernel-package break, then updating your kernel package for a stable version of Debian may be somewhat complicated.

make deb-pkg is a target in the Linux kernel's build infrastructure. It receives patches from Debian developers, but as it is not maintained within Debian itself, it always uses the tools and policies that are most up to date at the point in time where the kernel version you're trying to build was created. This means that in some cases, it might try to use a tool that isn't available on an older distribution yet. As it is not maintained inside Debian, it is not an officially-supported method (at least not from the point of view of Debian) for creating kernel packages; having said that though, it is mostly maintained by people who are involved in Debian, and so there is no reason to suspect that it won't work.

Whichever method you choose is just a matter of preference; unless you are heavily invested in peculiar outcomes of the package building options, both methods will work just fine.

Related Solutions

Ubuntu – What happens in each step of the Linux kernel-building process

From the top...

make compiles and links the kernel image. This is a single file named vmlinuz.
make modules compiles individual files for each question you answered M during kernel config. The object code is linked against your freshly built kernel. (For questions answered Y, these are already part of vmlinuz, and for questions answered N they are skipped).
make install installs your built kernel to /vmlinuz.
make modules_install installs your kernel modules to /lib/modules or /lib/modules/<version>.

As for adding it to the list of available kernels, that's taken care of by the boot loader. It's different for each boot loader, but grub is the most common on x86 and amd64 so I'll describe that. It's actually quite simple. Grub looks in /, /boot and /lib/modules for any thing that looks like it might be a working kernel and adds it. And yes, this is an oversimplified description.

That extra "horrible stuff" in the Ubuntu documentation is extra stuff to create a deb package. When you're doing it for more than yourself it's far better to package it. You'll switch in time.

Building the kernel and modules is kept separate because for the people who need to (i.e., kernel developers) they are often making changes to only a module. They can apply their changes, rebuild and install just the modules. This saves a lot of time when it has to be done 20 times a day. It will never be updated to have a single make everything command. You instead, run make && make modules && make install && make modules_install just like the documentation says to do. The build process favors kernel developers, not you. And that's the way it should be.

In reality there's almost no reason for anybody except kernel developers or distro packagers to compile a kernel. In almost any circumstance the kernel feature you want has already been built for you and is available in one of the pre-packaged kernels. There are exceptions, but they are exceedingly rare these days.

Not that I'm discouraging you from doing building your own kernel, I actually encourage you to do it. I think building your kernel from scratch is an invaluable practice for learning about how it all works down there. In part, because maybe one day you will be the exception that needs to. But it also teaches you a lot about the kernel & boot process in general. You will be a better person for having done it.

Buildroot ignoring configuration files – building wrong kernel

Not really an answer, but it doesn't fit a comment due to formatting:

What happens when you do the following:

cd /home/user/projects/buildroot
make clean
make distclean

Copy target system's /proc/config.gz to host /tmp Then take the existing kernel config and translates it to the new kernel version by answering the various question:

gunzip -c /tmp/config.gz ./.config
make oldconfig

Do some sanity checking on version:

make menuconfig

Build the binaries

make

Check version of the kernel image built, don't load the kernel image in nano to search for a string, that is bad practice.

file ./buildroot/output/images/*

Best Answer

Related Solutions

Ubuntu – What happens in each step of the Linux kernel-building process

Buildroot ignoring configuration files – building wrong kernel

Related Question