Hur man börjar använda User Mode i Linux

Inledning från översättaren: Mot bakgrund av det massiva intrånget av olika typer av containrar i våra liv kan det vara intressant och användbart att veta vilka teknologier detta en gång började med. Vissa av dem kan fortfarande användas med fördel idag, men inte alla kommer folk ihåg (eller känner till, om de inte upplevde tiden för deras hastiga utveckling). En av dessa teknologier är User Mode Linux. Författaren av originalet har grävt djupt för att ta reda på vad av de gamla lösningarna som fortfarande fungerar och vad som inte gör det, och har samlat något som liknar en steg-för-steg-instruktion om hur man själv kan sätta upp en hemgjord UML 2019. Och ja, vi har bjudit in författaren av det ursprungliga inlägget till Habr. Cadey, så om ni har frågor — ställ dem på engelska i kommentarerna.

User Mode i Linux är i praktiken en portering av Linux-kärnan på sig själv. Det här läget gör det möjligt att köra en fullständig Linux-kärna som en användarprocess och används vanligtvis av utvecklare för att testa drivrutiner. Men detta läge är också användbart som ett verktyg för allmän isolering, vars princip liknar att använda virtuella maskiner. Detta läge ger större isolering än Docker, men mindre än en fullständig virtuell maskin som KVM eller Virtual Box.

Överlag kan User Mode verka som ett konstigt och svårt verktyg att använda, men det har ändå sina tillämpningsområden. Det är trots allt en fullständig Linux-kärna som körs av en icke-privilegerad användare. Denna egenskap gör det möjligt att köra potentiellt osäkert kod utan några hot mot värdmaskinen. Och eftersom det är en fullständig kärna, är dess processer avskilda från värdmaskinen, vilket innebär att processer som körs inom User Mode inte kommer att vara synliga för värden.Detta liknar inte en vanlig Docker-container, där värdmaskinen alltid kan se processerna inne i lagringsutrymmet. Titta på detta stycke pstree från en av mina servrar:

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}]

Och jämför detta med pstree i Linux-kärnan i användarläge:

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

När jag arbetar med Docker-containrar kan jag se processnamnen som körs i gästsystemet från värden. Med Linux användarläge är detta inte möjligt. Vad betyder detta? Det betyder att övervakningsverktyg som arbetar genom Linuxs revisionssystem inte ser processer som körs i gästsystemet. Men i vissa situationer kan denna funktion bli en tveeggat svärd.

Hela inlägget nedan är en uppsättning av forskningar och grova försök att åstadkomma önskat resultat. För detta har jag tvingats använda olika gamla verktyg, läsa källkoden till kärnan, ägna mig åt intensiv felsökning av kod som skrivits under en tid när jag fortfarande gick i grundskolan, samt gräva i Heroku-uppsättningar med hjälp av ett speciellt binärprogram för att hitta de verktyg jag behövde. allt detta arbete ledde till att killarna i min IRC började kalla mig för magikern. Jag hoppas att detta inlägg kan fungera som en tillförlitlig dokumentation för någon som vill göra exakt samma sak, men med nyare kärnor och versioner av operativsystem.

Inställning

Inställning av Linux användarläge sker i flera steg:

• installation av beroenden på värden;
• nedladdning av Linux-kärnan;
• konfigurera kärnbygget;
• bygga kärnan;
• installera binärfilen;
• konfigurera gästfilsystemet;
• välja startparametrar för kärnan;
• konfigurera gästnätverket;
• starta gästkärnan.

Jag antar att om du beslutar dig för att göra allt detta själv, så kommer du högst troligt att göra det i något Ubuntu- eller Debian-liknande system. Jag försökte implementera allt ovan i min favoritdistribution – Alpine, men det blev inget av, uppenbarligen på grund av att Linux-kärnan har en strikt koppling till glibc-isms för drivrutiner i användarläge. Jag planerar att rapportera detta till upstream efter att jag har förstått problemet helt.

Installation av beroenden på värden

Ubuntu kräver minst följande paket för att bygga Linux-kärnan (förutsatt en ren installation):

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

Du kan installera dem med följande kommando (med root-rättigheter eller med sudo):

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

