all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
From: Efraim Flashner <efraim@flashner.co.il>
To: guix-devel@gnu.org, Pierre Neidhardt <mail@ambrevar.xyz>,
	Ludovic Courts <ludo@gnu.org>,
	Chris Marusich <cmmarusich@gmail.com>
Subject: [BLOG] custom kernel config
Date: Wed, 15 May 2019 21:09:45 +0300	[thread overview]
Message-ID: <20190515180945.GA7636@macbook41> (raw)
In-Reply-To: <20190401180434.GF21029@macbook41>


[-- Attachment #1.1: Type: text/plain, Size: 573 bytes --]

I've cleaned up the blog post a bit and run it through a spell checker.
I'm unsure about Linux-Libre vs linux-libre, regarding talking about the
kernel and the package. I think I glossed over it well enough that I
didn't actually get a custom kernel up and running on my laptop, but for
the purpose of the blog post I don't think it's actually necessary.

-- 
Efraim Flashner   <efraim@flashner.co.il>   אפרים פלשנר
GPG key = A28B F40C 3E55 1372 662D  14F7 41AA E7DC CA3D 8351
Confidentiality cannot be guaranteed on emails sent or received unencrypted

[-- Attachment #1.2: custom-kernel.md --]
[-- Type: text/plain, Size: 11540 bytes --]

title: Creating and using a custom Linux kernel on Guix System
date: 2019-05-20 00:00
author: Efraim Flashner
tags: kernel, customization
---

Guix is, at its core, a source based distribution with substitutes, and
as such building packages from their source code is an expected part of
regular package installations and upgrades.  Given this starting point,
it makes sense that efforts are made to reduce the amount of time spent
compiling packages, and recent changes and upgrades to the building and
distribution of substitutes continues to be a topic of discussion within
Guix.  One of the packages which I prefer to not build myself is the
Linux-Libre kernel.  The kernel, while not requiring an overabundance of
RAM to build, does take a very long time on my build machine (which my
children argue is actually their Kodi computer), and I will often delay
reconfiguring my laptop while I want for a substitute to be prepared by
the official build farm.  The official kernel configuration, as is the
case with many GNU/Linux distributions, errs on the side of
inclusiveness, and this is really what causes the build to take such a
long time when I build the package for myself.

The Linux kernel, however, can also just be described as a package
installed on my machine, and as such can be customized just like any
other package.  The procedure is a little bit different, although this
is primarily due to the nature of how the package definition is written.

The linux-libre kernel package definition is actually a procedure which
creates a package.

```scheme
(define* (make-linux-libre version hash supported-systems
                           #:key
                           ;; A function that takes an arch and a variant.
                           ;; See kernel-config for an example.
                           (extra-version #f)
                           (configuration-file #f)
                           (defconfig "defconfig")
                           (extra-options %default-extra-linux-options)
                           (patches (list %boot-logo-patch)))
  ...)
```

The current linux-libre package is for the 5.1.x series, and is
declared like this:

```scheme
(define-public linux-libre
  (make-linux-libre %linux-libre-version
                    %linux-libre-hash
                    '("x86_64-linux" "i686-linux" "armhf-linux" "aarch64-linux")
                    #:patches %linux-libre-5.1-patches
                    #:configuration-file kernel-config))
```

Any keys which are not assigned values inherit their default value from
the make-linux-libre definition.  When comparing the two snippets above,
you may notice that the code comment in the first doesn't actually refer
to the extra-version keyword; it is actually for configuration-file.
Because of this, it is not actually easy to include a custom kernel
configuration from the definition, but don't worry, there are other ways
to work with what we do have.

There are two ways to create a kernel with a custom kernel configuration.
The first is to provide a standard '.config' file during the build
process by including an actual '.config' file as a native-input to our
custom kernel.  The following is a snippet from the custom 'configure
phase of the make-linux-libre package definition:

```scheme
(let ((build  (assoc-ref %standard-phases 'build))
      (config (assoc-ref (or native-inputs inputs) "kconfig")))

  ;; Use a custom kernel configuration file or a default
  ;; configuration file.
  (if config
      (begin
        (copy-file config ".config")
        (chmod ".config" #o666))
      (invoke "make" ,defconfig))
```

Below is a sample kernel package for one of my computers:

```scheme
(define-public linux-libre-E2140
  (let ((base
          ((@@ (gnu packages linux) make-linux-libre)
           (@@ (gnu packages linux) %linux-libre-version)
           (@@ (gnu packages linux) %linux-libre-hash)
           '("x86_64-linux")
           #:extra-version "E2140"
           #:patches (@@ (gnu packages linux) %linux-libre-5.1-patches))))
    (package
      (inherit base)
      (native-inputs
       `(("kconfig" ,(local-file "E2140.config"))
         ,@(package-native-inputs base))))))
