개발

jackryu 2011. 5. 31. 22:23


[팁004] Kernel - Ubuntu

kleinstein의 아바타

Kernel 만들기

가끔씩 사람들은 자신에 맞는 추가적인 어떤것? 들이 들어가거나 동적으로 하드웨어의 드라이버가 커널에 장착될수 있도록 최적화된 커널을 필요로 할때가 있습니다. 말이 괜스레 어려워 지네요.. 번역을 하려니까.. 흠..

어쨋거나 자신이 사용하는 커널을 이럴경우 좀 만져줘야 할때가 있는데 아래의 내용은 이럴때 참고가 되는 내용이랍니다.
이 내용은 Debian 계열의 리눅스에서 Kernel 2.6.x 버전에 적용될수 있는 내용이니까 참고하세요..

먼저 해 둘것들..
컴파일러와 각종 필요한 도구들 설치

우선 아래의 프로그램들이 설치되어 있어야 합니다.

build-essential

kernel-package

libncurses5-dev (ncurses 를 기반으로 하는 화면에서 설정하기 위한것) 혹은 
libgtk2.0-dev 과 libglib2.0-dev 과 libglade2-dev (GTK 기반 화면에서 설정하려면 설치해야 할것) 혹은 
libqt3-mt-dev (Qt 기반 화면에서 설정하려면 필요한것 Universe 저장소에 있을것임..).

커널소스 다운받기
이미 몇몇의 패치를 포함하고 있는 Ubuntu-Kernel 의 소스는 apt 라던가 Synaptic 이라는 프로그램을 통해 패키지 형태로 다운 받아질 수 있습니다. linux-source-x.x.x 라는 이름으로 이 패키지 이름이 되어 있을거구요.. 기왕이면 현재 사용하고 있는 커널의 버전과 동일하면 좋을겁니다.. 현재 커널 버전은 콘솔에서 아래의 명령으로 알수 있습니다.

uname -r

커널 패치 다운받기(옵션항목..)

커널을 패치하려는 사람들은 보통 자기가 뭘하려고 하는지 알고 있거나 어떤 패치가 필요한지 알고 있는 사람이겠지요? 필요한 패치가 패키지 저장소에 이미 있다면 좋을텐데요.. 어떤 패치들은 Universe 저장소에 있고 이럴경우 패치 버전을 신경써서 잘 봐서 선택하시면 된답니다. 흠.. 뭐 저같은 초보가 이게 뭔지 알수는 없지만..언젠가 이런걸 제대로 알날이 오겠지요... 일단 커널도 하나의 프로그램이다보니.. 적절한 이유에 의해 특별한 코드를 더 집어넣거나 고친것이 아닐까 생각해 봅니다...

커널 소스 압축풀고 소스가 있는 곳으로 가기.
커널 소스를 다운 받으면 아마 tar.bz2 압축형태로 /usr/src 디렉토리에 저장되어 있을겁니다. 그리고 이 위치로 가야겠지요..

아래의 과정은 root 권한으로 한 콘솔에서 시행되어야 합니다.
root 터미날을 열고 하시는게 좋을듯.. (왜 저에게는 루트 터미날을 여는 아이콘이 그놈에 기본적으로 없을까요.. 보통은 그놈의 프로그램-보조 프로그램-root 터미날 이렇게 있다고 하는데...흠.. ).

sudo tar -xjvf linux-source-<버전번호>
cd linux-source-<버전번호>

(옵션항목) : 커널 패치하기..
Synaptic같은 패키지 관리 프로그램으로 커널 패치를 위해 패치를 다운 받으셨다면 아마 usr/src/kernel-patches/diffs 디렉토리 아래에 저장되어 있을겁니다.. 
아마 gz- 나 혹은 bz2- 압축으로 된 Diff-파일로 되어 있는 경우가 많다네요..(*.diff.gz 나 *.diff.bz2 같은 파일이름이죠..). 어쨋거나 요놈들은 아래의 명령으로 패치한답니다..

zcat /usr/src/kernel-patches/diffs/<패치 디렉토리>/<패치 파일이름> | sudo patch -p1

