a) Tastați comanda și observați cu atenție textul apărut în terminal ca urmare a rulării acesteia:

ps

La ce se referă liniile apărute? R: Se afișează procesele deschise din terminalul curent. Apar doar două procese: shell-ul bash și procesul ps:

student@uso:~$ ps
  PID TTY          TIME CMD
 3821 pts/1    00:00:00 bash
 3877 pts/1    00:00:00 ps

b) Adăugați argumentele -ef comenzii anterioare.

ps -ef

Se vor afișa toate procesele ce rulează în sistem:

student@uso:~$ ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 19:37 ?        00:00:00 /sbin/init
root         2     0  0 19:37 ?        00:00:00 [kthreadd]
root         3     2  0 19:37 ?        00:00:00 [ksoftirqd/0]
root         6     2  0 19:37 ?        00:00:00 [migration/0]
root         7     2  0 19:37 ?        00:00:00 [watchdog/0]
root         8     2  0 19:37 ?        00:00:00 [migration/1]
root        10     2  0 19:37 ?        00:00:00 [ksoftirqd/1]
root        12     2  0 19:37 ?        00:00:00 [watchdog/1]
root        13     2  0 19:37 ?        00:00:00 [cpuset]
root        14     2  0 19:37 ?        00:00:00 [khelper]
root        15     2  0 19:37 ?        00:00:00 [kdevtmpfs]
root        16     2  0 19:37 ?        00:00:00 [netns]
root        18     2  0 19:37 ?        00:00:00 [sync_supers]
[...]

c) Folosiți man ps pentru a găsi descrierea celor două argumente de mai sus. Folosiți opțiunea de cautare din man (/-e) pentru a ajunge mai rapid la descrierea dorită:

-e              Select all processes. Identical to -A.
-f              Do full-format listing.

d) În output-ul comenzii de mai sus, ce reprezintă câmpurile afișate? Folosiți man ps împreună cu opțiunea de căutare pentru a găsi descrierea câmpurilor afișate.

uid        UID     see euid. (alias euid).
euid       EUID    effective user ID (alias uid).
pid        PID     process ID number of the process.
ppid       PPID    parent process ID.
c          C       processor utilization. Currently, this is the integer value of the percent usage over the lifetime of the process.
start_time START   starting time or date of the process.
tname      TTY     controlling tty (terminal).
time       TIME    cumulative CPU time, "[DD-]HH:MM:SS" format.
ucmd       CMD     see comm. 
comm       COMMAND command name (only the executable name). 

e) Informații detaliate despre procesele care ruleaza în sistem pot afișate și folosind argumentele aux. În acest caz argumentele comenzii ps nu sunt prefixate de caracterul -. Este cazul argumentelor date în format BSD.

student@uso:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  24456  2416 ?        Ss   19:37   0:00 /sbin/init
root         2  0.0  0.0      0     0 ?        S    19:37   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    19:37   0:00 [ksoftirqd/0]
root         6  0.0  0.0      0     0 ?        S    19:37   0:00 [migration/0]
root         7  0.0  0.0      0     0 ?        S    19:37   0:00 [watchdog/0]
root         8  0.0  0.0      0     0 ?        S    19:37   0:00 [migration/1]
root        10  0.0  0.0      0     0 ?        S    19:37   0:00 [ksoftirqd/1]
root        12  0.0  0.0      0     0 ?        S    19:37   0:00 [watchdog/1]
root        13  0.0  0.0      0     0 ?        S<   19:37   0:00 [cpuset]
root        14  0.0  0.0      0     0 ?        S<   19:37   0:00 [khelper]
root        15  0.0  0.0      0     0 ?        S    19:37   0:00 [kdevtmpfs]
root        16  0.0  0.0      0     0 ?        S<   19:37   0:00 [netns]
root        18  0.0  0.0      0     0 ?        S    19:37   0:00 [sync_supers]
root        19  0.0  0.0      0     0 ?        S    19:37   0:00 [bdi-default]
root        20  0.0  0.0      0     0 ?        S<   19:37   0:00 [kintegrityd]
root        21  0.0  0.0      0     0 ?        S<   19:37   0:00 [kblockd]
root        22  0.0  0.0      0     0 ?        S<   19:37   0:00 [ata_sff]

Există 3 formate pentru opțiunile unei comenzi:

• formatul lung (de exemplu –help)
• formatul GNU (ca în ls -l)
• formatul BSD (ps aux)

f) Puteți vedea semnificația argumentelor mai des folosite pentru ps, în toate cele 3 formate, rulând

ps --help

sau o comandă cu un argument nevalid.

