garoedaok, i'll translate this one too
garoedafernand0: hallo, onze volgende spreker is Ismael Briones
garoedahij werkt als system administrator bij een een grote krant in Spanje
garoedahij is lid van UniNEt en draagt bij tot het succes van
garoedade organisatie van deze conferentie
garoedazijn spreekbeurt gaat over User Mode LInux
garoedaismak:
garoedahallo,
garoedagoedenavond iedereen
garoedaok, dit is een introductie tot User Mode Linux
garoedahet is een mix van de documentatie van het project
garoedadie je kan vinden op de webpagina van het project (http:/user-mode-linux.sourceforge.net).
garoedaik ga uitleggen wat UML is en enkele beschrijvingen van hoe mensen
garoedaUser-Mode-Linux gebruiken en hoe je het installeert
garoedaten eerste : wat is UML?
garoeda1.1 draai Linux in een Linux systeem
garoedawe kunnen een kort beschrijving van wat UML is lezen op de website van het project (http://user-mode-linux.sourceforge.net):
garoeda"User-Mode Linux is een veilige en secure manier om Linux versies te draaien in een andere Linux. Het geeft je een virtuele machine die meer hardware en software (virtuele) resources kan hebben den je eigenlijk fysieke computer
garoedadisk opslag van je virtuele machine zit volledig in één enkele file op je fysieke machine. je kan de virtuele machine enkel toegang geven tot de hardware die je zelf wil of die toegang beperken. Wat je doet met de virtuele machine kan je echte computer niet beschadigen noch de software erop
garoedadit lijkt wel heel tof, we kunnen Linux draaien onder Linux en we kunnen doen
garoedawat we willen omdat het gelijk een ander systeem is. UML laat je toe om een Linux kernel als een
garoedauser process te draaien onder een normale Linux kernel
garoedaEigenlijk is uml een port van de linux kernel naar de linux system call interface ipv naar de hardware interface. Wat betekent dit nu?
garoedahet behandelt Linux als een platform naar waar men de kernel kan porten, die platforms zijn bv Intel, Alpha, Mips etc..
garoedaalle devices toegankelijk onder de virtuele machine zijn virtueel en UML ondertsteunt het volledige gamma van devices  van een Linux machine, zoals
garoedaconsole en serial lines
garoedablock devices
garoedanetwerk devices
garoedanormaal gezien praat de Linux Kernel rechtstreeks met de hardware (netwerkkaart, videokaart, geluidskaart) en elke programma dat in het systeem draait vraagt de kernel toelating om met de hardware te werken
garoeda+-----------+-----------+----+
ismak   | Process 1 | Process 2 | ...|
ismak  +-----------+-----------+----+
ismak   |        Linux Kernel         |
ismak  +------------------------------+
ismak   |        Hardware            |
ismak  +------------------------------+
garoedade UML kernel communiceert niet met de hardware maar spreekt met de 'echte' Linux kernel (de kernel van het systeem waar we onze UML op draaien) zoals eender welk ander programma, Dit betekent dat programma's kunnen draaien in UML alsof ze in een normale kernel draaien als volgt:
garoeda+-----------------+
ismak          | Process 2 | ...|
ismak  +-----------+--------------------+
ismak   |Process 1 | User-Mode Linux |
ismak  +---------------------------------+
ismak   |      Linux Kernel              |
ismak  +---------------------------------+
ismak   |        Hardware               |
ismak  +---------------------------------+
ismak
ismak
ismak
garoedaenige voordelen van UML zijn:
garoeda- als de user mode linux crasht, gaat het systeem dat de umlgaat hiervan geen hinder ondervinden
garoedade user mode linux kan als non-root user draaien
garoedauml draait zoals een ander proces dus je kan het debuggen
garoedaje kan het gebruiken om nieuwe applicaties te testen, nieuwer kernels, nieuwe distributies (verschillende distributes tegelijkertijd draaien)
garoedaII waarvoor gebruiken mensen het?
garoedavirtual hosting
garoedawe kunnen uml gebruiken voor virtuele hosting. UML geeft ons een compleet Linux systeem dus we kunnen alles draaien wat we op de host pc kunnen draaien
garoedaeen voorbeeld hiervan is usermodelinux.org, beheerd door David Coulson, hij draait een user mode linux systeem
garoedaKernel ontwikkeling en debugging
garoedahet is een goede manier om kernels te debuggen, als ons UML systeem crasht gaat het basissysteem nog altijd probleemloos werken, er gaat geen beschadiging zijn
garoedawe kunnen debuggers gebruiken zoals gdb, gprof en gcov. de ontwikkeling van drivers is efficienter daar we de machine niet moeten reboten, wat de ontwikkeltijd lager maakt
garoedaprocess debugging
garoedaUML kan gebruikt worden um user-level prcoessen te debuggen, als we een proces willen debuggen starten we UML, zetten een breakpoint op de system call en draaien het programma
garoedaspelen met de laatste kernels
garoedawe kunnen UML gebruiken om de laatste kernel te testen, als die kernel bugs zou hebben zoals data corruptie ofzo kan het geen belangrijke data buiten het UML systeem beschadigen
garoedanieuwe distributies testen
garoedahet bestandssysteem van UML is compleet bevat in een enkele file, we hebben dus geen volledige disk partitie hiervoor nodig
garoedawe kunnen een aantal kant en klare root bestandssystemen vinden op de webpagina van UML (http://sourceforge.net/project/showfiles.php?group_id=429) of we kunnen ons eigen bestandssysteem van scratch maken, later gaan we een voorbeeld zien met de Debian distributie
garoedaOpvoeding
garoedahet is handiger voor de student daar die geen speciale machine nodig heeft om OS ontwikkeling te leren, netwerk administratie en meer algemene systeem administratie
garoedaexperimentele ontwikkeling
garoedaonze virtuele machine kan met meer devices draaien dan onze fysieke hardware, dus we kunnen een virtueel systeem hebben met meerr geheugen, mode devices en meer processoren
garoedawe kunnen hardware testen en verder ontwikkelen zonder de eigenlijke hardware te hebben
garoedaOnderzoeken van draaiende systemen
garoedawe Hebben een compleet OS draaiende buiten de UML, we kunnen dit gebruiken om 'in' de kernel van de UML te kijken wat bij een ander systeem niet mogelijk is
garoedaals 'zandbak' of 'gevangenis'
garoedaprocessen die draaien in de UML hebben geen toegang tot het fysieke systeem, bijgevolg kunnen kwaadaardige programma's in de UML ons echte systeem niet beschadigen
garoedaVirtual networking
garoedawe kunnen het netwerk gebruiken vanuit een draaiende UML, we kunnen een virtueel netwerk opzetten en experimentele diensten testen. Later zal ik uitleggen hoe we uml met netwerkondersteuning kunne instellen
garoedaals een testomgeving
garoedahet testen van sommige software vereist het reboten vande machine , met uml kunnen we dit tijdverlies vermijden. we kunnen het testen automatiseren. Er is een kleine perl module die een UML object implementeert die de mogelijkheid biedt een virtuele machine te booten, erop in te loggen, commando's te draaien en het af te sluiten. Je kan het vinden op de download pagina
garoedahttp://sourceforge.net/project/showfiles.php?group_id=429)
garoedaherstellen na rampen
garoedaals je wil weten wat er gebeurdt wanneer je rm -rf / typt, of je wil systeemherstel oefenen kan je uml gebruiken als een testsysteem, het kan leuk zijn :-)
garoedaeen LInux omgeving voor andere operating systems
garoedaUML draait momenteel enkel op Linux, maar er zijn projecten om uml te porten naar andere OS's zodat we een gehele Linux omgeving kunnen draaien in een ander OS
garoedanu we weten wat user mode linux is en hoe we het kunnen gebruiken ga ik enkele practische voorbeelden geven van uml in de praktijk
garoedamet name: hoe installeer ik vanaf nul een uml gebaseerd op debian
garoedaeen practisch voorbeeld:
garoedawe hebben een UML kernel en een root bestandssysteem nodig om het te boten. we kunnen de kernel installeren vanaf een .rpm of .deb package of een bestaande kernel patchen en onze UML kernel zelf compileren
garoedade .rpm en .deb bestanden bevatten trouwens ook een aantal userspace tools, kernel modules en documentatie
garoedainstalleren van source
garoedaals je UML vanaf source wil compileren moet je een patch downloaden en toepassen op de geschikte Linux kernel
garoedacd linux-2.4.19
garoedapatch -p1 < uml-patch-2.4.19-37
garoedahet compileren van de user mode kernel is hetzelfde als de compilatie van een andere kernel. dit doen we als volgt
garoedana het patchen moeten we de kernel compileren
garoedamake menuconfig ARCH=um (you can use make xconfig and make config)
garoedade default kernel configuratie werkt goed dus je hoeft die niet te veranderen. als je iets veranderdt zal er waarschijnlijk geen enkel probleem optreden. nu moeten we de kernel compileren
garoedamake linux ARCH=um
garoedana het compileren heb je een user mode kernel, genaamd linux, in de top directory van je source tree
garoedanu gaan we de kernel modules compileren en installeeren. we compileren de modules  op dezelfde manier als een gewone kernel met uitzondering van 'ARCH=um': optie
garoedamake modules ARCH=um
garoedaje kan ze installeren via ftp, uploaden naar onze UML of we kunnen ons root bestandssyteem mounten en ze in de goede directory plaatsen
garoedamount root_fs_file mount_point -o loop
garoedamake modules_install INSTALL_MOD_PATH=`pwd`/mnt ARCH=um
garoedaumount mnt
garoedadit gaat het kernel build proces gebruiken en de modules installeren in ons uml root bestandssysteem
garoedaals we de uml tools willen gebruiken moeten we de source afhalen en ze compileren
garoedaDebian installatie
garoedaOk, nu ga ik uitleggen hoe je op een gemakkelijke wijze een draaiende uml kan verkrijgen, met debian natuurlijk ;-)
garoedaten eerste, de woody versie van debian heeft de volgende uml packages
garoedauser-mode-linux
garoedauser-mode-linux-doc
garoedauml-utilities
garoedawe moeten het user-mode-linux package installeren
garoedaapt-get install user-mode-linux (het uml-utilities package wordt automatisch geinstalleerd door dependencies)
garoedadd if=/dev/zero of=root_fs_woody bs=1M count=100
garoedahiermee maken we een file van 100M groot, we kunnen de grootte instellen naar eigen keuze
garoedadit bestand kan een ext2 bestandssysteem hebben, we gebruiken mke2fs om het ext2 bestandssysteem te maken
garoedasbin/mke2fs -Fq root_fs_woody
garoedaok, nu hebben we ons root bestandssysteem, nu gaan we het mounten en onze bestandssysteem structuur maken
garoeda> mkdir /mnt/uml
garoedamount  root_fs_woody /mnt/uml -o loop
garoedawe halen het basis systeem package  af dat bij onze Debian versie hoort (ik gebruik de laatste versie: woody)
garoedawget ftp://ftp.debian.org/debian/dists/woody/main/disks-i386/base-images-current/basedebs.tar
garoedawe installeren het basis systeem in ons bestand:
garoedadebootstrap --unpack-tarball /PATH/basedebs.tar woody /mnt/uml/
garoedaah, een vraag
garoedavraag: can je geen partitie gebruiken als root bestandsysteem voor UML
garoedanee, de disk opslag van UML is een bestand
garoedaof meerdere bestanden als je meerderer harde schijven wil proberen
garoeda(vervang proberen door simuleren)
garoedanu moeten we enkele files van ons uml systeem configureren
garoedacd /mnt/debinst
garoedavi etc/fstab
garoeda# /etc/fstab: static file system information.
garoeda#
garoeda# file system    mount point   type    options                  dump pass
garoeda# /dev/ubd0        /             ext2    defaults                 0    0
garoedaproc             /proc         proc    defaults                 0    0
garoedaanother file:
garoedavi etc/inittab
garoedawe zeten bovenstande lijnen in commentaar zodat enkel een xtterm gestart wordt wanneer het systeem boot
ismak1:2345:respawn:/sbin/getty 38400 tty1
ismak#2:23:respawn:/sbin/getty 38400 tty2
ismak#3:23:respawn:/sbin/getty 38400 tty3
ismak#4:23:respawn:/sbin/getty 38400 tty4
ismak#5:23:respawn:/sbin/getty 38400 tty5
ismak#6:23:respawn:/sbin/getty 38400 tty6
ismak
garoedawe maken een lege source lijst
garoedatouch etc/apt/sources.list
garoedaOk, nu kunnen we onze uml kernel starten
garoedalinux ubd0=root_fs_woody devfs=nomount rw
garoedaals we cdrom ondersteuning willen:
garoedalinux ubd0=root_fs_woody ubd2r=/dev/cdrom devfs=nomount rw
garoedaHet laatste onderdeel van deze conferentie is de networking support
garoedaUser Mode Linux Networking
garoedawe hebben de TUN./TAP device module nodig dus we moeten de kernel (niet de uml kernel) recompilen met ondersteuning voor deze module
garoedawanneer we het hte TUN/TAP device als moudule hebben kunnen we het in kernel inserten
garoedainsmod tun
sarnold [sarnold@~65.102.14.138] is now known as sarMTG
garoedawe maken de TUN/TAP interface
garoedatunctl -u uiduser
garoedawaarbij uiduser het uid is van de user die de uml draait
garoedade gebruiker die het TUN/TAP device gaat gebruiken
garoedawe configureren de interface
garoedaifconfig tap0 ip_system netmask netmask_system broadcast broadcast_system
garoedawaarbij ip_system, netmast_system en broadcast_system de netwerk parameters zijn van ons echte systeem (dat dus de uml draait)
garoedanu moeten we de routetabel configureren. we moeten forwarding toelaten en manueel een ARP adres mapping maken voor de uml host
garoedabash -c 'echo 1 > /proc/sys/net/ipv4/ip_forward'
garoedaroute add -host uml_ip dev tap0
garoedabash -c 'echo 1 > /proc/sys/net/ipv4/conf/tap0/proxy_arp'
garoedaarp -Ds uml_ip eth0 pub
garoedauml_ip moet het ip zijn van de uml netwerk interface
garoeda#/dev/net/tun device moet schrijf permissies hebben voor de gebruiker die uml draait:
garoedachgrp gid /dev/net/tun
garoedachgrp gid /dev/net/tun
garoedachmod 660 /dev/net/tun
garoedaons systeem is nu klaar om uml te draaien met netwerk ondersteuning
garoedalinux ubd0=root_fs_woody devfs=nomount rw eth0=tuntap,tap0
garoedanu moet je nog de netwerkparameters in het uml systeem (ip, gateway, dns,...) configureeren en je hebt een draaiend uml systeem met netwerk ondersteuning
garoedahet enig wat je nu nog moet doen is ermee spelen ;-)
garoedadat is alles
garoedabedankt en proficiat voor de vertalers
garoeda(einde voorstelling)

Generated by irclog2html.pl by Jeff Waugh - find it at freshmeat.net!