103.5 Lecke 1
Tanúsítvány: |
LPIC-1 |
---|---|
Verzió: |
5.0 |
Témakör: |
103 GNU és Unix parancsok |
Fejezet: |
103.5 Folyamatok létrehozása, monitorozása és megszakítása |
Lecke: |
1/2 |
Bevezetés
Minden alkalommal, amikor meghívunk egy parancsot, egy vagy több folyamat (processz) indul el. Egy jól képzett rendszergazdának nemcsak létrehoznia kell a folyamatokat, hanem képesnek kell lennie arra is, hogy nyomon kövesse őket, és szükség esetén különböző típusú jelzéseket küldjön nekik. Ebben a leckében a feladatvezérlést és a processzek felügyeletét fogjuk megvizsgálni.
Job Control
A Jobok (munkák) olyan folyamatok, amelyeket interaktívan indítottak el egy terminálon keresztül, majd a háttérbe küldték őket, és még nem fejezték be a végrehajtásukat. A Linux-rendszerben lévő aktív jobokról (és azok állapotáról) a jobs
futtatásával tájékozódhatunk:
$ jobs
A fenti jobs
parancs nem adott ki semmilyen kimenetet, ami azt jelenti, hogy jelenleg nincsenek aktív jobok. Hozzuk létre az első jobunkat egy olyan parancs futtatásával, amelynek a végrehajtása némi időt vesz igénybe (a sleep
parancs a 60
paraméterrel), és — futás közben — nyomjuk meg a Ctrl+Z billentyűt:
$ sleep 60 ^Z [1]+ Stopped sleep 60
A parancs végrehajtása leállt (vagy inkább felfüggesztésre került), és a parancssor ismét elérhetővé vált. Másodszor is megnézhetjük a jobokat, és most már a felfüggesztett jobot fogjuk látni:
$ jobs [1]+ Stopped sleep 60
Nézzük meg, mit jelent ez a kimenet:
[1]
-
Ez a szám a job azonosítója, és felhasználható — egy százalékjellel (
%
) megelőzve — a job állapotának megváltoztatására azfg
,bg
éskill
segédprogramok segítségével (amint azt később be is mutatjuk). +
-
A plusz jel az aktuális, alapértelmezett jobot jelzi (vagyis az utolsót, amelyet felfüggesztettek vagy háttérbe küldtek). Az előző jobot mínusz jellel (
-
) jelöli. A többi korábbi jobot nem jelöli. Stopped
-
A job állapotának leírása.
sleep 60
-
A parancs vagy maga a job.
Az -l
kapcsolóval a jobok a processz azonosítóját (PID) is megjelenítik közvetlenül az állapot előtt:
$ jobs -l [1]+ 1114 Stopped sleep 60
A jobok további lehetséges kapcsolói a következők:
-n
-
Csak azokat a folyamatokat listázza, amelyek állapota megváltozott az utolsó értesítés óta. A lehetséges státuszok a következők:
Running
(futó, folyamatban lévő),Stopped
(megállt),Terminated
(terminált) vagyDone
(kész). -p
-
A processzek azonosítóinak listája.
-r
-
Csak a futó jobokat listázza.
-s
-
Csak a leállított (vagy felfüggesztett) jobokat listázza.
Note
|
Ne feledjük, egy jobnak van job ID-ja és process ID-ja (PID) is. |
A jobok specifikációja
A jobs
parancsnak, valamint más segédprogramoknak, mint például az fg
, bg
és kill
(amelyeket a következő szakaszban fogunk tárgyalni), szüksége van egy specifikációra (vagy jobspec
) ahhoz, hogy egy adott jobra hatni tudjon. Mint az imént láttuk, ez lehet — és általában ez is — a job azonosítója, amelyet %
előz meg. Azonban más specifikációk is lehetségesek. Nézzük meg ezeket:
%n
-
Az a job, amelynek az azonosítója
n
:$ jobs %1 [1]+ Stopped sleep 60
%str
-
Az a job, amelynek parancsa
str
-el kezdődik:$ jobs %sl [1]+ Stopped sleep 60
%?str
-
Az a job, amelynek a parancsa tartalmazza az
str
-t:$ jobs %?le [1]+ Stopped sleep 60
%+
vagy%%
-
Az aktuális job (az, amely a háttérben lett elindítva vagy az előtérből felfüggesztve):
$ jobs %+ [1]+ Stopped sleep 60
%-
-
Az előző job (ami
%+
volt, az aktuális előtti):$ jobs %- [1]+ Stopped sleep 60
A mi esetünkben, mivel csak egy job van, ez a jelenlegi és az előző is.
Job státusz: felfüggesztés, előtér és háttér
Ha egy job a háttérben van vagy felfüggesztésre került, három dolog közül bármit tehetünk vele:
-
Előtérbe hozni az
fg
-vel:$ fg %1 sleep 60
Az
fg
a megadott jobot előtérbe helyezi, és aktuális jobbá teszi. Most megvárhatjuk, amíg befejeződik, vagy újra leállíthatjuk a Ctrl+Z paranccsal, vagy megszüntethetjük a Ctrl+C paranccsal. -
Háttérbe küldeni a
bg
paranccsal:$ bg %1 [1]+ sleep 60 &
Ha a háttérben van, a job az
fg
paranccsal visszahozható az előtérbe, vagy megszüntethető (lsd. lentebb). Figyeljük meg az írásjelet (&
), ami azt jelenti, hogy a jobot a háttérbe küldtük. Ami azt illeti, az amperjelet használhatjuk arra is, hogy egy folyamatot közvetlenül a háttérben indítsunk el:$ sleep 100 & [2] 970
Az új job azonosítójával (
[2]
) együtt most már a folyamat azonosítóját is megkapjuk (970
). Most már mindkét feladat fut a háttérben:$ jobs [1]- Running sleep 60 & [2]+ Running sleep 100 &
Egy kicsivel később az első job befejezi a futást:
$ jobs [1]- Done sleep 60 [2]+ Running sleep 100 &
-
Terminálhatjuk a
SIGTERM
szignálon keresztül akill
segítségével:$ kill %2
Hogy biztosak legyünk benne, hogy a job terminálódott, futtassuk újra a
jobs
-t:$ jobs [2]+ Terminated sleep 100
Note
|
Ha nem adunk meg jobot, akkor az |
Önálló jobok: nohup
Az előző szakaszokban látott jobok mindegyike az őket előhívó felhasználó munkamenetéhez kapcsolódott. Ez azt jelenti, hogy ha a munkamenet megszűnik, a jobok is eltűnnek. Lehetőség van azonban a jobok munkamenetről való leválasztására, és ezek így a munkamenet bezárása után is futtathatók. Ez a nohup
(“no hangup”) paranccsal érhető el. A szintaxis a következő:
nohup COMMAND &
Ne feledjük, hogy a &
a folyamatot a háttérbe küldi, és felszabadítja a terminált, amelyben éppen dolgozunk!
Válasszuk le a ping localhost
háttérjobot az aktuális munkamenetről:
$ nohup ping localhost & [1] 1251 $ nohup: ignoring input and appending output to 'nohup.out' ^C
A kimenet mutatja a feladat azonosítóját ([1]
) és a PID-t (1251
), majd egy üzenetet a nohup.out
fájlról. Ez az alapértelmezett fájl, ahová az stdout
-ot és az stderr
-t mentjük. Most megnyomhatjuk a Ctrl+C billentyűkombinációt a parancssor felszabadításához, bezárhatjuk a munkamenetet, indíthatunk egy másikat root
-ként, és a tail -f
paranccsal ellenőrizhetjük, hogy a parancs fut-e, és a kimenet az alapértelmezett fájlba íródik-e:
$ exit logout $ tail -f /home/carol/nohup.out 64 bytes from localhost (::1): icmp_seq=3 ttl=64 time=0.070 ms 64 bytes from localhost (::1): icmp_seq=4 ttl=64 time=0.068 ms 64 bytes from localhost (::1): icmp_seq=5 ttl=64 time=0.070 ms ^C
Tip
|
Az alapértelmezett |
Ha meg akarjuk szüntetni a folyamatot (kill), meg kell adnunk a PID-jét:
# kill 1251
Folyamatok monitorozása
A folyamat (processz) vagy feladat (task) egy futó program példánya. Ez azt jelenti, hogy minden alkalommal új folyamatokat hozunk létre, amikor parancsokat írunk be a terminálba.
A watch
parancs periodikusan (alapértelmezés szerint 2 másodpercenként) végrehajt egy programot, és lehetővé teszi, hogy megfigyeljük a program kimenetének időbeli változását. Például a watch uptime
parancs beírásával nyomon követhetjük, hogyan változik a terhelés átlaga, ha több folyamatot futtatunk:
Every 2.0s: uptime debian: Tue Aug 20 23:31:27 2019 23:31:27 up 21 min, 1 user, load average: 0.00, 0.00, 0.00
A parancs addig fut, amíg meg nem szakad, ezért a Ctrl+C billentyűkombinációval kell leállítanunk. Kimenetként két sort kapunk: az első a watch
-nak felel meg, és megmondja, hogy milyen gyakran fog futni a parancs (Every 2.0s: uptime
), milyen parancsot/programot kell figyelni (uptime
), valamint a hostnevet és a dátumot (debian: Tue Aug 20 23:31:27 2019
). A második kimeneti sor az uptime-ról szól, és tartalmazza az időt (23:31:27
), azt, hogy mennyi ideje megy a rendszer (up 21 min
), az aktív felhasználók számát (1 user
) és a rendszer átlagos terhelését vagy a végrehajtásban vagy várakozó állapotban lévő folyamatok számát az elmúlt 1, 5 és 15 percben (load average: 0.00, 0.00, 0.00, 0.00
).
Hasonlóképpen ellenőrizhetjük a memóriahasználatot az új folyamatok létrehozásakor a watch free
paranccsal:
Every 2.0s: free debian: Tue Aug 20 23:43:37 2019 23:43:37 up 24 min, 1 user, load average: 0.00, 0.00, 0.00 total used free shared buff/cache available Mem: 16274868 493984 14729396 35064 1051488 15462040 Swap: 16777212 0 16777212
A watch
frissítési intervallumának módosításához használjuk az -n
vagy --interval
kapcsolókat és a másodpercek számát, csakúgy, mint ebben a példában:
$ watch -n 5 free
Mostantól a free
parancs 5 másodpercenként fog futni.
A uptime
, free
és watch
opciókkal kapcsolatos további információkért olvassuk el a man oldalaikat.
Note
|
Az |
Szignálok küldése a folyamatoknak: kill
Minden egyes folyamat egyedi processz azonosítóval vagy PID-del rendelkezik. Egy processz PID-jét a pgrep
paranccsal, majd a folyamat nevének megadásával lehet megtudni:
$ pgrep sleep 1201
Note
|
Egy folyamat azonosítója a |
A pgrep
-hez hasonlóan a pkill
parancs eliminál egy folyamatot a neve alapján:
$ pkill sleep [1]+ Terminated sleep 60
Ugyanazon folyamat több példányának megállításához a killall
parancs használható:
$ sleep 60 & [1] 1246 $ sleep 70 & [2] 1247 $ killall sleep [1]- Terminated sleep 60 [2]+ Terminated sleep 70
Mind a pkill
, mind a killall
ugyanúgy működik, mint a kill
, mivel egy befejező jelet küld a megadott folyamat(ok)nak. Ha nem adunk meg jelet, akkor az alapértelmezett SIGTERM
jelet küldjük. A kill
azonban csak egy feladat vagy egy folyamat azonosítóját veszi fel argumentumként.
A szignálokat a következő módokon lehet megadni:
-
Név:
$ kill -SIGHUP 1247
-
Szám:
$ kill -1 1247
-
Kapcsoló:
$ kill -s SIGHUP 1247
Ahhoz, hogy a kill
hasonlóan működjön, mint a pkill
vagy killall
(és megspóroljuk magunknak a PID-ek kiderítésének parancsát), használhatjuk a parancshelyettesítést:
$ kill -1 $(pgrep sleep)
Mint azt már tudjuk, az alternatív szintaxis a kill -1 `pgrep sleep`
.
Tip
|
Az összes |
top
és ps
A folyamatok monitorozásában két felbecsülhetetlen értékű eszköz a top
és a ps
. Míg az előbbi dinamikusan, az utóbbi statikusan állít elő kimenetet. Mindenesetre mindkettő kiváló segédprogram ahhoz, hogy átfogó képet kapjunk a rendszerben lévő összes folyamatról.
A top
használata
A top
használatához csak írjuk be, hogy top
:
$ top top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14 Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie %Cpu(s): 0,0 us, 0,3 sy, 0,0 ni, 99,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 436 carol 20 0 42696 3624 3060 R 0,7 0,4 0:00.30 top 4 root 20 0 0 0 0 S 0,3 0,0 0:00.12 kworker/0:0 399 root 20 0 95204 6748 5780 S 0,3 0,7 0:00.22 sshd 1 root 20 0 56872 6596 5208 S 0,0 0,6 0:01.29 systemd 2 root 20 0 0 0 0 S 0,0 0,0 0:00.00 kthreadd 3 root 20 0 0 0 0 S 0,0 0,0 0:00.02 ksoftirqd/0 5 root 0 -20 0 0 0 S 0,0 0,0 0:00.00 kworker/0:0H 6 root 20 0 0 0 0 S 0,0 0,0 0:00.00 kworker/u2:0 7 root 20 0 0 0 0 S 0,0 0,0 0:00.08 rcu_sched 8 root 20 0 0 0 0 S 0,0 0,0 0:00.00 rcu_bh 9 root rt 0 0 0 0 S 0,0 0,0 0:00.00 migration/0 10 root 0 -20 0 0 0 S 0,0 0,0 0:00.00 lru-add-drain (...)
A top
lehetővé teszi a felhasználó számára az interakciót. Alapértelmezés szerint a kimenetet az egyes folyamatok által felhasznált CPU-idő százalékos aránya szerint rendezi csökkenő sorrendben. Ez a viselkedés a következő billentyűkkel módosítható a top
-ban:
M
-
Rendezés memóriahasználat alapján.
N
-
Rendezés a folyamat azonosítószáma (ID) alapján.
T
-
Rendezés futási idő alapján.
P
-
Rendezés a CPU használat százalékos aránya alapján.
Tip
|
A csökkenő/növekvő sorrend közötti váltáshoz csak nyomjuk meg az |
További érdekes kulcsok a top
-pal való interakcióhoz:
?
orh
-
Segítség.
k
-
Egy folyamat terminálása. A
top
várja a terminálandó folyamatPID
azonosítóját, valamint a küldendő szignált (alapértelmezés szerintSIGTERM
vagy15
). r
-
Egy folyamat prioritásának módosítása (
renice
). Atop
várja anice
értéket. A lehetséges értékek -20 és 19 között mozognak, de csak a szuperfelhasználó (root
) állíthatja be olyan értékre, amely negatív vagy alacsonyabb az aktuálisnál. u
-
Egy adott felhasználó folyamatainak listázása (alapértelmezés szerint az összes felhasználó folyamatai megjelennek).
c
-
Megjeleníti a programok abszolút elérési útvonalait, és különbséget tesz a felhasználói és a kernelspace folyamatok között (szögletes zárójelben).
V
-
A folyamatok erdő/hierarchia nézete.
t
ésm
-
A CPU- és memóriaértékek megjelenésének megváltoztatása egy négylépcsős ciklusban: az első két megnyomásnál progress barok jelennek meg, a harmadik elrejti a progress bart, a negyedik pedig visszahozza azt.
W
-
A konfigurációs beállítások mentése a
~/.toprc
-be.
Tip
|
A |
A top
kimenetének magyarázata
A top
kimenete két területre van osztva: az összefoglaló területre (summary area) és a feladat területre (task area).
A top
összefoglaló területe
Az összefoglaló terület az öt felső sorból áll, és a következő információkat tartalmazza:
-
top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14
-
aktuális idő (24 órás formátumban):
11:20:29
-
uptime (mióta fut a rendszer):
up 2:21
-
a bejelentkezett felhasználók száma és a CPU átlagos terhelése az elmúlt 1, 5, illetve 15 percben:
load average: 0,11, 0,20, 0,14
-
-
Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie
(információk a folyamatokról)-
az aktív módú processzek száma:
73 total
-
running (amelyek épp futtatás alatt állnak):
1 running
-
sleeping (amelyek várnak a futtatás folytatására):
72 sleeping
-
stopped (megállítva egy job szignál által):
0 stopped
-
zombie (amelyek befejezték a futást, de még mindig a szülő processzre várnak, hogy eltávolítsa őket a táblából):
0 zombie
-
-
%Cpu(s): 0,0 us, 0,3 sy, 0,0 ni, 99,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st
(a CPU-idő százalékos aránya)-
felhasználói processzek:
0,0 us
-
rendszer/kernel folyamatok:
0,4 sy
-
folyamatok nice értékre állítva — minél szebb az érték, annál alacsonyabb a prioritás:
0,0 ni
-
semmi — idle CPU-idő:
99,7 id
-
I/O műveletekre váró processzek:
0,0 wa
-
hardveres megszakításokat kiszolgáló folyamatok - perifériák, amelyek figyelmet igénylő jeleket küldenek a processzornak.:
0,0 hi
-
szoftveres megszakításokat kiszolgáló folyamatok:
0,0 si
-
más virtuális gépek feladatait kiszolgáló folyamatok egy virtuális környezetben, így időt lopva:
0,0 st
-
-
KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache
(memóriainformáció kilobájtokban)-
a memória teljes mennyisége:
1020332 total
-
használatlan memória:
909492 free
-
használt memória:
38796 used
-
a pufferelt és gyorsítótárazott memória a túlzott lemezelérés elkerülése érdekében:
72044 buff/cache
Vegyük észre, hogy a
total
a másik három érték —free
,used
ésbuff/cache
— összege (durván 1 GB a mi esetünkben).
-
-
KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem
(swap információ kilobájtokban)-
a swap terület teljes mérete:
1046524 total
-
a használatlan swap mérete:
1046524 free
-
használt swap terület:
0 used
-
a swap-memória mennyisége, amelyet a folyamatok számára ki lehet osztani anélkül, hogy további lapozást okozna:
873264 avail Mem
-
A top
feladat területe: mezők és oszlopok
Az összefoglaló terület alatt található a feladat terület, amely egy sor mezőt és oszlopot tartalmaz, amelyek a futó folyamatokra vonatkozó információkat jelentik:
PID
-
Processz azonosító.
USER
-
A felhasználó, aki kiadta a parancsot, ami generálta a processzt.
PR
-
A processz prioriítása a kernel számára.
NI
-
A folyamat nice értéke. Az alacsonyabb értékek magasabb prioritást élveznek, mint a magasabbak.
VIRT
-
A folyamat által használt memória teljes mennyisége (beleértve a swapot is).
RES
-
A processz által használt RAM memória.
SHR
-
A folyamat más folyamatokkal megosztott memóriája.
S
-
A processz státusza. A lehetséges értékek közé tartoznak:
S
(megszakítható sleep (alvó) — egy eseményre vár a befejezéshez),R
(runnable (futtatható) — vagy épp végrehajtás alatt van, vagy a végrehajtásra váró sorban van) vagyZ
(zombie — befejezett gyermekfolyamatok, amelyek adatszerkezeteit még nem távolították el a folyamat táblából). %CPU
-
A processz által használt CPU százalékos aránya.
%MEM
-
A processz által használta RAM százalékos aránya, azaz a
RES
érték százalékban kifejezve. TIME+
-
A folyamat tevékenységének teljes időtartama.
COMMAND
-
A parancs/program neve, ami generálta a folyamatot.
Folyamatok statikus megtekintése: ps
Ahogy fentebb említettük, a ps
a folyamatok pillanatfelvételét (snapshot) mutatja. Ha az összes terminállal (tty) rendelkező folyamatot látni szeretnénk, írjuk be a ps a
parancsot:
$ ps a PID TTY STAT TIME COMMAND 386 tty1 Ss+ 0:00 /sbin/agetty --noclear tty1 linux 424 tty7 Ssl+ 0:00 /usr/lib/xorg/Xorg :0 -seat seat0 (...) 655 pts/0 Ss 0:00 -bash 1186 pts/0 R+ 0:00 ps a (...)
A ps
kapcsolóinak szintaxisa és kimenete
A kapcsolókat illetően a ps
három különböző stílust fogadhat el: BSD, UNIX és GNU. Nézzük meg, hogyan működnének ezek a stílusok, ha egy adott folyamat azonosítójáról adunk információt:
- BSD
-
A kapcsolóknál nincs kötőjel:
$ ps p 811 PID TTY STAT TIME COMMAND 811 pts/0 S 0:00 -su
- UNIX
-
A kapcsolóknál van kötőjel:
$ ps -p 811 PID TTY TIME CMD 811 pts/0 00:00:00 bash
- GNU
-
A kapcsolóknál két kötőjel van:
$ ps --pid 811 PID TTY TIME CMD 811 pts/0 00:00:00 bash
Mindhárom esetben a ps
arról a folyamatról ad információt, amelynek PID
-je a 811
— ebben az esetben a bash
.
Hasonlóképpen használhatjuk a ps
parancsot egy adott felhasználó által indított folyamatok megkeresésére:
-
ps U carol
(BSD) -
ps -u carol
(UNIX) -
ps --user carol
(GNU)
Ellenőrizzük a carol
által indított processzeket:
$ ps U carol PID TTY STAT TIME COMMAND 811 pts/0 S 0:00 -su 898 pts/0 R+ 0:00 ps U carol
Két folyamatot indított el: bash
(-su
) és ps
(ps U carol
). A STAT
oszlop árulja el a folyamatok státuszát (lsd. lentebb).
A ps
lehetőségeit egyesítve a legjobbat hozhatjuk ki belőle. Egy nagyon hasznos parancs (amely a top
parancshoz hasonló kimenetet ad) a ps aux
(BSD stílusban). Ebben az esetben az összes shell (nem csak az aktuális) folyamatai megjelennek. A kapcsolók jelentése a következő:
a
-
Megmutatja azokat a folyamatokat, amelyek egy
tty
-hez vagy terminálhoz kapcsolódnak. u
-
Felhasználó-orientált formátum megjelenítése.
x
-
Megjeleníti azokat a folyamatokat, amelyek nem kapcsolódnak egy
tty
-hez vagy terminálhoz.
$ ps aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.1 204504 6780 ? Ss 14:04 0:00 /sbin/init root 2 0.0 0.0 0 0 ? S 14:04 0:00 [kthreadd] root 3 0.0 0.0 0 0 ? S 14:04 0:00 [ksoftirqd/0] root 5 0.0 0.0 0 0 ? S< 14:04 0:00 [kworker/0:0H] root 7 0.0 0.0 0 0 ? S 14:04 0:00 [rcu_sched] root 8 0.0 0.0 0 0 ? S 14:04 0:00 [rcu_bh] root 9 0.0 0.0 0 0 ? S 14:04 0:00 [migration/0] (...)
Nézzük az oszlopok értelmezését:
USER
-
A processz tulajdonosa.
PID
-
A processz azonosítója.
%CPU
-
A CPU-használat százalékos aránya.
%MEM
-
A fizikiális memória-használat százalékos aránya.
VSZ
-
A processz virtuális memóriája KiB-ban.
RSS
-
A processz által használt nem-lapozható fizikális memória KiB-ban.
TT
-
A processzt kontrolálló terminál (
tty
). STAT
-
A folyamat állapotát jelző kód. Az
S
,R
ésZ
(amelyeket atop
kimenetének leírásakor láttunk) mellett a következő értékek lehetségesek:D
(megszakítás nélküli alvás — általában I/O-ra várva),T
(leállítva — általában egy szignál által). Néhány extra módosító a következő:<
(magas prioritású — nem"kedves`" (nice) más folyamatokkal), `N
(alacsony prioritású —"kedves`" más folyamatokkal), vagy `+
(az előtérben lévő folyamatcsoportban). STARTED
-
A processz kezdetének időpontja.
TIME
-
Összesített CPU-idő.
COMMAND
-
Parancs, ami elindította a folyamatot.
Gyakorló feladatok
-
Az
oneko
egy kedves, vicces program, amely egy macskát jelenít meg, amely az egérkurzort üldözi. Ha még nincs telepítve, telepítsük a csomagkezelő segítségével! Ezt fogjuk használni a job kontroll (job control) tanulmányozására.-
Indítsuk el a programot! Hogyan kell ezt megtenni?
-
Mozgassuk az egérkurzort, hogy lássuk, ahogy kergeti a macska. Most függesszük fel a processzt. Hogyan kell ezt megtenni? Mi a kimenet?
-
Nézzük meg, hogy mennyi jobunk van. Mit kell beírnunk? Mi a kimenet?
-
Most pedig küldjük a háttérbe a job azonosítójának megadásával. Mi a kimenet? Honnan tudhatjuk, hogy a job a háttérben fut?
-
Végül termináljuk a jobot az ID megadásával. Mit kell beírnunk?
-
-
Fedezzük fel az Apache HTTPD web server (
apache2
) által indított összes folyamat PID-jeit két különböző paranccsal: -
Fejezzük be az összes
apache2
folyamatot a PID-jük használata nélkül, két különböző paranccsal: -
Tegyük fel, hogy az
apache2
összes példányát meg kell szüntetnünk, és nincs időnk kideríteni, hogy mi a PID-jük. Hogyan tudnánk ezt elérni akill
használatával az alapértelmezettSIGTERM
szignállal egy sorban: -
Indítsuk el a
top
-ot és tegyük meg a következőket:-
Nézzük meg a processzek forest (erdő) nézetét:
-
A folyamatok teljes útvonalának megjelenítése, megkülönböztetve a felhasználói tér és a kerneltér között:
-
-
A
ps
használatával jelenítsük meg az Apache HTTPD web server felhasználó által indított összes folyamatot (www-data
):-
BSD szintaxis:
-
UNIX szintaxis:
-
GNU szintaxis:
-
Gondolkodtató feladatok
-
A
SIGHUP
szignál bizonyos daemonok újraindítására használható. Az Apache HTTPD web server esetében például aSIGHUP
elküldése a szülőfolyamatnak (amelyet azinit
indít el) megöli a gyermekfolyamatokat. A szülő azonban újraolvassa a konfigurációs fájljait, újra megnyitja a naplófájlokat, és új gyermekeket indít. Végezzük el a következő feladatokat:-
Indítsuk el a webszervert:
-
Tudjuk meg a szülőprocessz PID-jét:
-
Az Apache HTTPD webkiszolgáló újraindítása a
SIGHUP
szignál elküldésével a szülőfolyamatnak: -
Ellenőrizzük, hogy a szülő nem terminálódott-e, és születtek-e új gyermekek:
-
-
Bár kezdetben statikus, a
ps
kimenete aps
és awatch
kombinálásával dinamikussá fordítható. Monitorozzuk az Apache HTTPD web server új kapcsolatait! Az alább leírt feladatok elvégzése előtt ajánlott elolvasni aMaxConnectionsPerChild
direktíva leírását a Apache MPM Common Directives oldalon.-
Adjuk hozzá a
MaxConnectionsPerChild
direktívát1
értékkel azapache2
konfigurációs fájljához — Debian és Debian-alapú rendszerek esetén ez az/etc/apache2/apache2.conf
fájl; CentOS család esetén az/etc/httpd/conf/httpd.conf
. Ne felejtsük el újraindítani azapache2
-t, hogy a változtatások életbe lépjenek! -
Írjunk be egy parancsot, ami használja a
watch
,ps
ésgrep
parancsokatapache2
kapcsolatok esetén! -
Nyissuk meg a böngészőt vagy használjunk egy parancssori böngészőt, mint például a
lynx
, hogy létrehozzuk a kapcsolatot a webszerverrel az IP-címén keresztül! Mit figyelhetünk meg awatch
kimenetén?
-
-
Amint azt már megtanultauk, a
top
alapértelmezés szerint a CPU-használat százalékos aránya szerint rendezi a feladatokat csökkenő sorrendben (a magasabb értékek vannak felül). Ez a viselkedés módosítható azM
(memóriahasználat),N
(folyamat egyedi azonosítója),T
(futási idő) ésP
(CPU-idő százalékos aránya) interaktív kulcsokkal. A feladatlistát azonban atop
-o
kapcsolóval történő elindításával is tetszés szerint rendezhetjük (további információkért nézzük meg a topman
oldalát). Most hajtsuk végre a következő feladatokat:-
Indítsuk el a
top
-ot, hogy a feladatok memóriahasználat szerint legyenek rendezve: -
Ellenőrizzük a memória oszlop kiemelésével, hogy a megfelelő parancsot írtuk-e be:
-
-
A
ps
szintén rendelkezik egyo
kapcsolóval, amellyel megadhatjuk a megjeleníteni kívánt oszlopokat. Vizsgáljuk meg ezt a lehetőséget, és végezzük el a következő feladatokat:-
Indítsuk el a
ps
-t úgy, hogy csak a user, a percentage of memory used, a percentage of CPU time used és a full command információk jelenjenek meg: -
Most indítsuk el a
ps
-t úgy, hogy csak a felhasználó adatai és az általa használt programok neve jelenjen meg:
-
Összefoglalás
Ebben a leckében a jobok-ról és a job control-ról tanultunk. Fontos tények és fogalmak, amelyeket szem előtt kell tartanunk:
-
A jobok olyan folyamatok, amelyek a háttérbe kerülnek.
-
A process ID mellett a jobok létrehozásukkor egy job ID azonosítót is kapnak.
-
A jobok vezérléséhez egy specifikációra (
jobspec
) van szükség. -
A jobok előtérbe hozhatók, háttérbe küldhetők, felfüggeszthetők és megszüntethetők (vagy terminálhatók).
-
Egy job leválasztható a terminálról és a munkamenetről, amelyben létrehozták.
Hasonlóképpen, a folyamatok és a folyamatfelügyelet fogalmát is megvitattuk. A legfontosabb gondolatok a következők:
-
A folyamatok futó programok.
-
A folyamatok monitorozhatók.
-
Különböző segédprogramok segítségével megtudhatjuk a folyamatok process ID azonosítóját, valamint szignálokat küldhetünk nekik, hogy befejezzük őket.
-
A szignálokat meg lehet adni névvel (pl.
-SIGTERM
), számmal (pl.-15
) vagy kapcsolóval (pl.-s SIGTERM
). -
A
top
és aps
nagyon hatékonyak, ha folyamatok megfigyeléséről van szó. Az előbbi kimenete dinamikus és folyamatosan frissül; ezzel szemben aps
statikusan mutatja a kimenetet.
A leckében használt parancsok:
jobs
-
Aktív jobok és állapotuk megjelenítése.
sleep
-
Késleltetés egy meghatározott ideig.
fg
-
Job előtérbe hozása.
bg
-
Job háttérbe küldése.
kill
-
Job terminálása.
nohup
-
Job leválasztása a munkamenetről/terminálról.
exit
-
Az aktuális shell bezárása.
tail
-
A fájl legfrissebb sorainak megjelenítése.
watch
-
Egy parancs ismételt futtatása (alapértelmezés szerint 2 másodperces ciklus).
uptime
-
Megjeleníti, hogy mióta fut a rendszer, az aktuális felhasználók számát és a rendszer átlagos terhelését.
free
-
A memórihasználat megjelenítése.
pgrep
-
A folyamat azonosítójának keresése a név alapján.
pidof
-
A folyamat azonosítójának keresése a név alapján.
pkill
-
Szignál küldése a folyamatnak a neve alapján.
killall
-
Processz(ek) terminálása a név alapján.
top
-
Linux folyamatok megjelenítése.
ps
-
A jelenlegi folyamatok pillanatfelvétele.
Válaszok a gyakorló feladatokra
-
Az
oneko
egy kedves, vicces program, amely egy macskát jelenít meg, amely az egérkurzort üldözi. Ha még nincs telepítve, telepítsük a csomagkezelő segítségével! Ezt fogjuk használni a munkairányítás tanulmányozására.-
Indítsuk el a programot! Hogyan kell ezt megtenni?
Az
oneko
beírásával a terminálba. -
Mozgassuk az egérkurzort, hogy lássuk, ahogy kergeti a macska. Most függesszük fel a processzt. Hogyan kell ezt megtenni? Mi a kimenet?
A
Ctrl+z
billentyűkombináció lenyomásával:[1]+ Stopped oneko
-
Nézzük meg, hogy jobunk van. Mit kell beírnunk? Mi a kimenet?
$ jobs [1]+ Stopped oneko
-
Most pedig küldjük a háttérbe a job azonosítójának megadásával. Mi a kimenet? Honnan tudhatjuk, hogy a job a háttérben fut?
$ bg %1 [1]+ oneko &
A macska ismét mozog.
-
Végül termináljuk a jobot az ID megadásával. Mit kell beírnunk?
$ kill %1
-
-
Fedezzük fel az Apache HTTPD web server (
apache2
) által indított összes folyamat PID-jét két különböző paranccsal:$ pgrep apache2
vagy
$ pidof apache2
-
Fejezzük be az összes
apache2
folyamatot a PID-jük használata nélkül, két különböző paranccsal:$ pkill apache2
vagy
$ killall apache2
-
Tegyük fel, hogy az
apache2
összes példányát meg kell szüntetnünk, és nincs időnk kideríteni, hogy mi a PID-jük. Hogyan tudnánk ezt elérni akill
használatával az alapértelmezettSIGTERM
jellel egy sorban:$ kill $(pgrep apache2) $ kill `pgrep apache2`
vagy
$ kill $(pidof apache2) $ kill `pidof apache2`
NoteMivel a
SIGTERM
(15
) az alapértelmezett jel, nem szükséges semmilyen opciót átadni akill
-nek. -
Indítsuk el a
top
-ot és tegyük meg a következőket:-
Nézzük meg a processzek forest (erdő) nézetét:
Nyomjuk meg a
V
-t. -
A folyamatok teljes útvonalának megjelenítése, megkülönböztetve a felhasználói tér és a kerneltér között:
Nyomjuk meg a
c
-t.
-
-
A
ps
használatával jelenítsük meg az Apache HTTPD web server felhasználó által indított összes folyamatot (www-data
):-
BSD szintaxis:
$ ps U www-data
-
UNIX szintaxis:
$ ps -u www-data
-
GNU szintaxis:
$ ps --user www-data
-
Válaszok a gondolkodtató feladatokra
-
A
SIGHUP
jel bizonyos daemonok újraindítására használható. Az Apache HTTPD web server esetében például aSIGHUP
elküldése a szülőfolyamatnak (amelyet azinit
indít el) megöli a gyermekfolyamatokat. A szülő azonban újraolvassa a konfigurációs fájljait, újra megnyitja a naplófájlokat, és új gyermekeket indít. Végezzük el a következő feladatokat:-
Indítsuk el a webszervert:
$ sudo systemctl start apache2
-
Tudjuk meg a szülőprocessz PID-jét:
$ ps aux | grep apache2
A szülői folyamat a
root
felhasználó által indított folyamat. A mi esetünkben az, amelynek PID azonosítója1653
. -
Az Apache HTTPD webkiszolgáló újraindítása a
SIGHUP
jel elküldésével a szülőfolyamatnak:$ kill -SIGHUP 1653
-
Ellenőrizzük, hogy a szülő nem terminálódott-e, és születtek-e új gyermekek:
$ ps aux | grep apache2
Most a szülő
apache2
folyamatot kell látnunk két új gyermekével együtt.
-
-
Bár kezdetben statikus, a
ps
kimenete aps
és awatch
kombinálásával dinamikussá fordítható. Monitorozzuk az Apache HTTPD web server új kapcsolatait! Az alább leírt feladatok elvégzése előtt ajánlott elolvasni aMaxConnectionsPerChild
direktíva leírását a Apache MPM Common Directives oldalon.-
Adjuk hozzá a
MaxConnectionsPerChild
direktívát1
értékkel azapache2
konfigurációs fájljához — Debian és Debian-alapú rendszerek esetén ez az/etc/apache2/apache2.conf
fájl; CentOS család esetén az/etc/httpd/conf/httpd.conf
. Ne felejtsük el újraindítani azapache2
-t, hogy a változtatások életbe lépjenek!A konfigurációs fájlhoz a
MaxConnectionsPerChild 1
sort kell hozzáadnunk. A webszerver újraindításának egy módja:sudo systemctl restart apache2
. -
Írjunk be egy parancsot, ami használja a
watch
,ps
ésgrep
parancsokatapache2
kapcsolatok esetén!$ watch 'ps aux | grep apache2'
vagy
$ watch "ps aux | grep apache2"
-
Nyissuk meg a böngészőt vagy használjunk egy parancssori böngészőt, mint például a
lynx, hogy létrehozzuk a kapcsolatot a webszerverrel az IP-címén keresztül! Mit figyelhetünk meg a `watch
kimenetén?A
www-data
által tulajdonolt gyermek-processzek egyike eltűnik.
-
-
Amint azt már megtanultuk, a
top
alapértelmezés szerint a CPU-használat százalékos aránya szerint rendezi a feladatokat csökkenő sorrendben (a magasabb értékek vannak felül). Ez a viselkedés módosítható azM
(memóriahasználat),N
(folyamat egyedi azonosítója),T
(futási idő) ésP
(CPU-idő százalékos aránya) interaktív kulcsokkal. A feladatlistát azonban atop
-o
kapcsolóval történő elindításával is tetszés szerint rendezhetjük (további információkért nézzük meg a topman
oldalát). Most hajtsuk végre a következő feladatokat:-
Indítsuk el a
top
-ot, hogy a feladatok memóriahasználat szerint legyenek rendezve:$ top -o %MEM
-
Ellenőrizzük a memória oszlop kiemelésével, hogy a megfelelő parancsot írtuk-e be:
Nyomjuk meg az
x
-et.
-
-
A
ps
szintén rendelkezik egyo
kapcsolóval, amellyel megadhatjuk a megjeleníteni kívánt oszlopokat. Vizsgáljuk meg ezt a lehetőséget, és végezzük el a következő feladatokat:-
Indítsuk el a
ps
-t úgy, hogy csak a user, a percentage of memory used, a percentage of CPU time used és a full command információk jelenjenek meg:$ ps o user,%mem,%cpu,cmd
-
Most indítsuk el a
ps
-t úgy, hogy csak a felhasználó adatai és az általa használt programok neve jelenjen meg:$ ps o user,comm
-