Observera att körningen av inställningsprogrammet för Linux-kärnan kommer att kräva installation av libncurses-dev. Vänligen se till att det är installerat med följande kommando (med root-rättigheter eller med sudo):

apt-get -y install libncurses-dev

Nedladdning av kärnan

Bestäm en plats för nedladdning och efterföljande byggnation av kärnan. För denna operation behöver du avsätta cirka 1,3 GB utrymme på hårddisken, så se till att du har det.

Efter det, gå till kernel.org och erhåll URL:en för att ladda ner den senaste stabila versionen av kärnan. Vid tidpunkten för skrivandet av detta inlägg, är det: https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.1.16.tar.xz

Ladda ner denna fil med 'wget':

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

Och extrahera den med 'tar':

tar xJf linux-5.1.16.tar.xz

Nu går vi in i katalogen som skapades vid uppackningen av tarball:

cd linux-5.1.16

Konfigurering av kärnbyggnation

Byggsystemet för kärnan är en uppsättning Make-filer med med många användarverktyg och skript för att automatisera processen. Börja med att öppna det interaktiva konfigurationsprogrammet:

make ARCH=um menuconfig

Det kommer delvis att genomföra byggprocessen och visa dig en dialogruta. När det i botten av fönstret visas ‘[Select]‘, kan du börja konfigurera med hjälp av mellanslagstangent eller Enter. Navigering i fönstret görs som vanligt med piltangenterna ‘upp’ och ‘ner’, och val av element med ‘vänster’ eller ‘höger’.

En indikator av typen –> innebär att du är i en undermeny, som du går in i med Enter-tangenten. Utgång från den, uppenbarligen, genom ‘[Exit]‘.

Aktivera följande alternativ i ‘[Select]‘ och se till att det finns en symbol ‘[*]’ bredvid dem:

UML-specifika alternativ:
  - Värdfilssystem
Nätverksstöd (aktivera detta för att få undermenyn att visas):
  - Nätverksalternativ:
    - TCP/IP-nätverk
UML-nätverksenheter:
  - Virtuell nätverksenhet
  - SLiRP-transport

Allt, detta fönster kan lämnas genom att välja ‘[Exit]‘. Se bara till att du erbjuds att spara konfigurationen i slutet och väljer ‘[Ja]‘.

Jag rekommenderar att du leker med kärnkonfigurationsalternativen efter att ha läst detta inlägg. Genom dessa experiment kan du lära dig mycket om hur lågnivåmekanikerna i kärnan fungerar och hur olika flaggor påverkar dess kompilering.

Kompilering av kärna

Linux-kärnan är ett stort program som sysslar med många saker. Även med en så minimal konfiguration kan kompileringen ta ganska lång tid på gammal utrustning. Så här kompilera du kärnan med följande kommando:

make ARCH=um -j$(nproc)

Varför? Detta kommando säger till vår kompilator att använda alla tillgängliga kärnor och trådar i processen. Kommandot $(nproc) i slutet av Byggd sätter in utdata från kommandot nproc, som är en del av coreutils i den standardmässiga Ubuntu-konfigurationen.

Efter en stund kommer vår kärna att kompilera till en körbar fil ./linux.

Installation av binärfilen

Eftersom User Mode i Linux skapar en vanlig binärfil kan du installera den som vilken annan verktyg som helst. Så här gjorde jag:

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

Det är också värt att se till att ~/bin finns i din $PATH:

export PATH=$PATH:$HOME/bin

Konfigurera gästfilssystemet

Skapa en katalog för gästfilssystemet:

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

Öppna alpinelinux.org och i nedladdningsavsnittet hitta den aktuella nedladdningslänken MINI ROOT FILESYSTEM. Vid tidpunkten för detta inlägg var det:

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

Ladda ner denna tarball med 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

Gå nu in i gästfilssystemets katalog och packa upp arkivet:

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

De beskrivna åtgärderna kommer att skapa en liten mall av filsystemet. På grund av systemets egenskaper kan det vara mycket svårt att installera paket via apks hanterare. Men detta filsystem kommer att vara tillräckligt för att förstå den övergripande idén.

Vi kommer också att behöva verktyget tini för att förhindra minnesanvändning av zombieprocesser i vårt gästkärna.

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