bz2-압축일경우 gunzip 을 bunzip2 으로 바꿉니다.

커널 설정하기

커널 설정값들은 .config 파일에 저장되어집니다. 이미 설치된 커널의 설정값들을 보면 참고가 어느정도 되겠지요..아래 명령으로 현재의 디렉토리에 이미 설치된 커널의 설정값 파일을 복사해둡니다.

sudo cp /boot/config-<Kernelversion> .config

힌트:
지금 독자들의 컴에서 돌아가고 있는 커널의 설정값들은 /proc 디렉토리에 있는 압축된 파일에서 가져올수도 있다네요..유분투의 기본 커널에서는 이게 활성화 되지 않아서 여기서 가져오는게 되지 않을텐데 스스로 컴파일한 경우 이게 활성화 되어서 여기서 가져올수 있을거랍니다.. 지금 돌아가고 있는 커널이 스스로 컴파일 한 커널인 경우 암튼 아래의 명령으로 지금 돌아가고 있는 커널의 설정값을 가져올수도 있다고 합니다.

sudo zcat /proc/config.gz > .config

그리고 아래의 명령

sudo make defconfig

이걸로 아주 기본적이면서 최소의 설정을 가진 기본 최소 설정값을 만들어 낼수도 있답니다. 물론 그다음에 이 값들을 조금 수정해줘야 겠지만요.. 이 경우 ext2 나 ext3 같은 파일시스템하에서만 요렇게 할수 있다네요.. 다른 파일시스템에서는 이렇게 하지 말라는것 같은데.. 왜 그런지는 고수님들의 댓글을 기대해봅니다. 아님 제가 번역을 엉터리로 했을수도...

암튼.. 이제 개인적인 설정을 할 차례입니다. 아까 처음에 언급한대로 어떤 화면에서 설정하기로 했느냐에 따라(위에서 이것에 따라서 각각 다른 패키지-프로그램-들을 설치했었지요.. ) 아래의 명령들중 하나를 실행해줍니다.

sudo make menuconfig
(ncurses경우), 혹은

sudo make gconfig
(GTK의 경우), 혹은

sudo make xconfig
(Qt의 경우)

이제 행운을 빕니다. 잘 설정해 보시길.. 구체적인 설정값들에 대해서는 뭐..
각자 웹을 뒤져서 알아보시길.. 개인적으로 참..저도 궁금합니다. 다 뭘 의미하는건지.. 쩝.. 이런게 한글로 메뉴얼 같이 되어 있으면 좋을텐데..

만약 새로운 커널버전이 또 나와서 새로운 커널버전으로 옮기고 싶다면 예전 커널 디렉토리에 있는 .config파일을 이제 새 커널 디렉토리로 복사합니다.. 그리고 새 커널 디렉토리로 우선 가셔서(cd 명령으로..)

sudo make oldconfig

명령을 실행합니다. 이렇게 하면 새로운 커널의 새로운 부분을 위한 설정값들만 고칠수 있게 사용자에게 물어보게 된다고 합니다. 요부분은 제가 잘 이해가 안됩니다.. 해봐야 알텐데..암튼.. 잘 아시는분은 좀 도와주세요..

커널 컴파일하기

위에서 개인적인 설정을 한 뒤에 이제 커널을 컴파일 해야 합니다.
아래의 명령으로 컴파일하면 나중에 컴파일된 커널을 손쉽게 설치할수 있도록 .deb 파일까지 한꺼번에 만들어 버릴수 있어서 아래의 명령으로 Debian 계열 리눅스는 커널을 컴파일하는게 좋답니다.(make-kpkg 명령으로 컴파일한걸 데이안 패키지로 만드는 것.)이건 kernel-image, kernel-headers, kernel-doc 과 kernel-source를 모두 포함하는것 같습니다..

sudo make-kpkg --initrd --revision i686ver1 binary

"i686ver1" 라고 표시된 부분은 적절히 자신이 편한 명칭을 바꿔 주시면 됩니다. 혹시나 이미 같은 이름의 파일이 있다면 동일한 이름이 되지 않도록 조심해야겠지요..