student@uso:~$ ps --help
********* simple selection *********  ********* selection by list *********
-A all processes                      -C by command name
-N negate selection                   -G by real group ID (supports names)
-a all w/ tty except session leaders  -U by real user ID (supports names)
-d all except session leaders         -g by session OR by effective group name
-e all processes                      -p by process ID
T  all processes on this terminal     -s processes in the sessions given
a  all w/ tty, including other users  -t by tty
g  OBSOLETE -- DO NOT USE             -u by effective user ID (supports names)
r  only running processes             U  processes for specified users
x  processes w/o controlling ttys     t  by tty
*********** output format **********  *********** long options ***********
-o,o user-defined  -f full            --Group --User --pid --cols --ppid
-j,j job control   s  signal          --group --user --sid --rows --info
-O,O preloaded -o  v  virtual memory  --cumulative --format --deselect
-l,l long          u  user-oriented   --sort --tty --forest --version
-F   extra full    X  registers       --heading --no-heading --context
                    ********* misc options *********
-V,V  show version      L  list format codes  f  ASCII art forest
-m,m,-L,-T,H  threads   S  children in sum    -y change -l format
-M,Z  security data     c  true command name  -c scheduling class
-w,w  wide output       n  numeric WCHAN,UID  -H process hierarchy

g) Informațiile oferite de utilitarul ps se pot filtra specificând un set de argumente. Spre exemplu, pentru a afișa doar procesele deținute de utilizatorul student, rulați comanda

student@uso:~$ ps -u student
  PID TTY          TIME CMD
 2038 ?        00:00:00 x-session-manag
 2086 ?        00:00:00 ssh-agent
 2089 ?        00:00:00 dbus-launch
 2090 ?        00:00:01 dbus-daemon
 2154 ?        00:00:00 start_kdeinit
 2155 ?        00:00:00 kdeinit4
 2156 ?        00:00:00 klauncher
 2158 ?        00:00:04 kded4
 2163 ?        00:00:00 bluedevil-helpe
 2165 ?        00:00:00 obex-data-serve
 2337 ?        00:00:00 bluedevil-monol
 2339 ?        00:00:00 kglobalaccel

Alternativ puteți rula și

student@uso:~$ ps U student
  PID TTY      STAT   TIME COMMAND
 2038 ?        Ss     0:00 /bin/sh /usr/bin/x-session-manager
 2086 ?        Ss     0:00 /usr/bin/ssh-agent /usr/bin/dbus-launch --exit-with-session x-session-manager
 2089 ?        S      0:00 /usr/bin/dbus-launch --exit-with-session x-session-manager
 2090 ?        Ss     0:01 //bin/dbus-daemon --fork --print-pid 5 --print-address 7 --session
 2154 ?        S      0:00 /usr/lib/kde4/libexec/start_kdeinit +kcminit_startup
 2155 ?        Ss     0:00 kdeinit4: kdeinit4 Running...                  
 2156 ?        S      0:00 kdeinit4: klauncher [kdeinit] --fd=9           
 2158 ?        Sl     0:04 kdeinit4: kded4 [kdeinit]                      
 2163 ?        S      0:00 /usr/bin/bluedevil-helper
 2165 ?        S      0:00 /usr/bin/obex-data-server --no-daemon 
 2337 ?        S      0:00 /usr/bin/bluedevil-monolithic
 2339 ?        S      0:00 /usr/bin/kglobalaccel
 2341 ?        Sl     0:00 /usr/bin/kwalletd
 2344 ?        S      0:00 /usr/bin/kactivitymanagerd

a) Utilitarul ps poate fi folosit pentru a “face o poză” proceselor sistemului la un anumit moment de timp. Pentru a vizualiza informații în timp real, folosim top. Rulați comanda

top

Se vor afișa primele procese sortate după gradul de folosire al procesorului.

b) Parametrii acestei comenzi sunt similari comenzii ps. Folosiți top pentru a lista doar procesele utilizatorului student:

top -u student

c) Dacă tastați h în timp ce top rulează, se afișează un ecran informativ in care sunt listate comenzile interactive acceptate de top. De exemplu, dacă tastați u puteți selecta interactiv ce utilizatori să fie afișați.

Porniți o instanță nouă de top și afișați procesele utilizatorului root.

a) Utilitarul pstree afișează sub formă arborescentă toate procesele existente în momentul lansării lui. Utilizând

pstree

identificați primul proces creat la lansarea sistemului de operare (rădăcina arborelui).

b) Identificați PID-ul acestui proces folosind ps. Folosiți argumentul -C pentru a specifica numele executabilului init.

a) Pentru a afla cât timp a rulat un anumit proces, se poate folosi comanda time. Rulați

time sleep 3

.

b) Output-ul comenzii time conține trei valori de timp: real, user, sys. Folosiți pagina de man pentru a afla ce reprezinta fiecare valoare.