Skapa kärnkommandoraden

I Linux-kärnan, liksom i de flesta andra program, finns det kommandoradsargument som kan ses genom att ange nyckeln --help.

Själv —help

linux --help
User Mode Linux v5.1.16
        finns tillgänglig på http://user-mode-linux.sourceforge.net/

--showconfig
    Skriver ut konfigurationsfilen som denna UML-binär skapades från.

iomem=,
    Konfigurera  som en IO-minnesregion namngiven .

mem=
    Detta kontrollerar hur mycket "fysisk" minne kärnan allokerar
    för systemet. Storleken anges som ett nummer följt av
    en av 'k', 'K', 'm', 'M', som har de uppenbara betydelserna.
    Detta är inte relaterat till mängden minne i värden. Det kan
    vara mer, och överskotten, om de någonsin används, kommer bara att bli swapade.
        Exempel: mem=64M

--help
    Skriver ut detta meddelande.

debug
    denna flagga behövs inte för att köra gdb på UML i skas-läge

root=
    Detta används faktiskt av den generiska kärnan på exakt samma
    sätt som i någon annan kärna. Om du konfigurerar ett antal block
    enheter och vill starta från något annat än ubd0, skulle du
    använda något som:
        root=/dev/ubd5

--version
    Skriver ut versionsnumret av kärnan.

umid=
    Detta används för att tilldela en unik identitet till denna UML-maskin och
    används för att namnge pid-filen och hanteringskonsolens socket.

con[0-9]*=
    Koppla en konsol eller seriell linje till en värdkanal. Se
    http://user-mode-linux.sourceforge.net/old/input.html för en fullständig
    beskrivning av denna switch.

eth[0-9]+=,
    Konfigurera en nätverksenhet.
    
aio=2.4
    Detta används för att tvinga UML att använda 2.4-stil AIO även när 2.6 AIO är
    tillgänglig. 2.4 AIO är en enda tråd som hanterar en förfrågan i
    taget, synkront. 2.6 AIO är en tråd som använder 2.6 AIO
    gränssnittet för att hantera ett godtyckligt antal utestående förfrågningar. 2.6 AIO
    är inte tillgänglig i tt-läge, på 2.4-värdar eller när UML är byggd med
    /usr/include/linux/aio_abi.h inte tillgänglig. Många distributioner inkluderar inte
    aio_abi.h, så du behöver kopiera den från en kärnträ till
    din /usr/include/linux för att bygga en AIO-kapabel UML.

nosysemu
    Stänger av syscall-emuleringspatchen för ptrace (SYSEMU).
    SYSEMU är en prestandapatch som introducerades av Laurent Vivier. Den ändrar
    beteendet hos ptrace() och hjälper till att minska värdkontextväxlingshastigheter.
    För att få det att fungera behöver du också en kärnpatch för din värd.
    Se http://perso.wanadoo.fr/laurent.vivier/UML/ för mer information.

uml_dir=
    Platsen för att placera pid- och umid-filerna.

quiet
    Stänger av informationsmeddelanden under uppstart.

hostfs=,,...
    Detta används för att ställa in hostfs-parametrar. Rotkatalogargumentet
    används för att begränsa alla hostfs-mounts till den specificerade katalog
    trädet på värden. Om detta inte anges, kan en användare inuti UML
    montera vad som helst på värden som är åtkomligt för användaren som kör
    den. Den enda flagga som för närvarande stöds är 'append', vilket anger att alla
    filer som öppnas av hostfs kommer att öppnas i append-läge.

Detta banner belyser de grundläggande startparametrarna. Låt oss starta kärnan med den minimi nödvändiga uppsättningen av alternativ:

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

Raderna ovan anger för vår kärna följande:

• Anta att rotfilsystemet är en pseudoadapter. /dev/root.
• Välj hostfs som en drivrutin för rotfilssystemet.
• Montera gästfilssystemet som vi skapade på rot-enheten.
• Och ja, i läs-och-skriv-läge.
• Använd endast 64 megabyte RAM (du kan använda mycket mindre, beroende på vad du planerar att göra, men 64 MB verkar vara en optimal mängd).
• Kärnan startar automatiskt /bin/sh som init-process.

Kör detta kommando, och du bör få något i stil med följande:

En till sträcka

Kärnedumpgränser :
        mjuk - 0
        hård - INGEN
Kontrollerar att ptrace kan ändra systemanropsnummer...OK
Kontrollerar systemanropsemuleringspatch för ptrace...OK
Kontrollerar avancerad systemanropsemuleringspatch för ptrace...OK
Kontrollerar miljövariabler för en tempdir...inga funna
Kontrollerar om /dev/shm är på tmpfs...OK
Kontrollerar PROT_EXEC mmap i /dev/shm...OK
Lägger till 32137216 byte till fysisk minne för att ta hänsyn till exec-shield-gap
Linux-version 5.1.16 (cadey@kahless) (gcc-version 7.4.0 (Ubuntu 7.4.0-1ubuntu1~18.04.1)) #30 Sön 7 Jul 18:57:19 UTC 2019
Byggde 1 zonlistor, mobilitetsgruppering på.  Totalt sidor: 23898
Kärnkommandorad: root=/dev/root rootflags=/home/cadey/dl/uml/alpine rootfstype=hostfs rw mem=64M init=/bin/sh
Dentry-cache hash-tabellposter: 16384 (ordning: 5, 131072 byte)
Inode-cache hash-tabellposter: 8192 (ordning: 4, 65536 byte)
Minnes: 59584K/96920K tillgängligt (2692K kärnkod, 708K rwdata, 588K rodata, 104K init, 244K bss, 37336K reserverat, 0K cma-reserverat)
SLUB: HWalign=64, Ordning=0-3, MinObjects=0, CPUer=1, Noder=1
NR_IRQS: 15
klockkälla: timer: mask: 0xffffffffffffffff max_cycles: 0x1cd42e205, max_idle_ns: 881590404426 ns
Kalibrerar fördröjningsloop... 7479.29 BogoMIPS (lpj=37396480)
pid_max: standard: 32768 minimum: 301
Monteringscache hash-tabellposter: 512 (ordning: 0, 4096 byte)
Montagepunkt-cache hash-tabellposter: 512 (ordning: 0, 4096 byte)
Kontrollerar att värdena för värdena ptys stödjer utdata SIGIO...Ja
Kontrollerar att värdena för värdena ptys stödjer SIGIO vid stängning...Nej, aktiverar workaround
devtmpfs: initierad
slumrande: get_random_bytes anropades från setup_net+0x48/0x1e0 med crng_init=0
Använder 2.6 värd AIO
klockkälla: jiffies: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 19112604462750000 ns
futex hash-tabellposter: 256 (ordning: 0, 6144 byte)
NET: Registrerade protokollfamilj 16
klockkälla: Växlat till klockkälla timer
NET: Registrerade protokollfamilj 2
tcp_listen_portaddr_hash hash-tabellposter: 256 (ordning: 0, 4096 byte)
TCP etablerad hash-tabellposter: 1024 (ordning: 1, 8192 byte)
TCP bind hash-tabellposter: 1024 (ordning: 1, 8192 byte)
TCP: Hash-tabeller konfigurerade (etablerad 1024 bind 1024)
UDP hash-tabellposter: 256 (ordning: 1, 8192 byte)
UDP-Lite hash-tabellposter: 256 (ordning: 1, 8192 byte)
NET: Registrerade protokollfamilj 1
konsol [stderr0] inaktiverad
mconsole (version 2) initierad på /home/cadey/.uml/tEwIjm/mconsole
Kontrollerar stöd för host MADV_REMOVE...OK
workingset: timestamp_bits=62 max_order=14 bucket_order=0
Blocklager SCSI generell (bsg) drivrutin version 0.4 laddad (major 254)
io schemaläggare noop registrerad (standard)
io schemaläggare bfq registrerad
loop: modul laddad
NET: Registrerade protokollfamilj 17
Initierad stdio konsol drivrutin
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 1 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 2 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 3 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 4 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 5 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 6 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 7 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 8 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 9 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 10 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 11 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 12 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 13 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 14 : Konfiguration misslyckades
Använder en kanaltyp som är konfigurerad utanför UML
setup_one_line misslyckades för enhet 15 : Konfiguration misslyckades
Konsolen initierad på /dev/tty0
konsol [tty0] aktiverad
konsol [mc-1] aktiverad
Misslyckades med att initiera ubd-enhet 0 : Kunde inte bestämma storleken på enhetens fil
VFS: Monterade rot (hostfs-filsystem) på enhet 0:11.
devtmpfs: monterad
Denna arkitektur har ingen kärnminnesskydd.
Kör /bin/sh som init-process
/bin/sh: kan inte komma åt tty; jobbkontroll avstängd
slumrande: snabb init klart
/ # 

