🥇Como comezar a usar o modo de usuario en Linux

Introdución do tradutor: ante a entrada masiva nas nosas vidas de diversos tipos de envases, pode ser bastante interesante e útil descubrir con que tecnoloxías comezou todo unha vez. Algúns deles poden ser útiles ata hoxe, pero non todos lembran tales métodos (ou saben se non foron capturados durante o seu rápido desenvolvemento). Unha destas tecnoloxías é User Mode Linux. O autor do orixinal investigou moito, descubriu cales dos antigos desenvolvementos aínda funcionan e cales non, e elaborou algo así como unha instrución paso a paso sobre como conseguir un UML homebrew en 2k19. E si, invitamos ao autor do post orixinal a Habr Cadey, así que se tes algunha dúbida, pregunta en inglés nos comentarios.

O modo de usuario en Linux é, de feito, un porto do núcleo de Linux para si mesmo. Este modo permítelle executar un núcleo Linux completo como proceso de usuario e adoita utilizar os desenvolvedores para probar controladores. Pero este modo tamén é útil como ferramenta de illamento xeral, cuxo principio é similar ao funcionamento das máquinas virtuais. Este modo ofrece máis illamento que Docker, pero menos que unha máquina virtual completa como KVM ou Virtual Box.

En xeral, o modo de usuario pode parecer unha ferramenta estraña e difícil de usar, pero aínda ten os seus usos. Despois de todo, este é un núcleo Linux completo que se executa desde un usuario sen privilexios. Esta función permite que o código potencialmente non fiable se execute sen ningunha ameaza para a máquina host. E como este é un núcleo completo, os seus procesos están illados da máquina host, é dicir os procesos que se executan no modo de usuario non serán visibles para o host. Isto non é como o contedor Docker habitual, nese caso a máquina host sempre ve os procesos dentro do repositorio. Mira esta peza de pstree dun dos meus servidores:

containerd─┬─containerd-shim─┬─tini─┬─dnsd───19*[{dnsd}]
           │                 │      └─s6-svscan───s6-supervise
           │                 └─10*[{containerd-shim}]
           ├─containerd-shim─┬─tini─┬─aerial───21*[{aerial}]
           │                 │      └─s6-svscan───s6-supervise
           │                 └─10*[{containerd-shim}]
           ├─containerd-shim─┬─tini─┬─s6-svscan───s6-supervise
           │                 │      └─surl
           │                 └─9*[{containerd-shim}]
           ├─containerd-shim─┬─tini─┬─h───13*[{h}]
           │                 │      └─s6-svscan───s6-supervise
           │                 └─10*[{containerd-shim}]
           ├─containerd-shim─┬─goproxy───14*[{goproxy}]
           │                 └─9*[{containerd-shim}]
           └─32*[{containerd}]

E compara isto co pstree do núcleo de Linux no modo de usuario:

linux─┬─5*[linux]
      └─slirp

Cando traballo con contedores Docker, podo ver dende o host os nomes dos procesos que se están a executar no convidado. Co modo de usuario de Linux, isto non é posible. Qué significa? Isto significa que as ferramentas de seguimento que se executan a través do subsistema de auditoría de Linux non vexo procesos que se executan no sistema convidado. Pero nalgunhas situacións, esta característica pode converterse nunha espada de dobre fío.

En xeral, a seguinte publicación é unha colección de investigacións e intentos aproximados para lograr o resultado desexado. Para iso, tiven que usar varias ferramentas antigas, ler as fontes do núcleo, facer unha depuración intensiva do código escrito na época na que aínda estaba na escola primaria e tamén xogar coas compilacións de Heroku usando un binario especial para atopar as ferramentas que necesitaba. . Todo este traballo levou aos mozos do meu IRC a chamarme maxia. Espero que esta publicación sirva de documentación fiable para que alguén intente o mesmo con núcleos e versións do sistema operativo máis recentes.

axuste

A configuración do modo de usuario de Linux faise en varios pasos:

instalar dependencias no host;
descargar o núcleo de Linux;
configuración de compilación do núcleo;
montaxe do núcleo;
instalación binaria;
configurar o sistema de ficheiros convidado;
selección de parámetros de inicio do núcleo;
configurar unha rede de convidados;
iniciando o núcleo convidado.