To run the command `ls -Fs' and show just the user, system, and total time:
            time -f "%E real,%U user,%S sys" ls -Fs
[...]
E      Elapsed real (wall clock) time used by the process, in [hours:]minutes:seconds.
U      Total number of CPU-seconds that the process used directly (in user mode), in seconds.
S      Total number of CPU-seconds used by the system on behalf of the process (in kernel mode), in seconds.

Rulați comanda

vi secretfile

Scrieți “acest fișier este secret” în fisier și salvați. Nu închideți.

Într-un alt terminal, folosiți ps pentru a identifica PID-ul procesului vim pornit.

Rulați comanda cd /proc/$PID (înlocuiți ?</code>

true și false sunt două programe care întotdeauna se termină cu succes, respectiv cu eroare.

true
echo $?
0
false
echo $?
1

Folosind operatorii && și ||, putem rula un al doilea proces doar dacă primul proces a avut succes, respectiv eroare.

Testați următoarele comenzi și observați dacă se execută sau nu procesul echo:

true && echo "Success"

false && echo "Success"

true || echo "Fail"

false || echo "Fail"

Deschideți o instanță de vim.

Într-un alt terminal, rulați comanda

htop

Observați că informațiile afișate sunt cele din top dar interfața este mult mai ușor de folosit.

Afișați detalii despre procesul vim, detalii referitoare la fișierele deschise și la zonele de memorie folosite (folosiți tasta l)

Folosind ps determinați PID-ul procesului gnome-panel.

NU folosiți scroll. Folosiți less sau more.

Observați că less permite operații mai avansate decât more. Utilizatorii spun ”less is more”

Un tip special de fișiere unix sunt pipe-urile cu nume. Acestea au o reprezentare fizică pe disc.

Creați un pipe cu numele twitter.

mkfifo twitter

Listați în format lung informații despre acest fișier. Ce observați?

Deschideți un terminal și scrieți mesajul “USO rU1z” în fișierul twitter.

Deschideți un alt terminal și afișați conținutul fișierului. Ce observați?

Încercați să afișați din nou conținutul fișierului.

Ce se întâmplă dacă revenim în primul terminal și încercăm să scriem un nou mesaj în fișier?

Folosiți ps și grep pentru a afla PID-ul terminalului curent.

Ce se întâmplă dacă aveți mai multe sesiuni deschise?

$$ este o variabilă de mediu specială care conține PID-ul procesului curent.

Determinați PID-ul terminalului curent.

Determinați PID-ul procesului părinte. (folosiți variabila de mediu $PPID)

Aflați numele procesului părinte. (ps și grep)

Deschideți editorul vi.

Într-un alt terminal, folosiți comanda pgrep pentru a afișa numele și pid-ul tuturor proceselor vi din sistem.

Căutați parametrul -l în man.

Cum ați putea afișa doar procesele vi, fără a afișa și procesele ale căror nume conțin grupul de litere vi?

Căutați în man după “exactly”.

Se dă următorul program hello.c.

Compilați programul folosind

gcc -o hello hello.c

Folosiți pmap pentru a vizualiza maparea memoriei virtuale.

Analizați sursa și încercați să explicați comportamentul.

Comunicarea între procese se poate realiza prin semnale.

Un utilizator îi trimite un semnal unui proces, utilizând comanda kill.

Folosiți

kill -l

pentru a vedea toate semnalele pe care i le puteți trimite unui proces.

Descărcați programul signal_test, faceți-l executabil și rulați-l astfel:

chmod +x signal_test
./signal_test

Deschideți un alt terminal și rulați comanda următoare pentru a afla PID-ul procesului creat

pgrep signal_test

Alternativ, puteți folosi comanda pidof.

Rulați următoarele comenzi în același terminal pentru a trimite mesaje procesului creat:

kill -1 $(pidof signal_test)
kill -2 $(pidof signal_test)
kill -3 $(pidof signal_test)
kill -5 $(pidof signal_test)
kill -6 $(pidof signal_test)
kill -7 $(pidof signal_test)
kill -11 $(pidof signal_test)
kill -19 $(pidof signal_test)
kill -18 $(pidof signal_test)
kill -INT $(pidof signal_test)
kill $(pidof signal_test)
pkill signal_test
pkill -1 signal_test
pkill -INT signal_test

În terminalul în care programul rulează, tastați, pe rând combinațiile de taste următoare și observați ce semnale se trimit:

* CTRL-Z * CTRL-C * CTRL-\

La final, rulați comanda:

kill -9 $(pidof signal_test)

Observați că semnalul 9 (SIGKILL) nu poate fi tratat de nici o aplicație.

Comanda trap poate fi folosită pentru a executa o comandă în momentul în care shell-ul primește un anumit semnal.

Executați comanda:

trap "echo shell closed > /tmp/log.terminal" SIGHUP

În momentul în care shell-ul primește semnalul HUP, va executa comanda echo.

Verificați conținutul fișierului /tmp/log.terminal. Observați că acest fișier nu există.

Ce reprezintă $$? (dacă nu vă amintiți, căutați în laboratorul din săptămâna trecută)

Trimiteți semanul:

kill -HUP $$

Verificați conținutul fișierului /tmp/log.terminal.

Citiți mai multe în man bash.

Pentru a forța închiderea unei aplicații grafice se poate folosi comanda xkill.

Deschideți un calculator. (Applications → Accessories → Calculator)

Deschideți un terminal. Tastați comanda xkill.

În terminal a apărut mesajul:

Select the window whose client you wish to kill with button 1

Ce formă are mouse-ul?

Dați click pe Calculator.

Utilizând vim deschideți fișierul Uranus:

vim Uranus

Scrieți textul Uranus, Geea în fișier.

Tastați Ctrl-Z. Procesul este trimis în background.

Rulând

ps

observați câte procese se afișează.

Procesul vim se află în background. Reveniți la el tastând comanda

fg

Trimiteți-l din nou în fundal (Ctrl-Z). Porniți un alt proces vim, direct în fundal cu

vim Cronos &

Prezența lui & a forțat procesul să pornească direct în fundal.

Rulați

jobs

pentru a vedea toate procesele care se află în fundal.

Tastați

fg

pentru a aduce în foreground un proces din fundal.

După cum observați, se aduce ultimul proces trimis în fundal.

Trimiteți Ctrl-Z procesului vim din foreground.

Rulați comanda

fg 1

Observați că se aduce primul proces trimis în fundal.

Aduceți ambele procese în foreground și ieșiți din vim.

Rulați comanda

cat /dev/random

Pe ecran vor fi afișate caractere random. Trimiteți procesul în fundal utilizând semnalul SIGSTOP (Ctrl-Z).

Observați că procesul a fost trecut în starea Stopped. Rulând ps, procesul apare în output.

Rulați comanda

bg

Procesul pornește din nou dar aveți acces la prompt. Procesul rulează în background (puteți observa ușor acest lucru deoarece caracterele generate de /dev/random sunt afișate în terminal).

Trimiteți semnalul SIGKILL utilizând kill procesului cat din background. Știind că este ultimul proces din background, folosim comanda

kill -9 $!

deoarece $! este PID-ul ultimului proces aflat în background.

Diagrama următoare arată stările în care se poate afla un proces și cum se trece dintr-o stare în alta.

Rulați programul descărcat anterior astfel:

./signal_test 42

Programul creează un daemon. Folosiți un procedeu pentru a afla PID-ul procesului creat.

Observați că singura modalitate de a interacționa cu acesta o reprezintă semnalele.

Navigați către directorul din /proc corespunzător procesului. Listați filedescriptorii procesului, în format lung. Ce observați?

Instalați pachetul apache2.

Verificați că există un proces apache2 care rulează. Acesta este un alt exemplu de daemon.

Folosind /etc/init.d/apache2 opriți acest proces. Această formulare trimite un semnal daemonului Apache. Ca rezultat, daemonul se va închide.

Porniți procesul corespunzător comenzii ping -c 10000 google.com într-un terminal.

Închideți acest terminal și verificați (folosind ps și htop) dacă procesul ping mai există.

Încercați același lucru și trimițând procesul în background prin folosirea &.

Încercați și folosind nohup, trimițând procesul în background prin &.

Rulați comanda ping 8.8.8.8 > /dev/null &. Procesul este rulat în background.

Închideți acest terminal și verificați (folosind ps și htop) dacă procesul mai există.

Deschideți un alt terminal și rulați din nou ping 8.8.8.8 > /dev/null &. Procesul rulează în background.

Folosiți disown pe pid-ul asociat procesului ping, apoi închideți terminal-ul.

Ce se întâmplă cu procesul?

Demonstrați, pornind procese și trimițând semnalele corespunzătoare, că părintele unui proces al cărui părinte este terminat este chiar procesul init.

Hint: porniți un xterm din interiorul altui xterm pornit din terminal și terminați primul xterm pornit.

Instalați pachetul screen. Folosiți-l pentru a rula, în paralel, pagina de manual a programului screen, o instanță de vim și procesul corespunzător comenzii ping google.com.

Utilizând pagina de manual, determinați combinația de taste necesară pentru a părăsi screen fără a opri procesele care rulează.

Pentru a verifica, conectați-vă la sesiunea anterioară de screen.