Att förstå och hantera processer är en av de mest grundläggande färdigheterna i Linux. När du kör ett program – vare sig det är en webbläsare, ett terminalkommando eller en systemtjänst – skapas en process. Ibland behöver du som användare ta kontroll över dessa processer: kanske för att ett program har hängt sig, för att frigöra resurser eller för att starta om en tjänst. I Linux görs detta genom att skicka signaler till processer via terminalen. I den här guiden går vi igenom vad processer är, hur signaler fungerar och hur du kan använda viktiga kommandon som kill, killall, pkill, fuser, pgrep och skill för att söka upp, pausa eller avsluta processer – med tydliga exempel för nybörjare.

Vad är en process i Linux?

En process är ett körande program på datorn. Operativsystemet Linux hanterar många processer samtidigt och ger varje process ett unikt process-ID (PID) för identifiering. Processer kan vara synliga användarprogram (som ett webbrowserfönster) eller systemtjänster som körs i bakgrunden. Linux-kärnan ansvarar för att schemalägga processer, fördela resurser och hålla isär deras minne och rättigheter. Som användare kan man med kommandon i terminalen inspektera och påverka processer, till exempel om ett program har hängt sig eller om man behöver avsluta en process som förbrukar för mycket resurser.

Varför behöver man hantera eller avsluta processer?

Vanliga anledningar till att manuellt hantera (eller döda) processer är att ett program inte svarar, har låst sig eller använder orimligt mycket CPU/minne. Ibland behöver man avsluta ett program som körs i bakgrunden, starta om en tjänst genom att skicka en viss signal, eller frigöra en fil eller nätverksport som en process håller låst. Genom att skicka signaler till processer kan man be dem avsluta på ett kontrollerat sätt eller tvinga fram en avslutning om de inte reagerar. Att känna till de viktigaste kommandona för processhantering – såsom kill, killall, pkill, fuser, pgrep och skill – är därför värdefullt. I denna artikel går vi igenom vad signaler är och hur man använder dessa kommandon med praktiska exempel.

Signaler i Linux och vanliga signaler

En signal är ett meddelande som operativsystemet kan skicka till en process för att uppmärksamma den på en händelse eller begära en viss åtgärd. Signaler identifieras både med namn (ofta med prefixet SIG) och ett nummer. Till exempel är SIGTERM signal nummer 15, SIGKILL nummer 9, SIGHUP nummer 1 och SIGSTOP nummer 19. När en signal skickas till en process avbryts den normalt tillfälligt för att hantera signalen. Vissa signaler kan fångas upp av processen (som då kan välja att ignorera dem eller utföra städning), medan andra inte kan ignoreras.

Några vanliga signaler och deras betydelser är:

• SIGTERM (15) – Termineringssignal. Standard-signalen som skickas av kommandot kill. Den ber processen att avsluta sig själv gracefully, dvs. på ett kontrollerat sätt[2]. Processen får en chans att städa upp, spara sitt tillstånd, stänga filer etc., innan den avslutas.
• SIGKILL (9) – Kill-signalen. Detta är en tvångsavslutning som inte kan fångas eller ignoreras av processen[1][3]. Operativsystemet terminerar processen omedelbart när det får denna signal, även om processen hängt sig. SIGKILL bör användas som sista utväg när en process inte reagerar på vänligare signaler, eftersom ingen städning sker och t.ex. temporära filer eller resurser kan lämnas i osäkert tillstånd[3].
• SIGHUP (1) – Hang up. Ursprungligen indikerar detta att den terminal (TTY) som startade processen kopplades ned. För många bakgrundstjänster (daemons) har det blivit konvention att SIGHUP innebär att processen ska läsa om sin konfiguration eller starta om sig själv[4]. Man kan alltså skicka SIGHUP till en daemon för att få den att göra en mjuk omstart eller ladda om inställningar.
• SIGSTOP (19) – Stoppsignal. Pauserar en process (fryser dess exekvering) utan att avsluta den, och kan inte ignoreras av processen[1]. Detta motsvarar att köra ett program i bakgrunden genom att trycka Ctrl+Z i terminalen. En stoppad process kan återupptas igen genom att skicka SIGCONT (continue) eller föras in i förgrunden med shell-kommandon som fg. SIGSTOP/SIGCONT är användbara om man tillfälligt vill pausa en process (t.ex. för felsökning) utan att döda den.

Det finns många fler signaler (för att lista alla standard-signaler kan man köra kill -l eller fuser -l i terminalen). Som nybörjare är det viktigast att förstå att SIGTERM är standardmetoden att avsluta processer på ett snällt sätt, SIGKILL är en tvingande nödlösning, och att signaler som SIGHUP och SIGSTOP har speciella användningsområden. Nästa steg är att använda kommandon som skickar dessa signaler till processer.

Kommandot kill – avsluta processer med PID