Manipulationerna ovan ger oss ett minimalt gästsystem, utan sådana saker som /proc eller tilldelat värdnamn. Som exempel, prova att köra följande kommandon:

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

För att lämna gästsystemet, skriv exit eller tryck control-d. Detta kommer att avsluta skalet med en följande kernel panic:

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

Vi fick denna kernel panic eftersom Linux-kärnan anser att initieringsprocessen alltid körs. Utan den kan systemet inte fungera längre och stänger ner. Men eftersom detta är en process i användarläge, skickar den erhållna resultaten tillbaka till SIGABRT, vilket resulterar i utgång.

Konfigurera gästnätverket

Det är här saker börjar gå snett. Nätverket i User Mode Linux är den plats där hela konceptet av det begränsade 'användarläget' börjar falla isär. Vanligtvis är nätverket på systemnivå begränsat av privilegierade exekveringslägen av alla kända skäl.

Not. anm.: mer om olika sätt att arbeta med nätverket i UML går att läsa här.

En resa in i slirp

Det finns dock ett gammalt och praktiskt taget ounderstödd verktyg som kallas Slirp, med vilket User Mode Linux kan interagera med nätverket. Det fungerar ungefär som ett TCP/IP-stack på användarnivå och kräver inga systembehörigheter för att köra. Det här verktyget släpptes 1995, och den senaste uppdateringen är från 2006.Slirp är väldigt gammal. Under tiden utan stöd och uppdateringar har kompilatorer kommit så långt att detta verktyg nu bara kan karaktäriseras som ‘code rot’.

Så låt oss installera Slirp från Ubuntu-repositorierna och försöka köra det:

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

Copyright (c) 1995, 1996 Danny Gasparovski och andra.
Alla rättigheter förbehållna.
Detta program är copyrightat, fri programvara.
Vänligen läs filen COPYRIGHT som medföljde Slirp
paketet för villkoren och förutsättningarna för upphovsrätten.

IP-adress för Slirp-värden: 127.0.0.1
IP-adressen för dina DNS:er: 1.1.1.1, 10.77.0.7
Din adress är 10.0.2.15
(eller vad som helst annat du vill)

Skriv fem nollor (0) för att avsluta.

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

SLiRP Ready ...
fisk: “/usr/bin/slirp” avslutat av signal SIGSEGV (Adressgränsfel)

Åh, herregud. Låt oss installera en debugger för Slirp och se om vi kan förstå vad som händer:

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 
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:
.
Find the GDB manual and other documentation resources online at:
.
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.

Felet finns i den här raden. Låt oss titta på stacktrace, kanske kan det hjälpa oss:

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

Här ser vi att felet inträffar när den huvudsakliga loopen startas, när slirp försöker kontrollera timeouts. Vid den punkten borde jag ha gett upp med felsökningen. Men låt oss se om Slirp, som byggdes från källkoden, fungerar. Jag laddade ner arkivet direkt från webbplatsen Sourceforge, eftersom det är besvärligt att hämta något därifrån via kommandoraden:

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

Här ser vi varningar om odefinierade inbyggda funktioner, vilket betyder att det inte går att länka den resulterande binära filen. Det verkar som om gcc slutade generera symboler som används i inbyggda funktioner för mellan-kompilerade filer mellan 2006 och nu. Låt oss försöka byta ut nyckelordet inline mot en tom kommentar och se resultatet:

vi slirp.h
:6
a

#define inline /**/

:wq
make

Nej. Det fungerar inte heller. Jag kan fortfarande inte hitta tecknen för dessa funktioner.

