commit a8fd50b79c899b3b4958f8bb95bb5717906a37b6 · pyrox.dev/nixpkgs

+45 -38

nixos/doc/manual/configuration/linux-kernel.chapter.md

···

       82
       82
        
       sets the kernel's TCP keepalive time to 120 seconds. To see the

     

       83
       83
        
       available parameters, run `sysctl -a`.

     

       84
       84
        
       

     

       85
       85
       -
       ## Customize your kernel {#sec-linux-config-customizing}

     

       85
       85
       +
       ## Building a custom kernel {#sec-linux-config-customizing}

     

       86
       86
        
       

     

       87
       87
       -
       The first step before compiling the kernel is to generate an appropriate

     

       88
       88
       -
       `.config` configuration. Either you pass your own config via the

     

       89
       89
       -
       `configfile` setting of `linuxKernel.manualConfig`:

     

       87
       87
       +
       You can customize the default kernel configuration by overriding the arguments for your kernel package:

     

       90
       88
        
       

     

       91
       89
        
       ```nix

     

       92
       92
       -
       custom-kernel = let base_kernel = linuxKernel.kernels.linux_4_9;

     

       93
       93
       -
         in super.linuxKernel.manualConfig {

     

       94
       94
       -
           inherit (super) stdenv hostPlatform;

     

       95
       95
       -
           inherit (base_kernel) src;

     

       96
       96
       -
           version = "${base_kernel.version}-custom";

     

       97
       97
       -
       

     

       98
       98
       -
           configfile = /home/me/my_kernel_config;

     

       99
       99
       -
           allowImportFromDerivation = true;

     

       100
       100
       -
       };

     

       90
       90
       +
       pkgs.linux_latest.override {

     

       91
       91
       +
         ignoreConfigErrors = true;

     

       92
       92
       +
         autoModules = false;

     

       93
       93
       +
         kernelPreferBuiltin = true;

     

       94
       94
       +
         extraStructuredConfig = with lib.kernel; {

     

       95
       95
       +
           DEBUG_KERNEL = yes;

     

       96
       96
       +
           FRAME_POINTER = yes;

     

       97
       97
       +
           KGDB = yes;

     

       98
       98
       +
           KGDB_SERIAL_CONSOLE = yes;

     

       99
       99
       +
           DEBUG_INFO = yes;

     

       100
       100
       +
         };

     

       101
       101
       +
       }

     

       101
       102
        
       ```

     

       102
       103
        
       

     

       103
       103
       -
       You can edit the config with this snippet (by default `make

     

       104
       104
       -
          menuconfig` won\'t work out of the box on nixos):

     

       104
       104
       +
       See `pkgs/os-specific/linux/kernel/generic.nix` for details on how these arguments

     

       105
       105
       +
       affect the generated configuration. You can also build a custom version of Linux by calling

     

       106
       106
       +
       `pkgs.buildLinux` directly, which requires the `src` and `version` arguments to be specified.

     

       107
       107
       +
       

     

       108
       108
       +
       To use your custom kernel package in your NixOS configuration, set

     

       105
       109
        
       

     

       106
       106
       -
       ```ShellSession

     

       107
       107
       -
       nix-shell -E 'with import <nixpkgs> {}; kernelToOverride.overrideAttrs (o: {nativeBuildInputs=o.nativeBuildInputs ++ [ pkg-config ncurses ];})'

     

       110
       110
       +
       ```nix

     

       111
       111
       +
       boot.kernelPackages = pkgs.linuxPackagesFor yourCustomKernel;

     

       108
       112
        
       ```

     

       109
       113
        
       

     

       110
       110
       -
       or you can let nixpkgs generate the configuration. Nixpkgs generates it

     

       111
       111
       -
       via answering the interactive kernel utility `make config`. The answers

     

       112
       112
       -
       depend on parameters passed to

     

       113
       113
       -
       `pkgs/os-specific/linux/kernel/generic.nix` (which you can influence by

     

       114
       114
       -
       overriding `extraConfig, autoModules,

     

       115
       115
       -
          modDirVersion, preferBuiltin, extraConfig`).

     

       114
       114
       +
       Note that this method will use the common configuration defined in `pkgs/os-specific/linux/kernel/common-config.nix`,

     

       115
       115
       +
       which is suitable for a NixOS system.

     

       116
       116
       +
       

     

       117
       117
       +
       If you already have a generated configuration file, you can build a kernel that uses it with `pkgs.linuxManualConfig`:

     

       116
       118
        
       

     

       117
       119
        
       ```nix

     

       118
       118
       -
       mptcp93.override ({

     

       119
       119
       -
         name="mptcp-local";

     

       120
       120
       +
       let

     

       121
       121
       +
         baseKernel = pkgs.linux_latest;

     

       122
       122
       +
       in pkgs.linuxManualConfig {

     

       123
       123
       +
         inherit (baseKernel) src modDirVersion;

     

       124
       124
       +
         version = "${baseKernel.version}-custom";

     

       125
       125
       +
         configfile = ./my_kernel_config;

     

       126
       126
       +
         allowImportFromDerivation = true;

     

       127
       127
       +
       }

     

       128
       128
       +
       ```

     

       120
       129
        
       

     

       121
       121
       -
         ignoreConfigErrors = true;

     

       122
       122
       -
         autoModules = false;

     

       123
       123
       -
         kernelPreferBuiltin = true;

     

       130
       130
       +
       ::: {.note}

     

       131
       131
       +
       The build will fail if `modDirVersion` does not match the source's `kernel.release` file,

     

       132
       132
       +
       so `modDirVersion` should remain tied to `src`.

     

       133
       133
       +
       :::

     

       124
       134
        
       

     

       125
       125
       -
         enableParallelBuilding = true;

     

       135
       135
       +
       To edit the `.config` file for Linux X.Y, proceed as follows:

     

       126
       136
        
       

     

       127
       127
       -
         extraConfig = ''

     

       128
       128
       -
           DEBUG_KERNEL y

     

       129
       129
       -
           FRAME_POINTER y

     

       130
       130
       -
           KGDB y

     

       131
       131
       -
           KGDB_SERIAL_CONSOLE y

     

       132
       132
       -
           DEBUG_INFO y

     

       133
       133
       -
         '';

     

       134
       134
       -
       });

     

       137
       137
       +
       ```ShellSession

     

       138
       138
       +
       $ nix-shell '<nixpkgs>' -A linuxKernel.kernels.linux_X_Y.configEnv

     

       139
       139
       +
       $ unpackPhase

     

       140
       140
       +
       $ cd linux-*

     

       141
       141
       +
       $ make nconfig

     

       135
       142
        
       ```

     

       136
       143
        
       

     

       137
       144
        
       ## Developing kernel modules {#sec-linux-config-developing-modules}

     

       138
       145
        
       

     

       139
       139
       -
       When developing kernel modules it\'s often convenient to run

     

       146
       146
       +
       When developing kernel modules it's often convenient to run

     

       140
       147
        
       edit-compile-run loop as quickly as possible. See below snippet as an

     

       141
       148
        
       example of developing `mellanox` drivers.

     

       142
       149

+61 -44

nixos/doc/manual/from_md/configuration/linux-kernel.chapter.xml

···

       96
       96
        
           available parameters, run <literal>sysctl -a</literal>.

     

       97
       97
        
         </para>

     

       98
       98
        
         <section xml:id="sec-linux-config-customizing">

     

       99
       99
       -
           <title>Customize your kernel</title>

     

       99
       99
       +
           <title>Building a custom kernel</title>

     

       100
       100
        
           <para>

     

       101
       101
       -
             The first step before compiling the kernel is to generate an

     

       102
       102
       -
             appropriate <literal>.config</literal> configuration. Either you

     

       103
       103
       -
             pass your own config via the <literal>configfile</literal> setting

     

       104
       104
       -
             of <literal>linuxKernel.manualConfig</literal>:

     

       101
       101
       +
             You can customize the default kernel configuration by overriding

     

       102
       102
       +
             the arguments for your kernel package:

     

       105
       103
        
           </para>

     

       106
       104
        
           <programlisting language="bash">

     

       107
       107
       -
       custom-kernel = let base_kernel = linuxKernel.kernels.linux_4_9;

     

       108
       108
       -
         in super.linuxKernel.manualConfig {

     

       109
       109
       -
           inherit (super) stdenv hostPlatform;

     

       110
       110
       -
           inherit (base_kernel) src;

     

       111
       111
       -
           version = &quot;${base_kernel.version}-custom&quot;;

     

       112
       112
       -
       

     

       113
       113
       -
           configfile = /home/me/my_kernel_config;

     

       114
       114
       -
           allowImportFromDerivation = true;

     

       115
       115
       -
       };

     

       105
       105
       +
       pkgs.linux_latest.override {

     

       106
       106
       +
         ignoreConfigErrors = true;

     

       107
       107
       +
         autoModules = false;

     

       108
       108
       +
         kernelPreferBuiltin = true;

     

       109
       109
       +
         extraStructuredConfig = with lib.kernel; {

     

       110
       110
       +
           DEBUG_KERNEL = yes;

     

       111
       111
       +
           FRAME_POINTER = yes;

     

       112
       112
       +
           KGDB = yes;

     

       113
       113
       +
           KGDB_SERIAL_CONSOLE = yes;

     

       114
       114
       +
           DEBUG_INFO = yes;

     

       115
       115
       +
         };

     

       116
       116
       +
       }

     

       116
       117
        
       </programlisting>

     

       117
       118
        
           <para>

     

       118
       118
       -
             You can edit the config with this snippet (by default

     

       119
       119
       -
             <literal>make menuconfig</literal> won't work out of the box on

     

       120
       120
       -
             nixos):

     

       119
       119
       +
             See <literal>pkgs/os-specific/linux/kernel/generic.nix</literal>

     

       120
       120
       +
             for details on how these arguments affect the generated

     

       121
       121
       +
             configuration. You can also build a custom version of Linux by

     

       122
       122
       +
             calling <literal>pkgs.buildLinux</literal> directly, which

     

       123
       123
       +
             requires the <literal>src</literal> and <literal>version</literal>

     

       124
       124
       +
             arguments to be specified.

     

       121
       125
        
           </para>

     

       122
       122
       -
           <programlisting>

     

       123
       123
       -
       nix-shell -E 'with import &lt;nixpkgs&gt; {}; kernelToOverride.overrideAttrs (o: {nativeBuildInputs=o.nativeBuildInputs ++ [ pkg-config ncurses ];})'

     

       126
       126
       +
           <para>

     

       127
       127
       +
             To use your custom kernel package in your NixOS configuration, set

     

       128
       128
       +
           </para>

     

       129
       129
       +
           <programlisting language="bash">

     

       130
       130
       +
       boot.kernelPackages = pkgs.linuxPackagesFor yourCustomKernel;

     

       124
       131
        
       </programlisting>

     

       125
       132
        
           <para>

     

       126
       126
       -
             or you can let nixpkgs generate the configuration. Nixpkgs

     

       127
       127
       -
             generates it via answering the interactive kernel utility

     

       128
       128
       -
             <literal>make config</literal>. The answers depend on parameters

     

       129
       129
       -
             passed to

     

       130
       130
       -
             <literal>pkgs/os-specific/linux/kernel/generic.nix</literal>

     

       131
       131
       -
             (which you can influence by overriding

     

       132
       132
       -
             <literal>extraConfig, autoModules, modDirVersion, preferBuiltin, extraConfig</literal>).

     

       133
       133
       +
             Note that this method will use the common configuration defined in

     

       134
       134
       +
             <literal>pkgs/os-specific/linux/kernel/common-config.nix</literal>,

     

       135
       135
       +
             which is suitable for a NixOS system.

     

       136
       136
       +
           </para>

     

       137
       137
       +
           <para>

     

       138
       138
       +
             If you already have a generated configuration file, you can build

     

       139
       139
       +
             a kernel that uses it with

     

       140
       140
       +
             <literal>pkgs.linuxManualConfig</literal>:

     

       133
       141
        
           </para>

     

       134
       142
        
           <programlisting language="bash">

     

       135
       135
       -
       mptcp93.override ({

     

       136
       136
       -
         name=&quot;mptcp-local&quot;;

     

       137
       137
       -
       

     

       138
       138
       -
         ignoreConfigErrors = true;

     

       139
       139
       -
         autoModules = false;

     

       140
       140
       -
         kernelPreferBuiltin = true;

     

       141
       141
       -
       

     

       142
       142
       -
         enableParallelBuilding = true;

     

       143
       143
       -
       

     

       144
       144
       -
         extraConfig = ''

     

       145
       145
       -
           DEBUG_KERNEL y

     

       146
       146
       -
           FRAME_POINTER y

     

       147
       147
       -
           KGDB y

     

       148
       148
       -
           KGDB_SERIAL_CONSOLE y

     

       149
       149
       -
           DEBUG_INFO y

     

       150
       150
       -
         '';

     

       151
       151
       -
       });

     

       143
       143
       +
       let

     

       144
       144
       +
         baseKernel = pkgs.linux_latest;

     

       145
       145
       +
       in pkgs.linuxManualConfig {

     

       146
       146
       +
         inherit (baseKernel) src modDirVersion;

     

       147
       147
       +
         version = &quot;${baseKernel.version}-custom&quot;;

     

       148
       148
       +
         configfile = ./my_kernel_config;

     

       149
       149
       +
         allowImportFromDerivation = true;

     

       150
       150
       +
       }

     

       151
       151
       +
       </programlisting>

     

       152
       152
       +
           <note>

     

       153
       153
       +
             <para>

     

       154
       154
       +
               The build will fail if <literal>modDirVersion</literal> does not

     

       155
       155
       +
               match the source’s <literal>kernel.release</literal> file, so

     

       156
       156
       +
               <literal>modDirVersion</literal> should remain tied to

     

       157
       157
       +
               <literal>src</literal>.

     

       158
       158
       +
             </para>

     

       159
       159
       +
           </note>

     

       160
       160
       +
           <para>

     

       161
       161
       +
             To edit the <literal>.config</literal> file for Linux X.Y, proceed

     

       162
       162
       +
             as follows:

     

       163
       163
       +
           </para>

     

       164
       164
       +
           <programlisting>

     

       165
       165
       +
       $ nix-shell '&lt;nixpkgs&gt;' -A linuxKernel.kernels.linux_X_Y.configEnv

     

       166
       166
       +
       $ unpackPhase

     

       167
       167
       +
       $ cd linux-*

     

       168
       168
       +
       $ make nconfig

     

       152
       169
        
       </programlisting>

     

       153
       170
        
         </section>

     

       154
       171
        
         <section xml:id="sec-linux-config-developing-modules">

     

       155
       172
        
           <title>Developing kernel modules</title>

     

       156
       173
        
           <para>

     

       157
       157
       -
             When developing kernel modules it's often convenient to run

     

       174
       174
       +
             When developing kernel modules it’s often convenient to run

     

       158
       175
        
             edit-compile-run loop as quickly as possible. See below snippet as

     

       159
       176
        
             an example of developing <literal>mellanox</literal> drivers.

     

       160
       177
        
           </para>

pkgs/os-specific/linux/kernel/generic.nix

···

       206
       206
        
           features = kernelFeatures;

     

       207
       207
        
           inherit commonStructuredConfig structuredExtraConfig extraMakeFlags isZen isHardened isLibre;

     

       208
       208
        
           isXen = lib.warn "The isXen attribute is deprecated. All Nixpkgs kernels that support it now have Xen enabled." true;

     

       209
       209
       +
       

     

       210
       210
       +
           # Adds dependencies needed to edit the config:

     

       211
       211
       +
           # nix-shell '<nixpkgs>' -A linux.configEnv --command 'make nconfig'

     

       212
       212
       +
           configEnv = kernel.overrideAttrs (old: {

     

       213
       213
       +
             nativeBuildInputs = old.nativeBuildInputs or [] ++ (with buildPackages; [

     

       214
       214
       +
               pkg-config ncurses

     

       215
       215
       +
             ]);

     

       216
       216
       +
           });

     

       217
       217
       +
       

     

       209
       218
        
           passthru = kernel.passthru // (removeAttrs passthru [ "passthru" ]);

     

       210
       219
        
           tests = let

     

       211
       220
        
             overridableKernel = finalKernel // {