Supoño que se decides facelo por ti mesmo, o máis probable é que fagas todo o que se describe nalgún sistema tipo Ubuntu ou Debian. Tentei implementar todo o anterior na miña distribución favorita: Alpine, pero non saíu nada, ao parecer debido ao feito de que o núcleo de Linux ten un glibc-ismos de obrigado cumprimento para os controladores no modo de usuario. Planeo informar isto a upstream despois de que por fin entenda o problema.

Instalación de dependencias no host

Ubuntu require polo menos os seguintes paquetes para construír o núcleo de Linux (asumindo unha instalación limpa):

- 'build-essential' - 'flex' - 'bison' - 'xz-utils' - 'wget' - 'ca-certificates' - 'bc' - 'linux-headers'

Podes instalalos co seguinte comando (como root ou con sudo):

apt-get -y install build-essential flex bison xz-utils wget ca-certificates bc 
                   linux-headers-$(uname -r)

Teña en conta que a execución do programa de configuración do menú do núcleo de Linux requirirá a instalación de libncurses-dev. Asegúrate de que está instalado co seguinte comando (como root ou con sudo):

apt-get -y install libncurses-dev

Descargar kernel

Decide onde descargar e despois crea o núcleo. Para esta operación, terás que asignar uns 1,3 GB de espazo no disco duro, así que asegúrate de telo.

Despois de ir a kernel.org e obtén o URL para descargar o último núcleo estable. No momento de escribir isto é: https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.1.16.tar.xz

Descarga este ficheiro usando 'wget':

wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.1.16.tar.xz

E extraeo con 'tar':

tar xJf linux-5.1.16.tar.xz

Agora entramos no directorio creado ao desempaquetar o tarball:

cd linux-5.1.16

Configuración da compilación do núcleo

O sistema de construción do núcleo é un conxunto Makefiles с moitas ferramentas e scripts personalizados para automatizar o proceso. Primeiro, abra o programa de configuración interactivo:

make ARCH=um menuconfig

Creará e amosará parcialmente unha caixa de diálogo para ti. Cando '[Select]', poderás configurar usando as teclas Espazo ou Intro. Navega pola xanela, como de costume, coas frechas do teclado "arriba" e "abaixo" e selecciona elementos - "esquerda" ou "dereita".

O punteiro de vista —> significa que está nun submenú ao que se accede premendo a tecla Intro. A saída é obviamente a través de "[Exit]'.

Inclúe as seguintes opcións en '[Select]' e asegúrate de que teñan un '[*]' ao lado:

UML-specific Options:
  - Host filesystem
Networking support (enable this to get the submenu to show up):
  - Networking options:
    - TCP/IP Networking
UML Network devices:
  - Virtual network device
  - SLiRP transport

Isto é todo, pode saír desta xanela seleccionando sucesivamente '[Exit]'. Só asegúrese de que se lle solicite gardar a configuración ao final e seleccione '[Yes]'.

Recomendo que xogue coas opcións de compilación do núcleo despois de ler esta publicación. A través destes experimentos, podes aprender moito en canto a comprender o traballo da mecánica do núcleo de baixo nivel e o impacto de varias bandeiras na súa montaxe.

Construíndo o núcleo

O núcleo de Linux é un gran programa que fai moitas cousas. Incluso cunha configuración tan mínima no hardware antigo, a construción pode levar bastante tempo. Entón, constrúe o núcleo co seguinte comando:

make ARCH=um -j$(nproc)

Para qué? Este comando indicará ao noso creador que use todos os núcleos e fíos de CPU dispoñibles no proceso de compilación. Equipo $(nproc) ao final de Build substitúe a saída do comando nproc, que forma parte coreutils nunha compilación estándar de Ubuntu.

Despois dun tempo, o noso núcleo compilarase nun ficheiro executable ./linux.

Instalación do binario

Dado que o modo de usuario en Linux crea un binario normal, podes instalalo como calquera outra utilidade. Así o fixen:

mkdir -p ~/bin
cp linux ~/bin/linux

Tamén paga a pena asegurarse de que ~/bin está no teu $PATH:

export PATH=$PATH:$HOME/bin

Configurando o sistema de ficheiros convidado