Vid det här laget gav jag upp och började söka på Github. byggpaket för Heroku.. Min teori var att det skulle finnas nödvändiga binärfiler i något byggpaket för Heroku. Till slut ledde sökandet mig hit.. Jag laddade ner och packade upp uml.tar.gz. och hittade följande:

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*

Detta är binärfilen slirp! Men fungerar den?

.\/slirp
Slirp v1.0.17 (BETA) FULL_BOLT

Copyright (c) 1995,1996 Danny Gasparovski och andra.
Alla rättigheter förbehållna.
Detta program är upphovsrättsskyddat, gratis programvara.
Vänligen läs filen COPYRIGHT som följde med Slirp
paketet för villkor och bestämmelser för upphovsrätten.

IP-adress för Slirp-värden: 127.0.0.1
IP-adress för dina DNS: 1.1.1.1, 10.77.0.7
Din adress är 10.0.2.15
(eller något annat du vill)

Skriv fem nollor (0) för att avsluta.

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

SLiRP Klar ...

Den kraschar inte — så det borde fungera! Låt oss lägga in denna binär i ~\/bin\/slirp.:

cp slirp ~\/bin\/slirp.

För att skydda mig om paketets skapare tar bort det, har jag gjort en spegel..

Nätverksinställning.

Nu ska vi konfigurera nätverket på vår gästkärna. Vi uppdaterar startparametrarna.:

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

Nu låt oss aktivera nätverket:

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.

De första två konfigurationskommandona /proc och /sys är nödvändiga för att fungera. ifconfig, vilket upprättar nätverksgränssnittet för kommunikation med Slirp. Kommandot route upprättar kärnans routingtabell för att dirigera all trafik genom tunneln Slirp. Låt oss testa detta med en DNS-förfrågan:

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

Det fungerar!

Obs. Enligt vad som verkar ha skrivits, den ursprungliga posten, på en stationär dator med en trådbunden nätverksadapter, eller någon annan konfiguration som inte kräver extra drivrutiner. En bärbar dator med WiFi 8265 från Intel ger dock ett fel när nätverket aktiveras.

/ # 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
/ #

Det verkar som om kärnan inte kan ansluta till nätverksdrivrutinen. Tyvärr rättade ett försök att kompilera firmware till kärnan inte situationen. Vid tidpunkten för publiceringen har en lösning ännu inte kunnat hittas i denna konfiguration. I enklare konfigurationer (t.ex. i Virtualbox) startar gränssnittet korrekt.

Låt oss automatisera omdirigeringen med hjälp av följande shell-skript:

#!/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

Och låt oss markera det som exekverbart:

chmod +x init.sh

Och sedan gör vi ändringar i kommandoraden för kärnan:

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

Och vi upprepar:

SLiRP Ready ...
nätverket är upprättat
\/bin\/sh: kan inte få åtkomst till tty; jobbkontroll avstängd

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

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

Nätverket fungerar stabilt!

Docker-fil

För att göra det lättare för dig att kontrollera allt detta har jag samlat Dockerfile, som automatiserar de flesta av de beskrivna stegen och bör ge dig en fungerande konfiguration. Jag har även en färdig kärnkonfiguration, som innehåller allt som beskrivs i inlägget. Men det är viktigt att förstå att jag här har redogjort för endast den minimiella inställningen.

Jag hoppas att detta inlägg har hjälpt dig att förstå hur man startar en gästkärna. Det blev någon slags monster, men syftet med publiceringen var att fungera som en omfattande guide om byggande, installation och konfiguration av User Mode i Linux för moderna versioner av operativsystem i denna familj. Efterföljande åtgärder bör inkludera installation av tjänster och annan programvara redan inuti gästsystmet. Eftersom Docker-containerbilder bara är extraherade tar-arkiv, borde du kunna extrahera bilden genom docker export, och sedan ange installationsvägen i rotkatalogen för gästkärnan. Så, utför shell-skriptet.

Ett stort tack till Rkeene med #lobsters på Freenode. Utan hans hjälp med att felsöka Slirp skulle jag inte ha kommit så här långt. Jag har ingen aning om hur hans Slackware-system fungerar korrekt med slirp, men mina Ubuntu- och Alpine-system accepterade inte slirp och den Rkeene-binary som föreslogs för mig. Men det är tillräckligt för mig att något fungerar.

Källa: habr.com