binary 라는 파라메터는 .deb 패키지의 생성시에 바이너리 파일로 만들라는 뜻입니다. 단지 커널 이미지 패키지만 만들려면 binary 라는 파라메터 대신 kernel_image 라고 써주면 됩니다. 더 추가적인 옵션을 보고싶으시다면
man make-kpkg 명령으로 쭉~ 읽어보시길..

혹시: "arch/i386/boot/bzImage" 파일이 없다는 에러가 난다면

sudo make clean bzImage && sudo make-kpkg --initrd kernel_image && sudo make && sudo make-kpkg --initrd binary
명령을 주세요..

initrd 파라메터에 대해: 자신의 하드웨어를 잘 알고 있다면 initrd 가 꼭 필요한건 아니랍니다.(initrd 라는게 뭔지 잘 몰라요.. 고수님들.. 좀 자세히 알려주세요..) 자신만의 커널 설정시에 미리 적절히 커널자체에 포함되도록 설정해서 컴파일해버리니까요.. 암튼.. 이런식으로 하드웨어 지원을 모두 기본 커널에 포함되게 해버리면 커널 설정할때 initrd 를 지원하지 않도록 설정합니다.그리고 하드웨어의 드라이버를 root-디스크(대부분 하드디스크를 위한 ATAPI / IDE 드라이버)에 항상 연결되게 해버리고 모듈로 설정하지는 않겠지요.. 그러니까.. 예를 들어 USB 마우스를 항상 사용하시는 분은 굳이 USB 를 모듈로 지원하게끔할 필요는 없다는 말입니다. 그냥 커널자체가 지원을 하도록 해버릴수도 있다는 말인데.. 뭐 .. 이런건 각자 좋을대로 하면될것 같습니다... 제생각엔 말이죠.. 혹시 외부 Firewire 디스크를 처음 부팅시에 연결하려면 Firewire 드라이버가 커널에 들어 있어야겠지요..

암튼.. 이럴경우는 아래명령을 사용합니다.

sudo make-kpkg binary

그리고 혹시 make-kpkg 명령으로 컴파일했다가 또 설정을 바꿔서 다시한번 make-kpkg 명령으로 컴파일 하려고 한다면 그전에 아래의 명령을 한번 실행하랍니다. 왜일까요??

sudo make

만일 커널이 나중에 또다시 패치되어야 한다면 기존에 있는 여러가지 잡다한 것들을 지우고 다시 재컴파일해야 할 필요가 있답니다. 이럴때에는

sudo make clean

명령으로 컴파일시에 생성되었던 잡다한것들을 깨끗이 지우랍니다.
만약 make-kpkg를 이용해서 컴파일 했었다면 아래의 명령으로 지워줍니다.

sudo make-kpkg clean

이래야 Stamp 파일(?)도 지워진답니다.

커널 설치

이제 컴파일되고 동시에 .deb 으로 패키지화된 커널을 아래의 명령으로 설치하는겁니다.

sudo dpkg -i ../kernel-image-<xxx>.deb

아래의 명령으로는

sudo dpkg -r kernel-image-<xxx>

기존에 설치된 커널을 삭제하는거랍니다.
근데 이렇게 삭제하는 명령은 만약 무슨일이 있을때 대안으로 부팅할수 있는 커널이 존재할때 삭제하랍니다. 혹시 지워버렸다가 뭐가 잘못되면 새롭게 만든커널 말고 예전의 커널이 필요할때가 있으니까요!

새롭게 부팅하고 새 커널 테스트하기

새롭게 부팅하면 새 커널이 부트매니져(Grub 같은..)의 리스트에 떡하니 올라와 있을거랍니다. 컴파일한걸 동시에 .deb 패키지로 만들어서 설치했기에 가능한 일인듯..

새롭게 만든 커널 크기 비교해보기

아래의 예처럼 /boot/vmlinuz 를 확인해보면 됩니다.

ls -lh /boot/vmlinuz-2.6.12 //새 Kernel
-rw-r--r-- 1 root root 1,1M 2005-12-29 12:14 /boot/vmlinuz-2.6.12

