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.

a) Rulați comanda

vim beatles

Scrieți “we all live in a yellow submarine” în fisier și salvați fișierul. Nu iesiți din vim.

b) Într-un alt terminal, folosiți ps pentru a identifica PID-ul procesului vim pornit. Folosiți argumentul -C al utilitarului ps.

c) Rulați comanda cd /proc/$PID (înlocuiți $PID cu PID-ul găsit anterior). Listați conținutul directorului în care vă aflați.

• Link-ul exe pointează către executabilul ce a creat procesul. Care este acesta pentru cazul nostru?
• Fișierul cmdline conține linia de comandă folsoită pentru lansarea în execuție a procesului. Verificați conținutul fișierului folosind cat.
• Folderul fd conține legături simbolice către descriptorii de fișier folosiți de proces. Primii 3 descriptori sunt cei standard (0: stdin, 1: stdout, 2: stderr).

d) Închideți sesiunea de vim deschisă anterior. Reveniți în terminalul în care ați vizualizat structura lui procfs. Listați conținutul directorului. Ce observați?

a) Rulați comanda uptime. Folosind pagina de man a utilitarului, identificați ce reprezintă cele trei numere de la load average.

student@uso:~$ man uptime
[...]
uptime  gives  a  one line display of the following information.  The current time, how long the system has been running, how many users are currently logged on, and the system load averages for the past 1, 5, and 15 minutes.

b) Rulați executabilul uptime_ex (execuția acestuia dureză câteva secunde). În timp de executabilul uptime_ex rulează, executați într-un terminal separat comanda uptime de câteva ori la rând.

Cum variază valorile numerice de load? Ce credeți că face programul?

a) Construiți, în directorul ~ creați un director numit 1960s, și în el creați fișierele următoare:

touch Ticket-to-Ride_TheBeatles.txt Yesterday_TheBeatles.txt Penny-Lane_TheBeatles.txt
touch Satisfaction_RollingStones Brown-Sugar_RollingStones Wild-Horses_RollingStones Play-With-Fire_RollingStones
touch Hey-Jude_TheBeatles
touch Rainy-Day-Women_BobDylan

b) Ne interesează drepturile fișierelor ce conțin TheBeatles în nume. Tastați comenzile următoare:

student@uso:~$ cd ~/1960s
student@uso:~/1960s$ ls -l  > temp_file
student@uso:~/1960s$ cat temp_file
student@uso:~/1960s$ grep TheBeatles temp_file
student@uso:~/1960s$ rm temp_file

Observați că am folosit un fișier suplimentar (temp_file) în care am stocat rezultatele intermediare.

c) Tastați comanda

student@uso:~/1960s$ ls -l | grep greek

De această dată, s-a folosit o comandă compusă.

Caracterul | (pipe) este folosit pentru a înlănțui 2 comenzi, legând ieșirea standard a primei comenzi la intrarea standard a celeilalte, așa cum arată și figura următoare:

Folosind > și < putem face ca o comandă să scrie într-un fișier sau să citească dintr-un fișier. Folosind | fișierul nu mai este necesar.

Rulați comanda

student@uso:~/1960s$ ls -l | cat | cat | cat | cat | cat | cat

Câte fișiere ar fi fost necesare dacă nu foloseam pipe-uri?

a) Un proces își poate termina cu succes (status 0) sau cu eroare (status diferit de 0). Într-un terminal statusul cu care s-a încheiat ultimul proces lansat se poate vedea cu ajutorul comenzii

echo $?

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

student@uso:~$ true
student@uso:~$ echo $?
0
student@uso:~$ false
student@uso:~$ echo $?
1

c) Folosind operatorii && și ||, putem rula un al doilea proces doar dacă primul proces s-a încheiat cu succes, respectiv eroare. Operatorii se aseamănă cu funțiile logile AND și OR.

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

student@uso:~$ true && echo "Success"
student@uso:~$ false && echo "Success"
student@uso:~$ true || echo "Fail"
student@uso:~$ false || echo "Fail"

a) Unul din mecanismele prin care se poate comunica între procese sunt semnalele. Un utilizator poate trimite un semnal unui proces folosind comanda kill.

Utilizați kill -l pentru a vedea toate semnalele care se pot trimite unui proces.

student@uso~$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

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

student@uso~$ chmod +x signal_test
student@uso~$ ./signal_test

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

pidof signal_test

Alternativ, puteți folosi comanda pgrep.

Rulați următoarele comenzi din cel de-al doilea terminal pentru a trimite mesaje procesului creat:

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

d) În terminalul în care programul signal_test 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, pentru a opri procesul signal_test, rulați comanda:

student@uso~$ kill -9 $(pidof signal_test)

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

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

Deschideți aplicația calculator. (Applications → Accessories → Calculator)

b) 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 undeva în interiorul ferestrei Calculator.

a) Utilizând vim, deschideți fișierul TheBeatles:

student@uso:~$ vim TheBeatles

Scrieți textul John Lennon în fișier.

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

Folosiți ps în același terminal pentru a lista procesele pornite în cadtul terminalului

student@uso:~$ ps

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

student@uso:~$ fg

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

student@uso:~$ vim TheRollingStones &

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

e) Rulați comanda

student@uso:~$ jobs

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

f) Tastați

student@uso:~$ fg

pentru a aduce în foreground un proces din fundal.

După cum observați, fără nici un parametru, fg aduce ultimul proces trimis în fundal.

g) Trimiteți Ctrl-Z procesului vim din foreground.

Rulați comanda

student@uso:~$ fg 1

Observați că se aduce primul proces trimis în fundal. Aduceți pe rând ambele procese în foreground și ieșiți din vim.

a) Rulați comanda

student@uso:~$ cat /dev/random

b) 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. Folositi ps pentru a vedea ca procesul apare în output.

Rulați comanda

student@uso:~$ bg

Procesul pornește din nou dar aveți acces la prompt. În momentul de față 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

student@uso:~$ 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.

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”.

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?

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.

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.