Det mest grundläggande sättet att skicka en signal till en process är med kommandot kill. Namnet låter brutalt, men kill skickar egentligen en godtycklig signal (som standard SIGTERM) till en eller flera processer utifrån deras PID. För att använda kill måste du alltså känna till processens ID-nummer. Detta kan man ta reda på med verktyg som ps (processlista), top eller pgrep (mer om pgrep nedan).

Syntax: kill [signal] PID … (om ingen signal anges skickas SIGTERM som standard).

Exempel på användning:

# Skicka standardsignalen SIGTERM (15) till process med PID 1234
kill 1234

Kommandot ovan ber processen 1234 att avsluta sig själv snällt (SIGTERM är default för kill[2]). Om processen inte avslutas kan man behöva skicka en mer drastisk signal:

# Tvinga avslutning av process 1234 med SIGKILL (9)
kill -9 1234

Här används flaggan -9 för att skicka signal 9 (SIGKILL), vilket omedelbart dödar processen[3]. Notera att man också kan skriva kill -SIGKILL 1234 – många signaler kan anges antingen med nummer, med fullt namn (t.ex. -SIGKILL) eller förkortat utan ”SIG” (t.ex. -KILL), alla dessa är ekvivalenta.

Ett normalfall är att först försöka med en vanlig kill (SIGTERM) och ge processen åtminstone några sekunder att avsluta sig på rätt sätt. Om den fortsatt vägrar dö eller hänger sig, kan man följa upp med kill -9 för att garantera att den försvinner. SIGKILL kan som sagt inte ignoreras av processen[5].

Kommandot kill kan även skicka andra signaler. Till exempel kan man skicka SIGHUP (1) för att instruera en process att starta om eller läsa om konfiguration:

# Skicka SIGHUP (1) till process 5678, ofta för att få en daemon att läsa om sin config
kill -1 5678 # -1 motsvarar SIGHUP
kill -HUP 5678 # detta är likvärdigt med -1

På liknande sätt kan kill -STOP användas för att pausa en process och kill -CONT för att fortsätta en pausad process. Om du är osäker på signalnamnet eller numret kan du skriva:

# Lista alla signals namn och nummer
kill -l

Detta listar alla signaler som systemet känner till (t.ex. får du reda på att 15 = TERM, 9 = KILL, 1 = HUP, etc.).

Tips: kill är inbyggt i många shell (som Bash). Oftast räcker det att ange PID, men var försiktig så att du inte råkar ange fel PID. Det är alltid en bra idé att dubbelkolla med exempelvis ps eller pgrep att du har rätt process. Som vanlig användare kan du bara skicka signaler till processer du äger (startat själv), medan root-användaren kan signalera alla processer.

Kommandot killall – döda processer utifrån namn

Med killall kan du skicka en signal till samtliga processer som matchar ett givet kommando-namn. Till skillnad från kill behöver du alltså inte känna till PID; istället anger du namnet på processen/programmet. Som standard skickar killall också SIGTERM om ingen annan signal anges[6].

Syntax: killall [flaggor] [signal] namn…

Ett enkelt exempel:

# Försöker stänga alla processer som heter ”firefox” med SIGTERM
killall firefox

Ovanstående kommando försöker avsluta alla körande Firefox-processer (t.ex. om flera webbläsarfönster är öppna) genom att skicka SIGTERM till dem. Om de inte stänger sig ordentligt kan man tvinga dem:

# Döda alla ”firefox”-processer med SIGKILL (9)
killall -9 firefox

Flaggan -9 fungerar här likadant som för kill. Man kan även specificera signalnamn, till exempel killall -KILL firefox gör samma sak. Under huven skickar killall signalen till alla processer med det angivna namnet[6].

Det är viktigt att ange processen vid exakt namn. killall matchar som default hela kommandonamnet. Till exempel, killall vi dödar processer vars namn är precis ”vi”, men inte ”vim”. Man kan använda flaggan -I för att ignorera skillnad mellan versaler/gemener vid namnmatchning, eller -r för att tolka namnet som ett regular expression (regex) om man vill ha mer flexibel matchning[7]. Exempelvis skulle killall -r -9 ^firefox med regex döda alla processer vars namn börjar med ”firefox”.

Några andra praktiska flaggor för killall är: – -i (interactive) – frågar om bekräftelse före varje enskild process som ska dödas. Bra för säkerhets skull om man är osäker. – -v (verbose) – skriver ut information om huruvida signalen lyckades skickas till var och en. – -u användare – begränsa till processer som ägs av en viss användare. T.ex. killall -u alice firefox skulle bara försöka döda Alice instanser av firefox.

Varning: killall på Linux är harmlöst om du anger ett specifikt processnamn, men se upp så att du inte misstar det för det helt annorlunda kommandot killall på vissa Unix-system (som Solaris) där killall utan argument faktiskt försöker döda alla processer. På Linux är killall en del av psmisc-paketet och fungerar enligt ovan. Ange alltid explicit ett processnamn när du använder detta kommando.