ls -lh /boot/vmlinuz-2.6.12-10-386 //예전 Kernel
-rw-r--r-- 1 root root 1,2M 2005-12-22 14:14 /boot/vmlinuz-2.6.12-10-386

위의 예에서는 새 커널이 0,1 MB 작아졌네요...







http://debianusers.org/DebianWiki/wiki.php/%C4%BF%B3%CE%C4%C4%C6%C4%C0%CF 자세한 설명이 있습니다.

--initrd 옵션에 대해서도 링크에 나와 있습니다만, 조금 부연하자면 만약 JFS 파일 시스템을 사용한다고 가정하면요, make menuconfig 에서 파일 시스템에 관한 부분을 보면 보통 JFS 는 M(모듈)로 되어 있습니다.

시스템이 처음 부팅할 때는 커널이 먼저 뜨고 커널이 모듈을 띄우는 식이라서 만약 루트(/) 시스템이나 커널과 관련된 파일이 JFS에 들어있다면 부팅이 안되는 경우가 발생합니다. 이런 경우 --initrd 옵션을 주면 먼저 초기 램디스크(initial RAM Disk) 를 만들어서 거기에 필요한 모듈을 올리고 다시 루트 파티션을 마운트 하는 방식으로 진행되는 겁니다.

만약 커널 옵션 설정 시에 JFS 를 M 이 아니라 Y 로 했다면 initrd 가 필요없습니다. 이렇게 초기 램디스크 옵션이 필요한 경우는 주로 파일 시스템과 관련된 것이나, 스카시 하드와 관련된 것이 모듈로 되어 있을 경우가 많습니다.

만약 자기 하드웨어가 정확히 뭔지를 알아서 그걸 커널 옵션에서 Y로 해준다면 굳이 저 옵션이 필요없습니다.