Cree un directorio para o sistema de ficheiros convidado:

mkdir -p $HOME/prefix/uml-demo
cd $HOME/prefix

Abre alpinelinux.org e en sección de descargas atopar a ligazón de descarga real MINI ROOT FILESYSTEM. No momento de escribir isto era:

http://dl-cdn.alpinelinux.org/alpine/v3.10/releases/x86_64/alpine-minirootfs-3.10.0-x86_64.tar.gz

Descarga este tarball usando wget:

wget -O alpine-rootfs.tgz http://dl-cdn.alpinelinux.org/alpine/v3.10/releases/x86_64/alpine-minirootfs-3.10.0-x86_64.tar.gz

Agora introduza o directorio do sistema de ficheiros convidado e extrae o arquivo:

cd uml-demo
tar xf ../alpine-rootfs.tgz

As accións descritas crearán un pequeno modelo de sistema de ficheiros. Debido á natureza do sistema, será moi difícil instalar paquetes a través do xestor de apk de Alpine. Pero este FS será suficiente para avaliar a idea xeral.

Tamén necesitamos unha ferramenta tini para frear o consumo de memoria procesos zombies o noso núcleo convidado.

wget -O tini https://github.com/krallin/tini/releases/download/v0.18.0/tini-static
chmod +x tini

Creando unha liña de comandos do núcleo

O núcleo de Linux, como a maioría dos outros programas, ten argumentos de liña de comandos aos que se pode acceder especificando a chave --help.

El mesmo - axuda

linux --help
User Mode Linux v5.1.16
        available at http://user-mode-linux.sourceforge.net/

--showconfig
    Prints the config file that this UML binary was generated from.

iomem=<name>,<file>
    Configure <file> as an IO memory region named <name>.

mem=<Amount of desired ram>
    This controls how much "physical" memory the kernel allocates
    for the system. The size is specified as a number followed by
    one of 'k', 'K', 'm', 'M', which have the obvious meanings.
    This is not related to the amount of memory in the host.  It can
    be more, and the excess, if it's ever used, will just be swapped out.
        Example: mem=64M

--help
    Prints this message.

debug
    this flag is not needed to run gdb on UML in skas mode

root=<file containing the root fs>
    This is actually used by the generic kernel in exactly the same
    way as in any other kernel. If you configure a number of block
    devices and want to boot off something other than ubd0, you
    would use something like:
        root=/dev/ubd5

--version
    Prints the version number of the kernel.

umid=<name>
    This is used to assign a unique identity to this UML machine and
    is used for naming the pid file and management console socket.

con[0-9]*=<channel description>
    Attach a console or serial line to a host channel.  See
    http://user-mode-linux.sourceforge.net/old/input.html for a complete
    description of this switch.

eth[0-9]+=<transport>,<options>
    Configure a network device.
    
aio=2.4
    This is used to force UML to use 2.4-style AIO even when 2.6 AIO is
    available.  2.4 AIO is a single thread that handles one request at a
    time, synchronously.  2.6 AIO is a thread which uses the 2.6 AIO
    interface to handle an arbitrary number of pending requests.  2.6 AIO
    is not available in tt mode, on 2.4 hosts, or when UML is built with
    /usr/include/linux/aio_abi.h not available.  Many distributions don't
    include aio_abi.h, so you will need to copy it from a kernel tree to
    your /usr/include/linux in order to build an AIO-capable UML

nosysemu
    Turns off syscall emulation patch for ptrace (SYSEMU).
    SYSEMU is a performance-patch introduced by Laurent Vivier. It changes
    behaviour of ptrace() and helps reduce host context switch rates.
    To make it work, you need a kernel patch for your host, too.
    See http://perso.wanadoo.fr/laurent.vivier/UML/ for further
    information.

uml_dir=<directory>
    The location to place the pid and umid files.

quiet
    Turns off information messages during boot.

hostfs=<root dir>,<flags>,...
    This is used to set hostfs parameters.  The root directory argument
    is used to confine all hostfs mounts to within the specified directory
    tree on the host.  If this isn't specified, then a user inside UML can
    mount anything on the host that's accessible to the user that's running
    it.
    The only flag currently supported is 'append', which specifies that all
    files opened by hostfs will be opened in append mode.