Kommandot pkill – skicka signal utifrån sökmönster

pkill liknar killall genom att det låter dig avsluta processer baserat på namn, men det är mer flexibelt. Namnet pkill står för ”process kill” och är kopplat till kommandot pgrep (process grep). I själva verket är pkill en variant av pgrep som istället för att lista processer skickar en signal till dem som matchar kriteriet[8]. pkill använder sig av mönstermatchning (standardmässigt regular expressions) på processernas namn eller andra attribut.

Syntax: pkill [flaggor] [signal] mönster

Om ingen signal anges så skickar pkill som vanligt SIGTERM (15)[9]. Mönstret kan vara en del av processens namn. Exempel:

# Försök avsluta alla processer vars namn innehåller ”chrome”
pkill chrome

Ovan kommando skulle skicka SIGTERM till alla processer som matchar regex-mönstret ”chrome” i sitt namn (så det träffar t.ex. både chrome och chromium om de körs). Vill man vara specifik att namnet ska matcha exakt, kan man använda flaggan -x (exact match). Alternativt kan man skriva regex med ^ och $ för att ange början/slut på namnet:

# Avsluta alla processer som heter exakt ”ssh” (inte bara innehåller ”ssh”)
pkill -x ssh

Man kan på liknande sätt som med killall använda -9 eller -KILL för att skicka SIGKILL:

# Tvinga bort alla processer vars namn matchar ”chrome”
pkill -9 chrome

Ett praktiskt användningsområde är att skicka andra signaler. Till exempel för att be en tjänst ladda om sin konfiguration (vilket ofta görs med SIGHUP) kan du göra:

# Ladda om Nginx konfiguration genom att skicka SIGHUP (1) till alla ”nginx”-processer
pkill -HUP nginx

Detta utnyttjar att många tjänster (inklusive Nginx) tolkar SIGHUP som signal att läsa om config[10][11].

pkill har flera användbara flaggor för att begränsa vilka processer som träffas: – -f – matcha mot hela kommandoraden istället för bara basnamnet. T.ex. pkill -f ”python myscript.py” skulle matcha kommandoraden som innehåller texten python myscript.py (användbart om processen har ett generiskt namn men unika argument). – -u användare – matcha bara processer som körs av en viss användare (eller lista av användare). T.ex. pkill -u bob ssh dödar ssh-processer som körs av användaren bob. – -n / -o – matcha endast den nyaste respektive äldsta processen som uppfyller mönstret. Detta är bra om man t.ex. vill döda den senast startade instansen av något. – -c – (i vissa varianter) visa antal träffade processer istället för att döda (eller används i pgrep specifikt – se man pkill/pgrep).

En viktig sak med pkill är att det är lätt att matcha bredare än avsett om man inte är försiktig med mönstret. Till exempel kan pkill ssh även döda en process som heter ssh-agent eftersom ”ssh” ingår i namnet. Därför är ett gott råd att först testa mönstret med pgrep (som bara listar träffar) innan man kör pkill. Exempel:

pgrep -l chrome # listar PIDs och namn för processer som matchar ”chrome”

Om utdata ser rimlig ut så kan man sedan byta ut pgrep mot pkill med samma mönster för att faktiskt skicka signalen.

Kommandot pgrep – hitta processer utifrån namn eller villkor

Som nämnt är pgrep syskonverktyget till pkill. Istället för att skicka signaler listar pgrep helt enkelt ut process-ID för processer vars namn eller andra attribut matchar ett mönster. Formatet liknar pkill:

Syntax: pgrep [flaggor] mönster

Standardbeteendet är att matcha processnamn (kommandots namn) mot ett angivet mönster (som tolkas som regex). pgrep skriver ut matchande PIDs, ett per rad. Några exempel:

# Hitta PID för alla processer vars namn innehåller ”ssh”
pgrep ssh

# Hitta PID för processen som heter exakt ”gnome-shell”
pgrep -x gnome-shell Hantera processer i Linux från terminalen – En nybörjarguide

Vad är en process i Linux?

En process är ett körande program på datorn. Operativsystemet Linux hanterar många processer samtidigt och ger varje process ett unikt process-ID (PID) för identifiering. Processer kan vara synliga användarprogram (som ett webbrowserfönster) eller systemtjänster som körs i bakgrunden. Linux-kärnan ansvarar för att schemalägga processer, fördela resurser och hålla isär deras minne och rättigheter. Som användare kan man med kommandon i terminalen inspektera och påverka processer, till exempel om ett program har hängt sig eller om man behöver avsluta en process som förbrukar för mycket resurser.

Varför behöver man hantera eller avsluta processer?