설치 시디는 어떤 하드웨어에서 실행될 지를 모르기 때문에 가능한 많은 하드웨어 지원 목록을 모듈 형식으로 만들어 놓게 되고, 그렇기 때문에 initrd 옵션이 필요한 것입니다.













  • Kernel
  • Compile
  • Disclaimer

    Building and using a custom kernel will make it very difficult to get support for your system.

    While it is a learning experience to compile your own kernel, you will not be allowed to file bugs on the custom-built kernel (if you do, they will be Rejected without further explanation).

    If you have a commercial support contract with Ubuntu/Canonical, this will void such support.

    Also note that this page describes how to do things for the Edgy (2.6.17) kernel and newer! Until this kernel source, we did not have any mechanisms in place that would allow people to build their own kernels easily. This was intentional.

    This page does NOT describe how to build upstream kernels fromkernel.org. This is how to rebuild the actual Ubuntu kernel starting from source.

    Reasons for compiling a custom kernel

    • You are a kernel developer.
    • You need the kernel compiled in a special way, that the official kernel is not compiled in (for example, with some experimental feature enabled).
    • You are attempting to debug a problem in the stock Ubuntu kernel for which you have filed or will file a bug report.
    • You have hardware the stock Ubuntu kernel does not support.

    Reasons for NOT compiling a custom kernel

    • You merely need to compile a special driver. For this, you only need to install the linux-headers packages.
    • You have no idea what you are doing, and if you break something, you'll need help fixing it. Depending on what you do wrong, you might end up having to reinstall your system from scratch.
    • You got to this page by mistake, and checked it out because it looked interesting, but you don't really want to learn a lot about kernels.

    If you want to install a new kernel without compilation, you can use Synaptic, search for linux-image and select the kernel version you want to install.

    An easier way is to click on System > Administration > Update Manager, then click on the Check button, and finally click onApply all updates including the kernel.

    Tools you'll need

    To start, you will need to install a few packages. The exact commands to install those packages depends on which release you are using:

    • Edgy through Gutsy:

    sudo apt-get install linux-kernel-devel fakeroot kernel-wedge build-essential makedumpfile
    • Hardy:

    sudo apt-get install linux-kernel-devel fakeroot kernel-wedge build-essential
    • Note: The package makedumpfile is not available in Hardy.

      Intrepid, Jaunty, and Karmic:

    sudo apt-get install fakeroot kernel-wedge build-essential makedumpfile kernel-package
    • Note: The linux-kernel-devel package does not exist in Intrepid, Jaunty, or any newer release. To compile the kernel on Intrepid or newer, you'll also need to run:

    sudo apt-get build-dep linux
    • This will install the compiler related packages and kernel packaging tools. It will also install the git-core package, which is the best way to interact with the Ubuntu kernel source.

      Lucid:

    sudo apt-get install fakeroot build-essential crash kexec-tools makedumpfile kernel-wedge
    sudo apt-get build-dep linux
    sudo apt-get install git-core libncurses5 libncurses5-dev libelf-dev asciidoc binutils-dev

    Get the kernel source

    There are a few ways to obtain the Ubuntu kernel source:

    A) Use git

    • Use git (detailed instructions on it can be found in the Kernel Git Guide) - This is for users who always want to stay in sync with the latest Ubuntu kernel source. 

      The git repository does not include necessary control files, so you must build them by:

    fakeroot debian/rules clean

    B) Download the source archive

    • Download the source archive - This is for users who want to rebuild the standard Ubuntu packages with additional patches. Note that this will almost always be out of date compared to the latest development source, so you should use git (option A) if you need the latest patches. To install the build dependencies and extract the source (to the current directory):

      Ubuntu Gutsy Gibbon (7.10) and previous releases

    sudo apt-get build-dep linux-source
    apt-get source linux-source
    • Ubuntu Hardy (8.04), Intrepid Ibex (8.10), Jaunty Jackalope (9.04)

    sudo apt-get build-dep --no-install-recommends --only-source linux
    apt-get source --only-source linux
    • Ubuntu modules source may also be needed if you plan to enable PAE and 64 GiB support in the kernel for 32-bit Hardy (8.04). The Ubuntu supplied modules may not be compatible with a PAE enabled kernel.

    sudo apt-get build-dep --no-install-recommends linux-ubuntu-modules-$(uname -r)
    apt-get source linux-ubuntu-modules-$(uname -r)
    • The source will be downloaded to a subdirectory inside the current directory.

      Ubuntu Karmic Koala (9.10) and newer releases

    sudo apt-get build-dep --no-install-recommends linux-image-$(uname -r)
    apt-get source linux-image-$(uname -r)
    • The source will be downloaded to the current directory (for Lucid, at least) as a trio of files (.orig.tar.gz.diff.gz, and .dsc) and a sub-directory. For instance, if uname -r returns 2.6.32-25-generic, you'll obtain linux_2.6.32.orig.tar.gzlinux_2.6.32-25.44.diff.gzlinux_2.6.32-25.44.dsc and the sub-directory linux-2.6.32.

    C) Download the source package

    • Download the source package (detailed instructions are further down this page under Alternate Build Method: The Old-Fashioned Debian Way) - This is for users who simply want to modify, or play around with, the Ubuntu-patched kernel source. Again, this will not be the most up-to-date (use option A/git if you need the latest source). Please be aware this is NOT the same as option B.

    Modify the source for your needs

    For most people, simply modifying the configs is enough. If you need to install a patch, read the instructions from the patch provider to learn how to apply it.

    The stock Ubuntu configs are located in debian/config/ARCH/ where ARCH is the architecture you are building for (Starting with Jaunty this is debian.master/config/ARCH/). In this directory there are several files. The config file is the base for all targets in that architecture. Then there are several config.FLAVOUR files that contain options specific to that target. For example, here are the files for 2.6.20, i386:

    ls -l debian/config/i386/
    total 108
    -rw-r--r-- 1 root src  73962 2007-08-13 01:29 config
    -rw-r--r-- 1 root root  1369 2007-08-13 01:29 config.386
    -rw-r--r-- 1 root root  1330 2007-08-13 01:29 config.generic
    -rw-r--r-- 1 root root  1395 2007-08-13 01:29 config.server
    -rw-r--r-- 1 root root  1756 2007-08-13 01:29 config.server-bigiron
    -rw-r--r-- 1 root root     8 2007-08-13 01:25 lowlatency
    -rw-r--r-- 1 root root   194 2007-08-13 01:25 vars.386
    -rw-r--r-- 1 root root   218 2007-08-13 01:25 vars.server-bigiron

    If you do not find the config files under debian/config, you may find them in your /boot directory (for instance,/boot/config-2.6.22-14-generic).

    If you need to change a config option, simply modify the file that contains the option. If you modify just the config file, it will affect all targets for this architecture. If you modify one of the target files, it only affects that target.

    After applying a patch, or adjusting the configs, it is always best to regenerate the config files to ensure they are consistent. There is a helper command for this. To regenerate all architectures run:

    debian/rules updateconfigs

    If you just want to update one architecture, run:

    debian/scripts/misc/oldconfig ARCH

    For these two commands to work, you need to give the scripts in the debian/scripts/misc and debian/scripts directories execute permission with the following command:

    chmod -R u+x debian/scripts/*

    Build the kernel (when source is from git repository, or from apt-get source)

    To build the kernel(s) is very simple. Depending on your needs, you may want to build all the kernel targets, or just one specific to your system. However, you also want to make sure that you do not clash with the stock kernels.

    Note: Though these outside instructions include making a separate and unique branch of the kernel, unlike here, they include thorough explanations of all necessary steps from start to finish.

    These instructions are specific to the git-tree and for the source downloaded via apt-get sourcenot when downloading the linux-source package from kernel.org

    Use this command to build all targets for the architecture you are building on:

    fakeroot debian/rules clean
    AUTOBUILD=1 fakeroot debian/rules binary-debs

    debian/rules clean creates debian/controldebian/changelog, and so on from debian.<branchname>/* (e.g. debian.master). It is necessary in git trees following git commit 3ebd3729ce35b784056239131408b9a72b0288ef "UBUNTU: [Config] Abstract the debian directory".

    The AUTOBUILD environment variable triggers special features in the kernel build. First, it skips normal ABI checks (ABI is the binary compatibility). It can do this because it also creates a unique ABI ID. If you used a git repo, this unique ID is generated from the git HEAD SHA. If not, it is generated from the uuidgen program (which means every time you execute the debian/rules build, the UUID will be different!). Your packages will be named using this ID. (Note that in Intrepid and newer, you will need skipabi=true to skip ABI checks.)

    To build a specific target, use this command:

    fakeroot debian/rules clean
    AUTOBUILD=1 NOEXTRAS=1 fakeroot debian/rules binary-FLAVOUR

    Where FLAVOUR is one of the main flavours of the kernel (e.g. generic)

    To build one of the custom flavours (found in debian/binary-custom.d/), use:

    fakeroot debian/rules clean
    AUTOBUILD=1 NOEXTRAS=1 fakeroot debian/rules custom-binary-FLAVOUR

    As of this documentation, custom flavours include xen and rt.

    If you have a more than one processor or more than one core, you can speed things up by running concurrent compile commands. Prepend CONCURRENCY_LEVEL=2 for two processors or two cores; replace '2' with whatever number suits your hardware setup (for Gutsy and later, you can alternatively use DEB_BUILD_OPTIONS=parallel=2).

    fakeroot debian/rules clean
    DEB_BUILD_OPTIONS=parallel=2 AUTOBUILD=1 NOEXTRAS=1 fakeroot debian/rules binary-generic

    If you get ABI errors, you can avoid the ABI check with skipabi=true. For example,

    fakeroot debian/rules clean
    DEB_BUILD_OPTIONS=parallel=2 AUTOBUILD=1 NOEXTRAS=1 skipabi=true fakeroot debian/rules binary-generic

    To trigger a rebuild, remove the appropriate stamp file from debian/stamps (e.g. stamp-build-server for the server flavour, etc.).

    The debs are placed in your kernel directory's parent directory.

    If needed, the Ubuntu modules source for Hardy (8.04) can be built in a similar way.

    cd linux-ubuntu-modules-2.6.24-2.6.24
    AUTOBUILD=1 fakeroot debian/rules binary-debs

    Alternatively, if you need to specify a different kernel than the running one, use

    cd linux-ubuntu-modules-2.6.24-2.6.24
    AUTOBUILD=1 fakeroot debian/rules binary-debs KDIR=/path/to/kerneldir

    If you get an error, try running this in the kerneldir: (example for the generic flavour)

    cat debian/config/i386/config debian/config/i386/config.generic > .config
    make prepare scripts

    Alternate Build Method: The Old-Fashioned Debian Way

    The new Ubuntu build system is great for developers, for people who need the absolute latest bleeding-edge kernel, and people who need to build a diverse set of kernels (several "flavours"). However it can be a little complex for ordinary users. If you don't need the latest development sources, there is a simpler way to compile your kernel from the linux-source package. As suggested above, all you need for this is:

    sudo apt-get install linux-source device-tree-compiler # device-tree-compiler is only needed if you are targeting the PowerPC architecture
    mkdir ~/src
    cd ~/src
    tar xjvf /usr/src/linux-source-<version-number-here>.tar.bz2
    cd linux-source-<version-number-here>

    Now you are in the top directory of a kernel source tree. Before building the kernel, you must configure it. If you wish to re-use the configuration of your currently-running kernel, start with

    cp -vi /boot/config-`uname -r` .config

    Before you run make menuconfig or make xconfig (which is what the next step tells you to do), make sure you have the necessary packages:

    sudo apt-get install qt3-dev-tools libqt3-mt-dev # if you plan to use 'make xconfig'
    sudo apt-get install libncurses5 libncurses5-dev # if you plan to use 'make menuconfig'

    If you would like to see what is different between your original kernel config and the new one (and decide whether you want any of the new features), you can run:

    make oldconfig

    Since the 2.6.32 kernel, a new feature allows you to update the configuration to only compile modules that are actually used in your system:

    make localmodconfig

    Then, regardless of whether you're re-using an existing configuration or starting from scratch:

    make menuconfig # or "make xconfig" if you prefer

    If you re-used the existing configuration, note that Ubuntu kernels build with debugging information on, which makes the resulting kernel modules (*.ko files) much larger than they would otherwise be. To turn this off, go into the config's "Kernel hacking"<!-- ; then, under "Kernel debugging", --> and turn OFF "Compile the kernel with debug info".

    Now you can compile the kernel and create the packages:

    make-kpkg clean # only needed if you want to do a "clean" build
    fakeroot make-kpkg --initrd --append-to-version=-some-string-here kernel-image kernel-headers

    If you also need a debug symbol package, for example for use with SystemTap, add kernel-debug onto the end of the make-kpkgcommand line.

    You can enable parallel make (just like make -j) by defining the CONCURRENCY_LEVEL environment variable. Don't try to add the -joption to make-kpkg. Try 1+number of processor cores, e.g. 3 if you have a dual core processor:

    export CONCURRENCY_LEVEL=3

    The *.deb packages will be created in the parent directory of your Linux source directory (in this example, they would be placed in~/src because our Linux source directory is ~/src/linux-source-<version-number-here>).

    Install the new kernel

    If you want to see the Ubuntu splash screen (or use text mode) before you get to X instead of just a black screen, you'll want to make sure the framebuffer driver loads:

    echo vesafb | sudo tee -a /etc/initramfs-tools/modules
    echo fbcon | sudo tee -a /etc/initramfs-tools/modules

    Now that you've told initramfs-tools which modules it should include, and once the build is complete, you can install the generated debs using dpkg:

    sudo dpkg -i linux-image-2.6.20-16-2be-k7_2.6.20-16_i386.deb
    sudo dpkg -i linux-headers-2.6.20-16-2be-k7_2.6.20-16_i386.deb

    Similarly, if you have built the Ubuntu module for Hardy (8.04) earlier, install them as follows:

    sudo dpkg -i linux-ubuntu-modules-2.6.24-16-generic_2.6.24-16.23_i386.deb
    sudo dpkg -i linux-headers-lum-2.6.24-16-generic_2.6.24-16.23_i386.deb

    If you use modules from linux-restricted-modules, you will need to recompile this against your new linux-headers package.

    Since Ubuntu Lucid (10.04) the image postinst no longer runs the initramfs creation commands. Instead, there are example scripts provided that will perform the task. These scripts will work for official kernel images as well. For example:

    sudo cp /usr/share/doc/kernel-package/examples/etc/kernel/postinst.d/initramfs /etc/kernel/postinst.d/initramfs
    sudo mkdir -p /etc/kernel/postrm.d/
    sudo cp /usr/share/doc/kernel-package/examples/etc/kernel/postrm.d/initramfs /etc/kernel/postrm.d/initramfs

    Note: I couldn't get the above scripts to help in generating an initrd for the kernel - and so the built kernel couldn't boot; the only thing that worked for me was the recommendation in http://www.debian-administration.org/article/How_Do_I_Make_an_initrd_image, "use initramfs command. It is real solution."; what I used (after the custom-built kernel's *.deb's were installed), was:

    cd /boot
    sudo mkinitramfs -k -o initrd.img-2.6.32.15+drm33.5-mylucid 2.6.32.15+drm33.5-mylucid
    sudo update-grub2

    Note (Michael): that is because you need to include the right package scripts to build the initrd at package install time. The make-kpkg option is --overlay-dir. By default, make-kpkg uses /usr/share/kernel-package as an overlay directory, which contains the default, uncustomised scripts for a Debian distribution, and not the ones needed for building a Ubuntu kernel.

    The following instructions are based on this link: http://crashcourse.ca/introduction-linux-kernel-programming/intermission-building-new-ubuntu-1004-kernel-free-lesson

    First copy the default overlay directory to your home directory:

    $ cp -r /usr/share/kernel-package $HOME

    Then install the source of the kernel you are using currently, using the exact package name, e.g.

    $ cd
    $ apt-get source linux-image-2.6.32-24-generic

    which will unpack the sources to $HOME/linux-2.6.32. Now copy the control scripts into your new overlay:

    $ cp linux-2.6.32/debian/control-scripts/{postinst,postrm,preinst,prerm} kernel-package/pkg/image/
    $ cp linux-2.6.32/debian/control-scripts/headers-postinst kernel-package/pkg/headers/

    And now you can execute make-kpkg with the additional command line option --overlay-dir=$HOME/kernel-package.

    Rebuilding ''linux-restricted-modules''

    The linux-restricted-modules (l-r-m) package contains a number of non-DFSG-free drivers (as well as some firmware and the ipw3945 wireless networking daemon) which, in a perfect world, wouldn't have to be packaged separately, but which unfortunately are not available under a GPL-compatible license. If you use any of the hardware supported by the l-r-m package, you will likely find that your system does not work as well after switching to a custom kernel. In this case you should try to compile the l-r-m package.

    See CustomRestrictedModules on how to rebuild l-r-m (if you use nVidia or ATI binary drivers, you do).

    Note: you will need around 8 hours of compilation time and around 10 Gb of hard drive space to compile all kernel flavours and restricted modules.

    Further note: There are no l-r-m or linux-restricted-modules packages in Lucid.

    Speeding Up the Build

    Use distcc and, if you're rebuilding often, ccache. A good overview of using distcc on a debian-based system is available athttp://myrddin.org/howto/using-distcc-with-debian. If you have AMD64 machines available on your local net, they can still participate in building 32-bit code; distcc seems to handle that automatically. However, with distcc taking over all compiles by default, you will need to set HOSTCC so that when kernel builds want to use the compiler on the host itself, they don't end up distributing jobs to the 64-bit server. If you fail to do that, you'll get link-compatibility failures between 64-bit and 32-bit code. Mymake-kpkg command, with /usr/lib/ccache at the head of my $PATH, looks like:

    MAKEFLAGS="HOSTCC=/usr/bin/gcc CCACHE_PREFIX=distcc" make-kpkg --rootcmd fakeroot --initrd --append-to-version=-suspend2 kernel-image kernel-headers kernel-source

    More documentation

    Comments

    Please go to the community wiki page for comments, questions and discussion: https://wiki.ubuntu.com/KernelCustomBuild

    External information