Este panel destaca os principais parámetros do lanzamento. Imos executar o núcleo co conxunto mínimo de opcións necesario:

linux 
  root=/dev/root 
  rootfstype=hostfs 
  rootflags=$HOME/prefix/uml-demo 
  rw 
  mem=64M 
  init=/bin/sh

As liñas anteriores din o seguinte ao noso núcleo:

Supoña que o sistema de ficheiros raíz é un pseudodispositivo /dev/root.
Escolla hostfs como controlador do sistema de ficheiros raíz.
Monta o sistema de ficheiros convidado que creamos no dispositivo raíz.
E si, en modo lectura-escritura.
Use só 64 MB de RAM (pode usar moito menos dependendo do que pensa facer, pero 64 MB parecen a cantidade óptima).
O núcleo iníciase automaticamente /bin/sh como init-proceso.

Executa este comando e deberías obter algo como o seguinte:

Unha folla máis

Core dump limits :
        soft - 0
        hard - NONE
Checking that ptrace can change system call numbers...OK
Checking syscall emulation patch for ptrace...OK
Checking advanced syscall emulation patch for ptrace...OK
Checking environment variables for a tempdir...none found
Checking if /dev/shm is on tmpfs...OK
Checking PROT_EXEC mmap in /dev/shm...OK
Adding 32137216 bytes to physical memory to account for exec-shield gap
Linux version 5.1.16 (cadey@kahless) (gcc version 7.4.0 (Ubuntu 7.4.0-1ubuntu1~18.04.1)) #30 Sun Jul 7 18:57:19 UTC 2019
Built 1 zonelists, mobility grouping on.  Total pages: 23898
Kernel command line: root=/dev/root rootflags=/home/cadey/dl/uml/alpine rootfstype=hostfs rw mem=64M init=/bin/sh
Dentry cache hash table entries: 16384 (order: 5, 131072 bytes)
Inode-cache hash table entries: 8192 (order: 4, 65536 bytes)
Memory: 59584K/96920K available (2692K kernel code, 708K rwdata, 588K rodata, 104K init, 244K bss, 37336K reserved, 0K cma-reserved)
SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=1, Nodes=1
NR_IRQS: 15
clocksource: timer: mask: 0xffffffffffffffff max_cycles: 0x1cd42e205, max_idle_ns: 881590404426 ns
Calibrating delay loop... 7479.29 BogoMIPS (lpj=37396480)
pid_max: default: 32768 minimum: 301
Mount-cache hash table entries: 512 (order: 0, 4096 bytes)
Mountpoint-cache hash table entries: 512 (order: 0, 4096 bytes)
Checking that host ptys support output SIGIO...Yes
Checking that host ptys support SIGIO on close...No, enabling workaround
devtmpfs: initialized
random: get_random_bytes called from setup_net+0x48/0x1e0 with crng_init=0
Using 2.6 host AIO
clocksource: jiffies: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 19112604462750000 ns
futex hash table entries: 256 (order: 0, 6144 bytes)
NET: Registered protocol family 16
clocksource: Switched to clocksource timer
NET: Registered protocol family 2
tcp_listen_portaddr_hash hash table entries: 256 (order: 0, 4096 bytes)
TCP established hash table entries: 1024 (order: 1, 8192 bytes)
TCP bind hash table entries: 1024 (order: 1, 8192 bytes)
TCP: Hash tables configured (established 1024 bind 1024)
UDP hash table entries: 256 (order: 1, 8192 bytes)
UDP-Lite hash table entries: 256 (order: 1, 8192 bytes)
NET: Registered protocol family 1
console [stderr0] disabled
mconsole (version 2) initialized on /home/cadey/.uml/tEwIjm/mconsole
Checking host MADV_REMOVE support...OK
workingset: timestamp_bits=62 max_order=14 bucket_order=0
Block layer SCSI generic (bsg) driver version 0.4 loaded (major 254)
io scheduler noop registered (default)
io scheduler bfq registered
loop: module loaded
NET: Registered protocol family 17
Initialized stdio console driver
Using a channel type which is configured out of UML
setup_one_line failed for device 1 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 2 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 3 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 4 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 5 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 6 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 7 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 8 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 9 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 10 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 11 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 12 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 13 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 14 : Configuration failed
Using a channel type which is configured out of UML
setup_one_line failed for device 15 : Configuration failed
Console initialized on /dev/tty0
console [tty0] enabled
console [mc-1] enabled
Failed to initialize ubd device 0 :Couldn't determine size of device's file
VFS: Mounted root (hostfs filesystem) on device 0:11.
devtmpfs: mounted
This architecture does not have kernel memory protection.
Run /bin/sh as init process
/bin/sh: can't access tty; job control turned off
random: fast init done
/ #