Vanliga anledningar till att manuellt hantera (eller döda) processer är att ett program inte svarar, har låst sig eller använder orimligt mycket CPU/minne. Ibland behöver man avsluta ett program som körs i bakgrunden, starta om en tjänst genom att skicka en viss signal, eller frigöra en fil eller nätverksport som en process håller låst. Genom att skicka signaler till processer kan man be dem avsluta på ett kontrollerat sätt eller tvinga fram en avslutning om de inte reagerar. Att känna till de viktigaste kommandona för processhantering – såsom kill, killall, pkill, fuser, pgrep och skill – är därför värdefullt. I denna artikel går vi igenom vad signaler är och hur man använder dessa kommandon med praktiska exempel.

Signaler i Linux och vanliga signaler

En signal är ett meddelande som operativsystemet kan skicka till en process för att uppmärksamma den på en händelse eller begära en viss åtgärd. Signaler identifieras både med namn (ofta med prefixet SIG) och ett nummer. Till exempel är SIGTERM signal nummer 15, SIGKILL nummer 9, SIGHUP nummer 1 och SIGSTOP nummer 19[1]. När en signal skickas till en process avbryts den normalt tillfälligt för att hantera signalen. Vissa signaler kan fångas upp av processen (som då kan välja att ignorera dem eller utföra städning), medan andra inte kan ignoreras.

Några vanliga signaler och deras betydelser är:

• SIGTERM (15) – Termineringssignal. Standard-signalen som skickas av kommandot kill. Den ber processen att avsluta sig själv gracefully, dvs. på ett kontrollerat sätt[2]. Processen får en chans att städa upp, spara sitt tillstånd, stänga filer etc., innan den avslutas.
• SIGKILL (9) – Kill-signalen. Detta är en tvångsavslutning som inte kan fångas eller ignoreras av processen[1][3]. Operativsystemet terminerar processen omedelbart när det får denna signal, även om processen hängt sig. SIGKILL bör användas som sista utväg när en process inte reagerar på vänligare signaler, eftersom ingen städning sker och t.ex. temporära filer eller resurser kan lämnas i osäkert tillstånd[3].
• SIGHUP (1) – Hang up. Ursprungligen indikerar detta att den terminal (TTY) som startade processen kopplades ned. För många bakgrundstjänster (daemons) har det blivit konvention att SIGHUP innebär att processen ska läsa om sin konfiguration eller starta om sig själv[4]. Man kan alltså skicka SIGHUP till en daemon för att få den att göra en mjuk omstart eller ladda om inställningar.
• SIGSTOP (19) – Stoppsignal. Pauserar en process (fryser dess exekvering) utan att avsluta den, och kan inte ignoreras av processen[1]. Detta motsvarar att köra ett program i bakgrunden genom att trycka Ctrl+Z i terminalen. En stoppad process kan återupptas igen genom att skicka SIGCONT (continue) eller föras in i förgrunden med shell-kommandon som fg. SIGSTOP/SIGCONT är användbara om man tillfälligt vill pausa en process (t.ex. för felsökning) utan att döda den.

Det finns många fler signaler (för att lista alla standard-signaler kan man köra kill -l eller fuser -l i terminalen). Som nybörjare är det viktigast att förstå att SIGTERM är standardmetoden att avsluta processer på ett snällt sätt, SIGKILL är en tvingande nödlösning, och att signaler som SIGHUP och SIGSTOP har speciella användningsområden. Nästa steg är att använda kommandon som skickar dessa signaler till processer.

Kommandot kill – avsluta processer med PID

Det mest grundläggande sättet att skicka en signal till en process är med kommandot kill. Namnet låter brutalt, men kill skickar egentligen en godtycklig signal (som standard SIGTERM) till en eller flera processer utifrån deras PID. För att använda kill måste du alltså känna till processens ID-nummer. Detta kan man ta reda på med verktyg som ps (processlista), top eller pgrep (mer om pgrep nedan).

Syntax: kill [signal] PID … (om ingen signal anges skickas SIGTERM som standard).

Exempel på användning:

# Skicka standardsignalen SIGTERM (15) till process med PID 1234
kill 1234

Kommandot ovan ber processen 1234 att avsluta sig själv snällt (SIGTERM är default för kill[2]). Om processen inte avslutas kan man behöva skicka en mer drastisk signal:

# Tvinga avslutning av process 1234 med SIGKILL (9)
kill -9 1234

Här används flaggan -9 för att skicka signal 9 (SIGKILL), vilket omedelbart dödar processen[3]. Notera att man också kan skriva kill -SIGKILL 1234 – många signaler kan anges antingen med nummer, med fullt namn (t.ex. -SIGKILL) eller förkortat utan ”SIG” (t.ex. -KILL), alla dessa är ekvivalenta.

Ett normalfall är att först försöka med en vanlig kill (SIGTERM) och ge processen åtminstone några sekunder att avsluta sig på rätt sätt. Om den fortsatt vägrar dö eller hänger sig, kan man följa upp med kill -9 för att garantera att den försvinner. SIGKILL kan som sagt inte ignoreras av processen[5].

Kommandot kill kan även skicka andra signaler. Till exempel kan man skicka SIGHUP (1) för att instruera en process att starta om eller läsa om konfiguration:

# Skicka SIGHUP (1) till process 5678, ofta för att få en daemon att läsa om sin config
kill -1 5678 # -1 motsvarar SIGHUP
kill -HUP 5678 # detta är likvärdigt med -1

På liknande sätt kan kill -STOP användas för att pausa en process och kill -CONT för att fortsätta en pausad process. Om du är osäker på signalnamnet eller numret kan du skriva:

# Lista alla signals namn och nummer
kill -l

Detta listar alla signaler som systemet känner till (t.ex. får du reda på att 15 = TERM, 9 = KILL, 1 = HUP, etc.).

Tips: kill är inbyggt i många shell (som Bash). Oftast räcker det att ange PID, men var försiktig så att du inte råkar ange fel PID. Det är alltid en bra idé att dubbelkolla med exempelvis ps eller pgrep att du har rätt process. Som vanlig användare kan du bara skicka signaler till processer du äger (startat själv), medan root-användaren kan signalera alla processer.

Kommandot killall – döda processer utifrån namn

Med killall kan du skicka en signal till samtliga processer som matchar ett givet kommando-namn. Till skillnad från kill behöver du alltså inte känna till PID; istället anger du namnet på processen/programmet. Som standard skickar killall också SIGTERM om ingen annan signal anges[6].

Syntax: killall [flaggor] [signal] namn…

Ett enkelt exempel:

# Försöker stänga alla processer som heter ”firefox” med SIGTERM
killall firefox

Ovanstående kommando försöker avsluta alla körande Firefox-processer (t.ex. om flera webbläsarfönster är öppna) genom att skicka SIGTERM till dem. Om de inte stänger sig ordentligt kan man tvinga dem:

# Döda alla ”firefox”-processer med SIGKILL (9)
killall -9 firefox

Flaggan -9 fungerar här likadant som för kill. Man kan även specificera signalnamn, till exempel killall -KILL firefox gör samma sak. Under huven skickar killall signalen till alla processer med det angivna namnet[6].

Det är viktigt att ange processen vid exakt namn. killall matchar som default hela kommandonamnet. Till exempel, killall vi dödar processer vars namn är precis ”vi”, men inte ”vim”. Man kan använda flaggan -I för att ignorera skillnad mellan versaler/gemener vid namnmatchning, eller -r för att tolka namnet som ett regular expression (regex) om man vill ha mer flexibel matchning[7]. Exempelvis skulle killall -r -9 ^firefox med regex döda alla processer vars namn börjar med ”firefox”.

Några andra praktiska flaggor för killall är: – -i (interactive) – frågar om bekräftelse före varje enskild process som ska dödas. Bra för säkerhets skull om man är osäker. – -v (verbose) – skriver ut information om huruvida signalen lyckades skickas till var och en. – -u användare – begränsa till processer som ägs av en viss användare. T.ex. killall -u alice firefox skulle bara försöka döda Alice instanser av firefox.

Varning: killall på Linux är harmlöst om du anger ett specifikt processnamn, men se upp så att du inte misstar det för det helt annorlunda kommandot killall på vissa Unix-system (som Solaris) där killall utan argument faktiskt försöker döda alla processer. På Linux är killall en del av psmisc-paketet och fungerar enligt ovan. Ange alltid explicit ett processnamn när du använder detta kommando.

Svensk manualsida till killall(1)

Kommandot pkill – skicka signal utifrån sökmönster

pkill liknar killall genom att det låter dig avsluta processer baserat på namn, men det är mer flexibelt. Namnet pkill står för ”process kill” och är kopplat till kommandot pgrep (process grep). I själva verket är pkill en variant av pgrep som istället för att lista processer skickar en signal till dem som matchar kriteriet[8]. pkill använder sig av mönstermatchning (standardmässigt regular expressions) på processernas namn eller andra attribut.

Syntax: pkill [flaggor] [signal] mönster

Om ingen signal anges så skickar pkill som vanligt SIGTERM (15)[9]. Mönstret kan vara en del av processens namn. Exempel:

# Försök avsluta alla processer vars namn innehåller ”chrome”
pkill chrome

Ovan kommando skulle skicka SIGTERM till alla processer som matchar regex-mönstret ”chrome” i sitt namn (så det träffar t.ex. både chrome och chromium om de körs). Vill man vara specifik att namnet ska matcha exakt, kan man använda flaggan -x (exact match). Alternativt kan man skriva regex med ^ och $ för att ange början/slut på namnet:

# Avsluta alla processer som heter exakt ”ssh” (inte bara innehåller ”ssh”)
pkill -x ssh

Man kan på liknande sätt som med killall använda -9 eller -KILL för att skicka SIGKILL:

# Tvinga bort alla processer vars namn matchar ”chrome”
pkill -9 chrome

Ett praktiskt användningsområde är att skicka andra signaler. Till exempel för att be en tjänst ladda om sin konfiguration (vilket ofta görs med SIGHUP) kan du göra:

# Ladda om Nginx konfiguration genom att skicka SIGHUP (1) till alla ”nginx”-processer
pkill -HUP nginx

Detta utnyttjar att många tjänster (inklusive Nginx) tolkar SIGHUP som signal att läsa om config[10][11].

pkill har flera användbara flaggor för att begränsa vilka processer som träffas: – -f – matcha mot hela kommandoraden istället för bara basnamnet. T.ex. pkill -f ”python myscript.py” skulle matcha kommandoraden som innehåller texten python myscript.py (användbart om processen har ett generiskt namn men unika argument). – -u användare – matcha bara processer som körs av en viss användare (eller lista av användare). T.ex. pkill -u bob ssh dödar ssh-processer som körs av användaren bob. – -n / -o – matcha endast den nyaste respektive äldsta processen som uppfyller mönstret. Detta är bra om man t.ex. vill döda den senast startade instansen av något. – -c – (i vissa varianter) visa antal träffade processer istället för att döda (eller används i pgrep specifikt – se man pkill/pgrep).

En viktig sak med pkill är att det är lätt att matcha bredare än avsett om man inte är försiktig med mönstret. Till exempel kan pkill ssh även döda en process som heter ssh-agent eftersom ”ssh” ingår i namnet. Därför är ett gott råd att först testa mönstret med pgrep (som bara listar träffar) innan man kör pkill. Exempel:

pgrep -l chrome # listar PIDs och namn för processer som matchar ”chrome”

Om utdata ser rimlig ut så kan man sedan byta ut pgrep mot pkill med samma mönster för att faktiskt skicka signalen.

Svensk manualsida till pkill(1)

Kommandot pgrep – hitta processer utifrån namn eller villkor

Som nämnt är pgrep syskonverktyget till pkill. Istället för att skicka signaler listar pgrep helt enkelt ut process-ID för processer vars namn eller andra attribut matchar ett mönster. Formatet liknar pkill:

Syntax: pgrep [flaggor] mönster

Standardbeteendet är att matcha processnamn (kommandots namn) mot ett angivet mönster (som tolkas som regex). pgrep skriver ut matchande PIDs, ett per rad. Några exempel:

# Hitta PID för alla processer vars namn innehåller ”ssh”
pgrep ssh

# Hitta PID för processen som heter exakt ”gnome-shell”
pgrep -x gnome-shell

# Hitta alla processer som körs av användaren alice och innehåller ”python” i namnet
pgrep -u alice python

I det sista exemplet kombineras -u alice för att filtrera på ägare och mönstret ”python” för att filtrera på namn. pgrep har i stort sett samma filterflaggor som pkill (som -f, -x, -n, -o, -u etc.), så man kan göra avancerade sökningar. En användbar flagga är -l (lågt L) som gör att pgrep listar inte bara PID utan även processens namn:

pgrep -l ssh

Det kan ge utdata som:

1039 sshd
2257 ssh-agent
6850 ssh
31279 ssh-agent

Då ser man både PID och vilket program det är. Om man vill ha hela kommandoraden kan man använda -a i stället för -l.

pgrep är således mycket smidigare än att köra t.ex. ps aux | grep namn och manuellt leta PIDs. När man väl fått en PID via pgrep kan man sedan använda kill på den, eller direkt använda pkill som vi gjorde ovan för att slippa steget att manuellt läsa av PID.

Svenska manualsida till pgrep(1)

Kommandot fuser – hitta (och döda) processer som använder en resurs

fuser är ett verktyg som skiljer sig lite från de övriga: det är inte en renodlad ”kill”-kommandon utan används för att identifiera vilka processer som använder en viss resurs. En resurs i detta sammanhang kan vara en fil, en mapp, eller en nätverksport/socket. Namnet fuser kommer av ”file user”, dvs vilka processer som använder en fil.

Ett klassiskt problem är ”varför kan jag inte montera/avmontera den här disken?” eller ”vilken process kör på port 8080?”. fuser hjälper dig att svara på det, och kan även ta steget att döda de processer som blockerar en resurs.

Syntax: fuser [flaggor] [resurs]

Några vanliga användningsfall:

# Ta reda på vilken process som använder filen /var/log/syslog
fuser /var/log/syslog

# Lista vilken process som lyssnar på TCP-port 80 (HTTP)
fuser 80/tcp

# Visa mer detaljer (ägare, access-typ etc.) för processer som kör på port 80
fuser -v 80/tcp

När man kör fuser på en fil eller port returnerar den normalt vilka PID:er som använder resursen. Flaggan -v (verbose) ger en tabell som visar PID, användare, och hur de använder resursen (t.ex. F för öppnad fil, e för exe-körning, tcp för nätverkstjänst etc.)[12][13].

En mycket praktisk funktion är att kunna döda alla processer som använder en viss resurs. Detta görs med flaggan -k (kill). Exempel:

# Döda processen som använder TCP-port 8443
sudo fuser -k 8443/tcp

