Den här handledningen är tänkt att ge en enkel introduktion till hur man använder Linux, och då särskilt på datorerna i datorsalarna som Institutionen för naturvetenskap och teknik har i Teknikhuset på Örebro universitet. Introduktionen vänder sig främst till läsare som inte tidigare använt Linux eller något annat Unix-system. Den förutsätter dock att läsaren har en del datorerfarenhet, särskilt från Windows-datorer.
Om man vill köra Linux kan man göra det på olika sätt, till exempel så här:
Om man laddar ner en färdig virtuell Linux-maskin, och kör den i VirtualBox, finns det antagligen information om användarnamn och ett lösenord på samma ställe som man laddar ner den virtuella maskinen från.
Om man använder datorerna i de vanliga datorsalarna på Örebro universitet, loggar man in i Windows som vanligt, och startar sen programmet ThinLinc-klient. Man ska ange servern thinlinc.oru.se, och samma användarnamn och lösenord som man nyss loggade in i Windows med. Man kan klicka på Options och välja om man vill köra Linux i ett fönster på Windows-skrivbordet eller i helskärmsläge.
Om man vill använda ThinLinc på sin egen dator, måste man först ladda ner en ThinLinc-klient och installera på sin egen dator från http://www.cendio.com/thinlinc/download. Som man kanske kan gissa av namnet är klienten ganska liten, så den tar inte särskilt stor plats. Därefter ansluter man på samma sätt som ovan.
Om man använder datorerna i T002, så är det bara Linux som är installerat på dem. Det är lokala installationer, så vanliga studentkonton fungerar inte. Det finns ingen server med gemensam lagring av filer, så om man loggar in på två olika maskiner i T002 med samma användarnamn, så är det helt olika konton, med olika filer och (om någon ändrat det) olika lösenord. Använd samma dator varje gång.
Det är sant att Unix innehåller många verktyg som underlättar för experten, och som kräver att man läser en del i manualer innan man använder dem första gången, men moderna Unix-system, som Linux, är ganska lätta att använda även för nybörjaren. Man har arbetat mycket med att göra verktyg och fönstersystem som ska vara enkla att komma igång med.
Fönstersystemet är inte en del av operativsystemet i Linux, som det är i (nyare) Windows, utan om man vill kan man köra Linux i ett rent textläge. Men det finns flera olika fönstersystem till Linux, och nästan alla användare kör något av dem.
Här är ett exempel på hur skärmen kan se ut i Linux. Bilden är hämtad från en nyinstallerad dator med Ubuntu 18.04. (Klicka på bilden för att se den i stort format.)
Det här fönstersystemet kallas Gnome, och är modernt just nu. Det påminner ganska mycket om skrivbordet i Windows och på Mac. Det finns ett antal ikoner på skrivbordsytan och i listen till vänster, som man kan klicka på för att starta program eller öppna foldrar och filer. Det finns förstås en "filbläddrare" (nere till höger) där man kan öppna kataloger och titta på filer, som på Windows och Mac.
Här är ett lite annorlunda fönstersystem som heter Xfce, och som är det som används när man kör Linux via ThinLinc från maskinerna i de vanliga datorsalarna i Örebro:
Man kan använda andra fönstersystem, och en del går att konfigurera väldigt mycket. Som ett exempel ser min egen skärm ut så här, med en fönsterhanterare som heter ctwm. De sexton rutorna till vänster representerar sexton olika skrivbord, som man kan växla mellan. Det är praktiskt när man arbetar med flera olika saker.
Om man vill kan man dessutom köra Linux i ett rent textläge, utan något fönstersystem alls. Då får man, så att säga, ett enda stort textfönster att arbeta i. Det är vanligt att man gör så på servermaskiner, där man ganska sällan sitter vid datorn utan för det mesta styr den från en annan plats.
Unix har alltid haft kraftfulla textverktyg, så kallade skal, där man kan arbeta effektivt med hjälp av kommandon och egenskrivna programsnuttar. I den här handledningen ska vi bara titta på några av de enklaste kommandona.
Man startar ett skal i ett "terminalfönster" eller "skalfönster", som är motsvarigheten till kommandofönstret ("DOS-prompten") i Windows. I Gnome kan man starta nya program, som Terminal, genom att klicka på prickarna nere till vänster.
Ett skalfönster startas, och där kan man ge kommandon, till exempel ls som helt enkelt listar vilka filer som finns i aktuell katalog:
Prompten tpy-e@live:~$ betyder att det är användaren tpy-e som är inloggad på datorn live, och att aktuell katalog är den användarens hemkatalog (visas som ~). I Unix kan man enkelt logga in på andra datorer via nätverket, till exempel för att administrera en server, och då är det bra att ha datornamnet i prompten så man kommer ihåg vilken det är.
Man skapar nya kataloger med mkdir och byter aktuell katalog med cd:
I Windows är filerna uppdelade på flera olika enheter, C:, D: och så vidare. Under varje sådan enhet är alla filer samlade i ett träd.
I Unix finns bara ett enda träd av filer, som börjar i rotkatalogen. Den heter /. Diskar, usb-minnen, kataloger på servrar och allt annat stoppas in i trädet. Till exempel är det vanligt att användarnas hemkataloger ligger som underkataloger under katalogen home. I stället för till exempel M:\, som man kanske är van vid från Windows, heter hemkatalogen kanske /home/kajsa, om ens användarnamn råkar vara kajsa.
I Windows har alla filer normalt en ändelse, och vilken ändelse filen har avgör vad det är för typ av fil. Till exempel är filer som slutar på .exe körbara filer. I Unix behöver man inte ha filändelser, även om många enskilda verktyg tittar på ändelsen för att avgöra vad det är för fil.
Även fysiska enheter, som diskar, finns med i filträdet. Till exempel heter datorns huvudhårddisk ofta /dev/sda eller /dev/nvme0n1. Man kan öppna hårddisken som vilken fil som helst, och läsa dess innehåll direkt. (Om man har läsrättigheter till den, vilket du förmodligen inte har.)
Filnamn kan anges absolut, som till exempel /home/kajsa/foo, eller relativt till aktuell katalog. Att namnet börjar med ett snedstreck, /, betyder att filnamnet är absolut. Annars är det relativt till aktuell katalog. Om vi antar att aktuell katalog är /home, kan filen med det absoluta namnet /home/hejsan kallas hejsan. Om aktuell katalog fortfarande är /home, kan filen med det absoluta namnet /home/kajsa/foo kallas kajsa/foo. Om aktuell katalog är /home/hjalmar, kan filen kallas ../kajsa/foo. Katalogen .. anger katalogen ovanför aktuell katalog i (det uppochnervända) trädet. Katalogen . anger aktuell katalog, så foo och ./foo är samma fil.
Linux skiljer på stora och små bokstäver i filnamn.
De flesta skal förstår jokertecken ("wildcards") i filnamn. Som vanligt betyder ? ett godtyckligt tecken, och * står för noll, ett eller flera godtyckliga tecken. Det fungerar som i Windows, men med fler möjligheter och mer konsekvent.
Hakklamrar, som i [abcde], kan användas för att ange ett av flera tecken. Samma sak kan skrivas [a-e]. Fiskmåsklamrar kan användas för att ange alternativa delar av ett namn: {abc,de} betyder antingen abc eller de.
Tilde-tecknet, ~, som står för användarens hemkatalog. ~bengt står för användaren bengts hemkatalog.
Exempel: Om din hemkatalog heter /home/kajsa, så matchar mönstret ~/*/a*?.{c,cc} filerna /home/kajsa/koi/ax.c och /home/kajsa/C++/arbete.cc, men inte /home/kajsa/koi/labb1/ax.c eller /home/kajsa/koi/a.c.
Se upp med att det är skalet, och inte operativsystemet, som förstår och tolkar jokertecken och tilde-tecken. Det betyder att man kan skriva ut en fil i ett terminalfönster genom att skriva cat ~kajsa/foo*.{txt,docx}, men man kan inte öppna samma fil i sitt C-program genom att skriva fopen("~kajsa/foo*.{txt,docx}", "r")!
Absoluta och relativa filnamn, även med . och .., är det operativsystemet som hanterar, se dem kan man använda även inuti program.
| Kommando | Funktion | Exempel |
|---|---|---|
| ls | Lista filer |
ls
ls bilder ls prog*.c ls ~/prog*[1-4].{c,C,cpp,cc} |
| mv | Byt namn på en fil |
mv gammal ny
mv prog1.c pro2.c katalogen mv *.c c-programskatalogen |
| cp | Kopiera filer |
cp program.c kopia.c
cp prog1.c prog2.c katalogen cp *.c c-programskatalogen |
| cp -r | Kopiera rekursivt | cp -r en-katalog en-annan-katalog |
| rm | Ta bort en eller flera filer |
rm foo
rm apa.txt foo blaj.c rm /tmp/blaj.c |
| cd | Byt aktuell katalog |
cd koi/labb2
cd /usr/local/bin cd .. |
| mkdir | Skapa en katalog | mkdir min-nya-katalog |
| rmdir | Ta bort en katalog |
rmdir koi
rmdir koi ../gammalt |
| cat | Skriv ut en fil i skalfönstret |
cat foo
cat /etc/passwd |
| more | Skriv ut en fil i skalfönstret en sida i taget |
more foo
more koi/*.c |
| exit | Avsluta ett skal | exit |
| man | Titta på manualbladet för (exempelvis) ett kommando |
man rmdir
man -k time |
| alias | Definiera nya kommandon |
alias ll='ls -l'
alias e='emacs' |
| Varning: Kommandot rm tar bort filer. Det flyttar dem inte till en papperskorg, utan det tar bort dem. "Bort" som i "borta för evigt". Man kan visserligen omdefiniera kommandon i Linux, och det är ganska vanligt att man omdefinierar just kommandot rm så att det flyttar filerna till en papperskorgskatalog. Men om ingen varit snäll och gjort det, så kan man inte få tillbaka en fil som man raderat. |
Exempel:
ls > mina-filer ls | more locate luffartest.c | xargs ls -alFtr
Bägge tar bland annat dessa flaggor:
En stor hjälp är programmet make, som kan göra mycket av detta automatiskt. Om man skriver make foo, och det finns en källkodsfil som heter foo.c, inser make att foo.c ska kompileras för att skapa det körbara programmet foo. Om foo är nyare än foo.c, har det tydligen inte gjorts några ändringar sen senaste kompileringen, och då behöver filen inte kompileras på nytt.
| Kommando | Funktion | Exempel |
|---|---|---|
| gcc | Kompilera och länka C-program |
gcc -c foo.c
gcc -c -Wall foo.c gcc -g foo.c fum.o fie.o -o foo |
| g++ | Kompilera och länka C++-program |
g++ -c foo.cpp
g++ -c -Wall foo.cpp g++ -g foo.cpp fum.o fie.o -o foo |
| make | Kompilera och länka program | make foo |
Här nedan byter vi katalog med cd till katalogen debug-exercise, där vi sen bugger programmet metamatic med hjälp av kommandot make. Till sist startar vi programmet med kommandot ./metamatic (alltså inte bara metamatic). "Segmentation fault" betyder att programmet kraschade. Det är ju en debug-övning!
för att börja editera filen filen.c. &-tecknet betyder att kommandot körs i bakgrunden, så man kan ge nya kommandon i skalfönstret. Program som öppnar sina egna fönster är det ofta praktiskt att göra så med.emacs filen.c &
Så här ser ett Emacs-fönster ut i ett fönstersystem som heter Unity. Emacs är känt för sina många korta kommandon, som till exempel CTRL-B för att flytta markören ett tecken bakåt, ESCAPE b för att flytta markören ett ord bakåt, och CTRL-X ( för att börja definiera ett makro, men som syns på bilden finns det även vanliga menyer (File, Edit och så vidare) som man kan klicka på.
En annan editor, som är mer i stil med Notepad, är gedit. Starta den med kommandot gedit:
Jag själv, och andra Unix-människor jag känner, har i stället flera små fönster. Det kan vara ett fönster att editera i, ett fönster att köra programmet i, ett fönster för att läsa manualen i en webbläsare, och kanske ett kompileringsfönster. Varje fönster är bara så stort som det behöver vara, och eftersom alla får plats på skärmen behöver man sällan bläddra mellan fönstren.
Därför upplever jag det som frustrerande när jag ska kommunicera med någon Windows-person vid datorn, och hon ägnar den mesta tiden åt att bläddra bland sina (onödigt stora) fönster.
Jag tror att det kan finnas flera orsaker till den här vanan med maximerade fönster, bland annat att Windows-människor är vana vid integrerade system (som Visual Studio i stället för Emacs + xterm + gcc + gdb), vilket gör att de oftast inte har mer än ett enda fönster att hålla reda på.
Tänk på att det kan vara praktiskt att ha flera små fönster bredvid varandra på skärmen. I synnerhet när man programmerar.
| Ett gott råd: Automatisera alltid så mycket som möjligt när du programmerar. Manuella steg, som till exempel att komma ihåg att köra bison eller byta namn på en fil, glömmer man förr eller senare alltid bort någon gång. Och sen sitter man där i sex timmar på natten och letar efter fel som inte finns. |
Vi antar att vi har ett C-program, med källkoden i filen foo.c, som kan kompileras till den körbara filen foo. En enkel Makefile för detta kan se ut så här:
(Notera att raden med gcc-kommandot måste börja med ett tab-tecken, inte med mellanslag!)foo: foo.c gcc -g -Wall foo.c -o foo
Detta betyder att vi kan skapa filen foo utgående från filen foo.c, genom att köra kommandot gcc -g -Wall foo.c -o foo. Filen foo är också beroende av filen foo.c, så om foo.c har ändrats sen foo skapades, så måste kommandot köras på nytt.
Om vi nu ger kommandot make, i katalogen där filerna foo.c och Makefile finns, så kommer kompileringen att köras:
Om vi skriver samma kommando en gång till direkt, utan att ha ändrat i filen foo.c, så är make tillräckligt smart för att inse att programmet inte behöver kompileras om:tpy@live:~/koi$ make foo gcc -g -Wall foo.c -o foo tpy@live:~/koi$
Här är en lite mer avancerad Makefile:tpy@live:~/koi$ make foo make: `foo' is up to date. tpy@live:~/koi$
Körexempel:# Makefile för debug-övningsuppgiften # Skriv bara "make" för att kompilera programmet metamatic! OFILES = metamatic.o a.o abc.o abscissa.o absurdum.o ack.o CPPFLAGS += -g metamatic: $(OFILES) g++ -g $(OFILES) -o metamatic clean: rm -f $(OFILES) metamatic
tpy@live:~/koi$ make g++ -g -c -o metamatic.o metamatic.cc g++ -g -c -o a.o a.cpp g++ -g -c -o abc.o abc.cpp g++ -g -c -o abscissa.o abscissa.cpp g++ -g -c -o absurdum.o absurdum.cpp g++ -g -c -o ack.o ack.cpp g++ -g metamatic.o a.o abc.o abscissa.o absurdum.o ack.o -o metamatic tpy@live:~/koi$ make clean rm -f metamatic.o a.o abc.o abscissa.o absurdum.o ack.o metamatic tpy@live:~/koi$
Men när man laddar ner och installerar "Linux" är det inte bara kärnan, utan många andra program, som skalet ("shell"), fönstersystemet (normalt fönstersystemet X), olika kompilatorer, och så vidare. Även systemprogram som "cp" (som kopierar filer) och "rm" (som tar bort filer) finns med, men ingår inte i kärnan. Många program kommer från GNU-projektet, och därför vill en del använda termen "GNU/Linux" hellre än bara "Linux".
Det finns många olika paketeringar, eller distributioner, av Linux. Linux-kärnan och många av de centrala systemprogrammen är gemensamma, men de kan variera en del bland annat i vilka tilläggsprogram som skickas med, och i hur användargränssnittet ser ut. Några vanliga distributioner heter Ubuntu, Debian och CentOS.
Man bör också nämna Android, som innehåller Linux-kärnan och många systemprogram, men med tillägg anpassade för mobila enheter.