As manipulacións anteriores daranos sistema de invitados como mínimo, sen cousas como /proc ou nome de host asignado. Por exemplo, proba os seguintes comandos:

- uname -av - cat /proc/self/pid - hostname

Para saír do convidado, escribe exit ou prema control-d. Isto matará o shell seguido dun pánico do núcleo:

/ # exit
Kernel panic - not syncing: Attempted to kill init! exitcode=0x00000000
fish: “./linux root=/dev/root rootflag…” terminated by signal SIGABRT (Abort)

Temos este pánico do núcleo porque o núcleo de Linux pensa que o proceso de inicialización está sempre en execución. Sen el, o sistema xa non pode funcionar e falla. Pero dado que este é un proceso en modo usuario, a saída resultante envíase a SIGABRT, que dá como resultado unha saída.

Configuración da rede de convidados

E aquí é onde as cousas comezan a ir mal. A rede no modo de usuario Linux é onde todo o concepto de "modo de usuario" limitado comeza a desmoronarse. Despois de todo, normalmente a nivel do sistema, a rede é limitada privilexiados modos de execución por razóns comprensibles de todos.

Nota. por .: podes ler máis sobre as diferentes opcións para traballar cunha rede en UML aquí.

Viaxe a Slirp

Non obstante, hai unha ferramenta antiga e case non soportada chamada Slirp, co que o modo de usuario Linux pode interactuar coa rede. Funciona como unha pila TCP/IP a nivel de usuario e non require ningún permiso do sistema para executarse. Esta ferramenta foi lanzado en 1995, e a última actualización está datada 2006. Slirp é moi vello. Durante o tempo sen soporte e actualizacións, os compiladores foron tan lonxe que agora esta ferramenta só se pode describir como podredumbre do código.

Entón, descarguemos Slirp dos repositorios de Ubuntu e intentemos executalo:

sudo apt-get install slirp
/usr/bin/slirp
Slirp v1.0.17 (BETA)

Copyright (c) 1995,1996 Danny Gasparovski and others.
All rights reserved.
This program is copyrighted, free software.
Please read the file COPYRIGHT that came with the Slirp
package for the terms and conditions of the copyright.

IP address of Slirp host: 127.0.0.1
IP address of your DNS(s): 1.1.1.1, 10.77.0.7
Your address is 10.0.2.15
(or anything else you want)

Type five zeroes (0) to exit.

[autodetect SLIP/CSLIP, MTU 1500, MRU 1500, 115200 baud]

SLiRP Ready ...
fish: “/usr/bin/slirp” terminated by signal SIGSEGV (Address boundary error)

Ai deuses. Instalemos o depurador de Slirp e vexamos se podemos descubrir o que está a pasar aquí:

sudo apt-get install gdb slirp-dbgsym
gdb /usr/bin/slirp
GNU gdb (Ubuntu 8.1-0ubuntu3) 8.1.0.20180409-git
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from /usr/bin/slirp...Reading symbols from /usr/lib/debug/.build-id/c6/2e75b69581a1ad85f72ac32c0d7af913d4861f.debug...done.
done.
(gdb) run
Starting program: /usr/bin/slirp
Slirp v1.0.17 (BETA)

Copyright (c) 1995,1996 Danny Gasparovski and others.
All rights reserved.
This program is copyrighted, free software.
Please read the file COPYRIGHT that came with the Slirp
package for the terms and conditions of the copyright.

IP address of Slirp host: 127.0.0.1
IP address of your DNS(s): 1.1.1.1, 10.77.0.7
Your address is 10.0.2.15
(or anything else you want)

Type five zeroes (0) to exit.

[autodetect SLIP/CSLIP, MTU 1500, MRU 1500, 115200 baud]

SLiRP Ready ...