Här letar fuser upp vilken process som lyssnar på port 8443 och skickar SIGKILL till den[14]. Som standard skickar fuser -k nämligen SIGKILL till processerna[15]. Om man istället vill försöka avsluta dem mjukare kan man specificera signal, t.ex. fuser -k -TERM 8443/tcp för att skicka SIGTERM (15)[16][17]. Generellt kan man lägga till -[SIGNAL] efter -k för valfri signal.

VARNING: Använd fuser -k med omsorg. Om du anger en vanlig fil som resurs kommer bara processen som har just den filen öppen att dödas, men om du anger en hel mapp eller en monteringspunkt (t.ex. ett helt filsystem) så kommer alla processer som använder något i den mappen att dödas[18]. Till exempel fuser -k /home kan i värsta fall döda en mängd processer (eftersom många program sannolikt har något öppet under /home). Var därför specifik med resursen och använd gärna -i (interactive) flaggan tillsammans med -k för att be om bekräftelse för varje träff innan den dödas[18]. Exempel:

# Interaktivt (-i) döda alla processer som använder aktuell mapp (.)
fuser -ki .

Ovan skulle lista alla processer som kör något i nuvarande katalog, och fråga y/n innan varje dödas.

Slutligen, fuser -l visar en lista över alla signalnamn som kommandot känner till, liknande kill -l. fuser är ett kraftfullt verktyg när man till exempel felsöker ”resource busy” felmeddelanden – man kan snabbt hitta vilken process som blockerar en fil eller port och avsluta den för att komma vidare.

Svensk manualsida till fuser(1)

Kommandot skill – (föråldrat) skicka signaler baserat på användare/terminal

Kommandot skill har snarlikt namn som kill, men är ett separat verktyg som låter dig skicka signaler till processer baserat på kriterier som användarnamn, terminal eller kommandonamn. Det kan ses som en föregångare till moderna verktyg som pkill och killall. I dagens Linux-system betraktas skill som föråldrat (obsolete) och ostandardiserat – dokumentationen själv rekommenderar att man använder killall, pkill och pgrep istället[19]. Vi tar ändå upp det här för fullständighetens skull.

Syntax: skill [signal] [val för urval]

Till skillnad från killall/pkill som använder argument och flaggor för att matcha processer, så använder skill en mer fri form där man exempelvis kan ange en användare eller en terminal direkt. För att eliminera tvetydighet finns dock flaggor: – -u användare för att matcha alla processer körda av en given användare. – -t tty för att matcha en viss terminal (TTY/PTY) där processerna körs. – -p pid för att matcha ett specifikt process-ID. – -c namn för att matcha ett kommandonamn.

Standard-signalen för skill är SIGTERM (precis som kill)[20]. Du kan lista tillgängliga signalnamn med skill -l (eller -L för en tabell). Signal anges antingen med t.ex. -SIGKILL eller kortare -KILL eller med nummer -9.

Några exempel på vad man kan göra med skill:

# Döda (SIGKILL) alla processer som körs av användaren ”bob”
sudo skill -KILL -u bob

Detta liknar att köra killall -u bob eller pkill -9 -u bob – alla Bobs processer avslutas[21]. Ett annat exempel:

# Stoppa (pausa med SIGSTOP) alla processer som körs på terminal /dev/pts/3
skill -STOP -t pts/3

Om en användare har en viss terminal öppen (t.ex. pts/3 över SSH) skulle ovan kommando frysa alla den användarens processer i just den terminalen. Man kan även ange flera kriterier:

# Exempel från man-sidan: stoppa alla processer för tre olika användare
skill -STOP -u alice -u bob -u charlie

Och på motsvarande sätt kan man döda alla processer på alla pseudoterminaler (PTY):

