Boot with a liveCD's and look what it is using:

Launch the following programs:

lspci from pciutils package

lspci -v to get more details. lspci -vvv | grep Kernel to see what kernel modules get used.

lspci -vvv -s 00:10.2 to see just one single card

lspci -k to see the kernel modules supporting the cards and if in use

update-pciids update the list of known PCI ID and put it in /usr/share/misc/pci.ids , this is where the text of lspci comes from.

lsmod

lshw

lsusb

dmesg

gtk-lshw (emerge lshw)

hwinfo

cat /proc/modules lists them or better formatted:

cat /proc/modules | cut -d ' ' -f 1

Check the Ethernet card since update via Internet requires it. Use the help and description in make menuconfig, make nconfig, using X make xconfig or make gconfig. Check there the kernel module names later to be seen when you use the command lsmod.

An easier way than create the .config file is finding somebody who already has done it, so look to find a .config.

There is make help that prints out a lot make inside the kernel source directory can do.

This section gives some hints about kernel compilation or information when building the first time a kernel on a new computer. For kernel updated go directly to the kernel compilation section.

The kernel sources are in the directory cd /usr/src. To see whats there type ls -l. The symbolic link Linux points to the selected source. To update the source manually, the old link can be removed rm /usr/src/linux and a new link can be created ln -s linux-<nnn> linux.

Use make xconfig to have the short documentation available when for the options. Documentation is on the Internet or /usr/src/linux/Documentation.

or https://www.kernel.org/doc/ that is build from the file /usr/src/linux/arch/x86/Kconfig. This file includes lines as

source "init/Kconfig"

that include other files.

The kernel configuration of the hidden file /usr/src/linux/.config can be attached to the kernel. The kernel options IKCONFIG (general setup > kernel .config support) and IKCONFIG_PROC (general setup > enable access to .config through /proc/config.gz> must be set.

When the kernel is running and having set IKCONFIG_PROC the /usr/src/linux/.config can be unzipped from /proc/config.gz gunzip config.gz.

To restore cd /usr/src/linux and zcat /proc/config.gz > .config

The other option is:

scripts/extract-ikconfig <name of the kernel file>

Before rebooting and running into version problems with some kernel modules not delivered with the new kernel source. Re-emerge those kernel modules now, since the link points already to the new kernel source (even the old kernel is running) so the drivers will match the kernel version, otherwise the kernel probably will refuse to load those drivers (Other way would be using the option to force loading kernel modules with mismatching versions exist, however this is less clean and safe).

Further if selecting in Grub at boot time previous compiled kernels, an other problem might occur. Kernel modules are still used from the last compilation and might no more be compatible to the previous installation, they might even block your computer. Therefore all kernel modules not taken from the kernel need to be re-compiled as well.

To not manually remember what kernel modules are installed, Gentoo Linux has a tool emerge module-rebuild that does a rebuild to all used kernel modules not delivered with the kernel source

module-rebuild rebuild

does the job. An alternative would be emerge all packages individually.

For an overview see:http://tldp.org/HOWTO/KernelAnalysis-HOWTO.html

Applications can communicate with the kernel using system calls. All system calls are listed in /usr/src/linux/include/asm/unistd.h

The applications prepare the data for the system call and create an interrupt to call the kernel to do something. The following example shows how a C program makes the system call write.

#include <unistd.h>
int main ()
{
  write(0,"Hello World\n", 12);
}

unistd.h is the c library that holds the system call C functions.

0 is the file descriptor and means standard input output. 12 stands for the 12 characters to be printed.

The following program when started gets obviously a process ID, but it also creates a second child process using the fork command. After that both parent and child process get trapped in while loops. Using the KDE System guard both processes can be observed and killed (parent)!

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main ()
{
  int forkvar;
  forkvar = fork();
  if(forkvar==0)
  {
    printf("child process\n");
    while(1);
  }
  else
  {
    printf("parent process started child with PID:%i\n",forkvar);
    while(1);
  }
  return 0;
} 

Now, the child process is running, but as a second instance of the parent process. The kernel has a process table that actually can be seen using KDE System guard. Child and parent process running with the same parameters but different PID's. In the tree view the relation between child and parent (and bash that has called them) can also be verified.

The following line can be put into the program to call an other program

execl("<path to and the the binary>","<name of the program>,NULL);

The data in the process table will be replaced.

<path to and the binary> has to be replaced by program to be executed including the directory

<name of the program> has to be replaced

NULL stands for null arguments passed to the program

Processes can have different status:

The process table is defined in /usr/src/linux/include/linux/sched.h see the definition:

struct task_struct 

Different signals can be sent to the processes

Over the years the kernel configuration could be come bloated, resulting in big kernels and long compilation time.

Automatic trimming of the /usr/src/linux/.config file is done with make localmodconfig but this cleans modules that are not loaded (as not appear with lsmod). Such modules however might be used when plug in hardware as usb devices or mounting file systems.

To improve this setup modprobed-db

modprobed-db --help

Run it frequently over the next weeks to log the modules used

cron job

0 */6 * * * /usr/bin/modprobed-db store &> /dev/null

For cronie

cat <<'EOF' > /etc/cron.hourly/modprobed-db #!/bin/sh /usr/bin/modprobed-db store EOF

chmod +x /etc/cron.hourly/modprobed-db

run-parts /etc/cron.hourly

~/.config/modprobed-db.conf is the configuration and ~/.config/modprobed.db the list of modules loaded

With a more complete ~/.config/modprobed.db run make LSMOD=~/.config/modprobed.db localmodconfig

Just modules as files set with (m) not build into the kernel (y) are affected. So to get smaller kernels first try to convert (y) to (m) manually, but take care modules required to boot must be inside the kernel (y) or be inside a initramfs. Check cat .config | grep "=y"

The other way building a big monolithic kernel would be possible with make localyesconfig

make oldconfig with user prompt and make olddefconfig without user prompt will update the /usr/src/linux/.config to the new kernel version and add new settings. make defconfig creates a default /usr/src/linux/.config file

./scripts/diffconfig .config.actual .config.default is a diff tool coming with the kernel to show the differences in a more specific form.

- means just exists in the actual file and be absent in the default file but do not delete it in the actual file

+ means just exists in the default file and be absent in the current file but do not add it in the current file

SND_HDA_CODEC_ANALOG m -> n means first file had (m) second has disabled it (n)