```

In the same directory as the file defining linux-libre-E2140 is a file
named E2140.config, which is an actual kernel configuration file.  I
left the defconfig keyword of make-linux-libre blank, so the only kernel
configuration in the package is the one which I included as a native-input.

The second way to create a custom kernel is to pass a new value to the
extra-options keyword of the make-linux-libre procedure.  The
extra-options keyword works with another function defined right below it:

```scheme
(define %default-extra-linux-options
  `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
   ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #t)
   ;; Modules required for initrd:
   ("CONFIG_NET_9P" . m)
   ("CONFIG_NET_9P_VIRTIO" . m)
   ("CONFIG_VIRTIO_BLK" . m)
   ("CONFIG_VIRTIO_NET" . m)
   ("CONFIG_VIRTIO_PCI" . m)
   ("CONFIG_VIRTIO_BALLOON" . m)
   ("CONFIG_VIRTIO_MMIO" . m)
   ("CONFIG_FUSE_FS" . m)
   ("CONFIG_CIFS" . m)
   ("CONFIG_9P_FS" . m)))

(define (config->string options)
  (string-join (map (match-lambda
                      ((option . 'm)
                       (string-append option "=m"))
                      ((option . #t)
                       (string-append option "=y"))
                      ((option . #f)
                       (string-append option "=n")))
                    options)
               "\n"))
```

And in the custom configure script from the make-linux-libre package:

```scheme
;; Appending works even when the option wasn't in the
;; file.  The last one prevails if duplicated.
(let ((port (open-file ".config" "a"))
      (extra-configuration ,(config->string extra-options)))
  (display extra-configuration port)
  (close-port port))

(invoke "make" "oldconfig"))))
```

So by not providing a configuration-file the '.config' starts blank, and
then we write into it the collection of flags that we want.  Here's
another custom kernel which I have:

```scheme
(define %macbook41-full-config
  (append %macbook41-config-options
          %filesystems
          %efi-support
          %emulation
          (@@ (gnu packages linux) %default-extra-linux-options)))

(define-public linux-libre-macbook41
  ;; XXX: Access the internal 'make-linux-libre' procedure, which is
  ;; private and unexported, and is liable to change in the future.
  ((@@ (gnu packages linux) make-linux-libre) (@@ (gnu packages linux) %linux-libre-version)
                      (@@ (gnu packages linux) %linux-libre-hash)
                      '("x86_64-linux")
                      #:extra-version "macbook41"
                      #:patches (@@ (gnu packages linux) %linux-libre-5.1-patches)
                      #:extra-options %macbook41-config-options))
```

From the above example %filesystems is a collection of flags enabling
different filesystem support, %efi-support enables EFI support and
%emulation enables my x86_64-linux machine to act in 32-bit mode also.
%default-extra-linux-options are the ones quoted above, which had to be
added in since I used replaced them in the extra-options keyword.

This all sounds like it should be doable, but how does one even know
which modules are required for their system?  The two places I found
most helpful to try to answer this question were the [Gentoo
Handbook](https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel),
and the
[documentation](https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig)
from the kernel itself.  From the kernel documentation, it seems that
"make localmodconfig" is the command we want.

In order to actually run `make localmodconfig` we first need to get and
unpack the kernel source code:

```shell
tar xf $(guix build linux-libre --source)
```

Once inside the directory containing the source code run `touch .config`
to create an initial, empty '.config' to start with.  `make
localmodconfig` works by seeing what you already have in '.config' and
letting you know what you're missing.  If the file is blank then you're
missing everything.  The next step is to run

```shell
make localmodconfig
```

and note the output.  Do note that the '.config' file is still empty.
The output generally contains two types of warnings.  The first start
with "WARNING" and can actually be ignored in our case.  The second read:
```shell
module pcspkr did not have configs CONFIG_INPUT_PCSPKR
```

For each of these lines, copy the CONFIG_XXXX_XXXX portion into the
'.config' in the directory, and append "=m", so in the end it looks
like this:
```shell
CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m
```

After copying all the configuration options, run `make localmodconfig`
again to make sure that you don't have any output starting with
"module".  After all of these machine specific modules there are a
couple more left that are also needed.  CONFIG_MODULES is necessary so
that you can build and load modules separately and not have everything
built into the kernel.  CONFIG_BLK_DEV_SD is required for reading from
hard drives.  It is possible that there are other modules which you
will need.

This post does not aim to be a guide to configuring your own kernel
however, so if you do decide to build a custom kernel you'll have to
seek out other guides to create a kernel which is just right for your
needs.

The second way to setup the kernel configuration makes more use of
Guix's features and allows you to share configuration segments between
different kernels.  For example, all machines using EFI to boot have a
number of EFI configuration flags that they need.  It is likely that all
the kernels will share a list of filesystems to support.  By using
variables it is easier to see at a glance what features are enabled and
to make sure you don't have features in one kernel but missing in another.

Left undiscussed however, is Guix's initrd and its customization.  It is
likely that you'll need to modify the initrd on a machine using a custom
kernel, since certain modules which are expected to be built may not be
available for inclusion into the initrd.

Suggestions and contributions toward working toward a satisfactory
custom initrd and kernel are welcome!

#### About GNU Guix

[GNU Guix](https://www.gnu.org/software/guix) is a transactional package
manager and an advanced distribution of the GNU system that [respects
user
freedom](https://www.gnu.org/distros/free-system-distribution-guidelines.html).
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.

In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection.  When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management.  Guix is highly customizable
and hackable through [Guile](https://www.gnu.org/software/guile)
programming interfaces and extensions to the
[Scheme](http://schemers.org) language.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

  parent reply	other threads:[~2019-05-15 18:09 UTC|newest]

Thread overview: 36+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-04-01 18:04 custom kernel config Efraim Flashner
2019-04-01 18:30 ` Pierre Neidhardt
2019-04-02  5:37   ` Efraim Flashner
2019-04-02  8:04     ` Pierre Neidhardt
2019-04-02 14:49       ` Efraim Flashner
2019-04-01 19:46 ` Ludovic Courtès
2019-04-02 14:50   ` Efraim Flashner
2019-04-03  8:08 ` Chris Marusich
2019-04-03 19:04   ` Efraim Flashner
2019-04-03 19:49     ` Pierre Neidhardt
2019-04-03 20:27       ` Efraim Flashner
2019-04-04  8:44         ` Chris Marusich
2019-04-07 14:36           ` Efraim Flashner
2019-04-07 17:25             ` Pierre Neidhardt
2019-04-08 14:52             ` Ludovic Courtès
2019-04-08 15:03               ` Pierre Neidhardt
2019-05-01  7:54                 ` Pierre Neidhardt
2019-05-06  3:46                   ` Chris Marusich
2019-05-06  8:01                     ` Efraim Flashner
2019-05-06  8:34                       ` Pierre Neidhardt
2019-05-01  9:31               ` Mark H Weaver
2019-05-01 14:15                 ` Ludovic Courtès
2019-05-15 18:09 ` Efraim Flashner [this message]
2019-05-16 11:10   ` [BLOG] " Pierre Neidhardt
2019-05-16 19:15     ` Efraim Flashner
2019-05-16 11:48   ` Pierre Neidhardt
2019-05-16 14:29   ` Marius Bakke
2019-05-16 14:33     ` Pierre Neidhardt
2019-05-16 19:14     ` Efraim Flashner
2019-05-17  0:15     ` Mark H Weaver
2019-05-17  7:50       ` Efraim Flashner
2019-05-20 14:57         ` Ludovic Courtès
2019-05-20 17:38           ` Efraim Flashner
2019-05-21 10:07             ` Ludovic Courtès
2019-05-21 12:46               ` zimoun
2019-05-18  2:04       ` ison

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20190515180945.GA7636@macbook41 \
    --to=efraim@flashner.co.il \
    --cc=cmmarusich@gmail.com \
    --cc=guix-devel@gnu.org \
    --cc=ludo@gnu.org \
    --cc=mail@ambrevar.xyz \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.