# Exempel: logga ut alla användare på pts-terminaler med tvång
sudo skill -KILL -v /dev/pts/*

Här används -v för verbose så att varje träff rapporteras. Detta kommando skulle skicka SIGKILL till samtliga processer som är kopplade till någon pts-terminal (praktiskt taget logga ut alla interaktiva sessions) – använd med extrem försiktighet!

Sammanfattningsvis är skill kraftfull men inte så vanligt förekommande längre. Samma sak kan oftast göras med pkill/killall som är mer portabla mellan system. Om du stöter på skill i dokumentation eller scripts vet du nu att det är ett verktyg för att signalera processer med liknande funktion som killall/pkill, men i moderna Linux-distributioner kan du själv välja att använda de senare för klarhetens skull[19].

Svenska manualsida till skill(1)

ps – lista och filtrera processer

ps visar en ögonblicksbild av aktiva processer. Det används för att hitta PID:er och förstå vad som körs.

Exempel:
ps – Terminalens egna processer
ps aux – Alla processer i BSD-format
ps -ef – Alla processer i System V-format
ps -eo pid,ppid,user,%cpu,%mem,stat,etime,cmd | head
ps -C sshd -o pid,ppid,cmd
ps -ef –forest | less

Några viktiga kolumner:

• PID – process-ID
• PPID – föräldraprocessens ID
• STAT – status (R=running, S=sleeping, T=stopped, Z=zombie)
• %CPU / %MEM – resursanvändning

Svensk manualsida till ps(1)

pidof – hämta PID utifrån namn

Ger PID för körande program, bra i skript.

Exempel:
pidof nginx
ps -p ”$(pidof nginx)” -o pid,ppid,%cpu,%mem,cmd

Svensk manualsida för pidof(1)

pstree – visa processhierarki

pstree ritar processer i ett träd.

Exempel:
pstree
pstree -p – med PIDs
pstree -a – med kommandorader

Svensk manualsidan till pstree(1)

lsof – lista öppna filer och portar

lsof visar vilka filer eller nätverksportar som används av processer.

Exempel:
sudo lsof /var/log/syslog
sudo lsof -P -i :8080
sudo lsof -t -i :8443 – endast PID
sudo lsof -p 1234 – öppna filer för specifik PID

Flaggor:

• -P → visa portnummer
• -n → hoppa över DNS
• -t → endast PID

Svenskmanualsida för lsof(8)

top och htop – realtidsövervakning

Interaktiva verktyg för att se processer i realtid.

Exempel:
top
htop

Tips i top:

• M → sortera på minne
• P → sortera på CPU
• k → döda en process (ange PID och signal)

Avslutande tips

Att hantera processer i Linux-terminalen innebär i stort sett att man skickar rätt signal till rätt process(er). Börja alltid ”snällt” med SIGTERM eller SIGHUP om syftet är att låta processen städa upp och avsluta sig självmant. Om inte det hjälper, eskalera till SIGKILL för att tvinga fram en avslutning. Lär dig känna igen de vanligaste signalnamnen och deras nummer. Använd verktyg som pgrep för att dubbelkolla vilka processer som kommer att påverkas innan du använder pkill eller killall. Och slutligen – var försiktig med kommandon som mass-terminerar processer (killall, fuser -k, eller skill -KILL) särskilt som administratör, så att du inte råkar stänga ner mer än avsett.

Med dessa verktyg och koncept i bagaget har du en god grund för att felsöka och kontrollera processer i Linux via terminalen. Lycka till med din processhantering!

Exempel

Här är 10 praktiska exempel på hur du kan använda ps, pidof, pstree, lsof, top/htop, samt de tidigare genomgångna verktygen (kill, killall, pkill, pgrep, fuser, skill) på olika sätt:

1. Hitta en process som drar mest CPU

ps -eo pid,%cpu,%mem,cmd --sort=-%cpu | head

Visar de mest CPU-intensiva processerna.

2. Avsluta ett specifikt program via PID

kill -9 4321

Tvingar bort processen med PID 4321 (t.ex. en låst applikation).

3. Hitta och avsluta alla Firefox-processer

killall firefox

Avslutar alla processer som heter ”firefox”.

4. Avsluta processer baserat på mönster i kommandoraden

pkill -f "python myscript.py"

Stänger processen som kör ett Python-skript med namnet myscript.py.

5. Lista alla PIDs för processer som heter ssh

pgrep -l ssh

Visar både PID och namn på alla ssh-relaterade processer.

6. Hitta vilken process som lyssnar på port 8080

sudo lsof -i :8080

Visar vilket program som kör på port 8080 (ofta webbserver eller testserver).

7. Avsluta processen som håller port 8080

sudo fuser -k 8080/tcp

Dödar processen som blockerar porten.

8. Visa processhierarkin som träd

pstree -p

Visar processer och deras PID i ett trädformat – bra för att förstå föräldra-/barnrelationer.

9. Se vad som händer i realtid

top

Startar realtidsövervakning av processer. Du kan trycka k för att döda en process direkt från top.

10. Hitta PID för en tjänst och visa dess detaljer

pidof nginx
ps -p $(pidof nginx) -o pid,ppid,user,%cpu,%mem,etime,cmd

Hämtar PID för nginx och visar sedan detaljer om processen.

kill [signal] PID
kill 1234            # SIGTERM (standard)
kill -9 1234         # SIGKILL (tvingande)
kill -HUP 5678       # läs om konfiguration

killall firefox       # SIGTERM
killall -9 firefox    # SIGKILL
killall -i firefox    # interaktiv bekräftelse

pkill chrome          # SIGTERM
pkill -9 chrome       # SIGKILL
pkill -x ssh          # exakt namnmatch
pkill -HUP nginx      # ladda om tjänst

pgrep ssh
pgrep -l ssh          # PID + namn
pgrep -a python       # hela kommandoraden
pgrep -u alice python # filter per användare

fuser /var/log/syslog
fuser 80/tcp
sudo fuser -k 8080/tcp     # döda process(er) på port

sudo skill -KILL -u bob   # döda alla processer för användare
skill -STOP -t pts/3      # pausa processer på terminal