Program received signal SIGSEGV, Segmentation fault.
                                                    ip_slowtimo () at ip_input.c:457
457     ip_input.c: No such file or directory.

O erro latexa en nós esta liña. Vexamos o stacktrace, quizais algo nos axude alí:

(gdb) bt full
#0  ip_slowtimo () at ip_input.c:457
        fp = 0x55784a40
#1  0x000055555556a57c in main_loop () at ./main.c:980
        so = <optimized out>
        so_next = <optimized out>
        timeout = {tv_sec = 0, tv_usec = 0}
        ret = 0
        nfds = 0
        ttyp = <optimized out>
        ttyp2 = <optimized out>
        best_time = <optimized out>
        tmp_time = <optimized out>
#2  0x000055555555b116 in main (argc=1, argv=0x7fffffffdc58) at ./main.c:95
No locals.

Aquí vemos que o fallo ocorre durante o inicio do bucle principal cando slirp intenta comprobar os tempos de espera. Neste punto, tiven que renunciar a tentar depurar. Pero imos ver se Slirp construído a partir de sortes funciona. Volvín a descargar o arquivo directamente do sitio Fonteforge, porque arrastrar algo desde alí a través da liña de comandos é unha dor:

cd ~/dl
wget https://xena.greedo.xeserv.us/files/slirp-1.0.16.tar.gz
tar xf slirp-1.0.16.tar.gz
cd slirp-1.0.16/src
./configure --prefix=$HOME/prefix/slirp
make

Aquí vemos alertas sobre funcións integradas non definidas, é dicir, sobre a imposibilidade de vincular o ficheiro binario resultante. Parece que entre 2006 e este punto, gcc deixou de producir símbolos usados nas funcións integradas dos ficheiros compilados intermedios. Tentemos substituír a palabra clave inline nun comentario baleiro e mira o resultado:

vi slirp.h
:6
a
<enter>
#define inline /**/
<escape>
:wq
make

Non. Isto tampouco funciona. Aínda non se poden atopar símbolos para estas funcións.

Neste punto, deime por vencido e comecei a buscar en Github Paquetes de construción de Heroku. A miña teoría era que algún paquete de compilación de Heroku contería os binarios que necesitaba. Ao final, a busca levoume por aquí. Descargueino e desempaquetei uml.tar.gz e atopou o seguinte:

total 6136
-rwxr-xr-x 1 cadey cadey   79744 Dec 10  2017 ifconfig*
-rwxr-xr-x 1 cadey cadey     373 Dec 13  2017 init*
-rwxr-xr-x 1 cadey cadey  149688 Dec 10  2017 insmod*
-rwxr-xr-x 1 cadey cadey   66600 Dec 10  2017 route*
-rwxr-xr-x 1 cadey cadey  181056 Jun 26  2015 slirp*
-rwxr-xr-x 1 cadey cadey 5786592 Dec 15  2017 uml*
-rwxr-xr-x 1 cadey cadey     211 Dec 13  2017 uml_run*

Este é o binario slirp! El traballa?

./slirp
Slirp v1.0.17 (BETA) FULL_BOLT

Copyright (c) 1995,1996 Danny Gasparovski and others.
All rights reserved.
This program is copyrighted, free software.
Please read the file COPYRIGHT that came with the Slirp
package for the terms and conditions of the copyright.

IP address of Slirp host: 127.0.0.1
IP address of your DNS(s): 1.1.1.1, 10.77.0.7
Your address is 10.0.2.15
(or anything else you want)

Type five zeroes (0) to exit.

[autodetect SLIP/CSLIP, MTU 1500, MRU 1500]

SLiRP Ready ...

Non falla, polo que debería funcionar. Imos plantar este binario ~/bin/slirp:

cp slirp ~/bin/slirp

No caso de que o creador do paquete o elimine, eu fixo un espello.

Configuración da rede

Agora imos configurar a rede no noso núcleo convidado. Actualizar as opcións de lanzamento:

linux 
  root=/dev/root 
  rootfstype=hostfs 
  rootflags=$HOME/prefix/uml-demo 
  rw 
  mem=64M 
  eth0=slirp,,$HOME/bin/slirp 
  init=/bin/sh

Agora imos activar a rede:

mount -t proc proc proc/
mount -t sysfs sys sys/

ifconfig eth0 10.0.2.14 netmask 255.255.255.240 broadcast 10.0.2.15
route add default gw 10.0.2.2

Os dous primeiros comandos de configuración /proc и /sys necesarios para o traballo ifconfig, que configura a interface de rede para comunicarse con Slirp. Equipo route establece a táboa de enrutamento do núcleo para forzar o envío de todo o tráfico a través do túnel Slirp. Comprobamos isto cunha consulta DNS:

nslookup google.com 8.8.8.8
Server:    8.8.8.8
Address 1: 8.8.8.8 dns.google

Name:      google.com
Address 1: 172.217.12.206 lga25s63-in-f14.1e100.net
Address 2: 2607:f8b0:4006:81b::200e lga25s63-in-x0e.1e100.net

Funciona!

Nota por .: Ao parecer, a publicación orixinal foi escrita nun escritorio cunha tarxeta de rede con cable ou algunha outra configuración que non requiría controladores adicionais. Nun portátil con WiFi 8265 de Intel, prodúcese un erro ao aumentar a rede

/ # ifconfig eth0 10.0.2.14 netmask 255.255.255.240 broadcast 10.0.2.15
slirp_tramp failed - errno = 2
ifconfig: ioctl 0x8914 failed: No such file or directory
/ #

Ao parecer, o núcleo non pode comunicarse co controlador da tarxeta de rede. Un intento de compilar o firmware no núcleo, desafortunadamente, non solucionou a situación. No momento da publicación, non era posible atopar unha solución nesta configuración. En configuracións máis sinxelas (por exemplo, en Virtualbox), a interface sobe correctamente.

Imos automatizar a redirección co seguinte script de shell:

#!/bin/sh
# init.sh

mount -t proc proc proc/
mount -t sysfs sys sys/
ifconfig eth0 10.0.2.14 netmask 255.255.255.240 broadcast 10.0.2.15
route add default gw 10.0.2.2

echo "networking set up"

exec /tini /bin/sh

E márcao executable:

chmod +x init.sh

E despois faremos cambios na liña de comandos do núcleo:

linux 
  root=/dev/root 
  rootfstype=hostfs 
  rootflags=$HOME/prefix/uml-demo 
  rw 
  mem=64M 
  eth0=slirp,,$HOME/bin/slirp 
  init=/init.sh

E repetimos:

SLiRP Ready ...
networking set up
/bin/sh: can't access tty; job control turned off

nslookup google.com 8.8.8.8
Server:    8.8.8.8
Address 1: 8.8.8.8 dns.google

Name:      google.com
Address 1: 172.217.12.206 lga25s63-in-f14.1e100.net
Address 2: 2607:f8b0:4004:800::200e iad30s09-in-x0e.1e100.net

A rede é estable!

ficheiro docker

Para que che sexa máis fácil comprobar todo isto, recompilei dockerfile, que automatiza a maioría dos pasos descritos e debería darche unha configuración de traballo. Eu tamén teño núcleo preconfigurado, que ten todo o que se describe na publicación. Pero é importante entender que aquí delineei só a configuración mínima.

Espero que esta publicación che axude a comprender como crear un núcleo convidado. Resultou ser unha especie de monstro, pero a publicación foi concibida como unha guía completa sobre a construción, instalación e configuración do Modo Usuario en Linux baixo versións modernas dos sistemas operativos desta familia. Os seguintes pasos deberían incluír a instalación de servizos e outro software que xa está dentro do sistema invitado. Dado que as imaxes do contedor Docker son só tarballs publicitados, deberías poder extraer a imaxe mediante docker export, e despois determine a súa ruta de instalación na raíz do sistema de ficheiros do núcleo convidado. Ben, entón executa o script de shell.

Agradecemento especial a Rkeene de #lobsters en Freenode. Sen a súa axuda para depurar Slirp, non chegaría tan lonxe. Non teño nin idea de como o seu sistema Slackware funciona correctamente con slirp, pero os meus sistemas Ubuntu e Alpine non aceptaron slirp e o binario Rkeene suxeriume. Pero a min abonda con que polo menos algo me funcione.

Fonte: www.habr.com

Como comezar a usar o modo de usuario en Linux