1. Scopul lucrării

Lucrarea de faţă prezintă o modalitate de comunicare între procese şi anume prin semnale (signals). În lucrare sunt prezentate toate semnalele existente sub sistemul de operare UNIX, precum şi modul de lucru cu acestea. Semnalele se folosesc în general pentru situaţii de excepţie, alarme, terminări neprevăzute şi mai rar pentru comunicaţia între procese.

2. Consideraţii teoretice

Semnalele reprezintă calea cea mai simplă, cea mai veche şi cea mai rigidă de comunicaţie între procese. Se poate defini semnalul ca o avertizare pe care o primeşte un anumit proces. Semnalul în sine nu conţine informaţie utilă, tot ce contează fiind tipul său. Orice semnal are o sursă şi este generat dintr-o anumită cauză. Un semnal poate veni de la un alt proces care doreşte să comunice cu procesul în cauză, de exemplu să se sincronizeze cu acesta la transmiterea unor date sau pur şi simplu să-i provoace terminarea. Altă sursă de semnale este nucleul care, în anumite situaţii (incidenţe hard, apelarea procedurii shutdown ...), poate trimite mesaje către procese. Un proces poate să-şi trimită şi singur un semnnal, aşa cum este cazul la apelurile abort şi alarm. În sfârşit, un semnal poate fi trimis la cererea explicită a unui utilizator, prin apelul comenzii sistem kill. Procesul care primeşte semnalul nu poate determina sursa sa.

Cauza unui semnal este, de regulă, reflectată de tipul său. În UNIX SVR2 sunt definite 19 tipuri de semnale, care sunt prezentate în tab.1.

Tab.1. Semnale existente în primele versiuni Unix

Semnalele notate cu * produc vidaj de memorie. În funcţia signal, semnalul poate fi specificat prin numărul sau sau prin simbolul sau, definit în fişierul /usr/include/signal.h.

Având în vedere ca versiunile SVR4 şi 4.3+BSD, au fiecare cate 31 de semnale, din lipsa de spaţiu nu se vor prezenta restul semnalelor. Pentru detalii a suplimentare a se consulta bibliografia.

Un proces care a recepţionat un semnal poate să-l trateze în trei moduri:

a) Ignora semnalul şi continua activitatea sa. Dintre semnale, doar SIGKILL nu poate fi ignorat (nucleul are posibilitatea terminării oricărui proces).

b) Sarcina tratării semnalul este lăsată nucleului. În acest caz, cu excepţia semnalelor SIGCLD şi SIGPWR ( şi mai nou SIGINFO, SIGURG şi SIGWINCH) care sunt ignorate, toate celelalte semnale duc la terminarea procesului, eventual cu vidaj de memorie. Aceasta este tratarea implicită.

c) Tratarea semnalului printr-o procedură proprie, care este lansată în mod automat la apariţia semnalului. La terminarea procedurii, procesul este reluat din punctul din care a fost întrerupt. Reluarea nu se va face imediat, ci în regim de multiprogramare, pe baza priorităţii procesului din acel moment.

La apelul funcţiei de sistem fork procesul fiu creat moşteneşte de la procesul părinte acţiunea ataşată semnalelor

Funcţia exec lasă tratarea semnalelor în sarcina nucleului, chiar dacă ele erau tratate de către proces. Se păstrează doar acţiunea prevăzută iniţial de ignorare a unor semnale de către proces. Explicaţia constă în faptul că prin apelul exec textul programului curent este distrus, deci şi procedurile de tratare a semnalelor.

Indiferent de modul cum reacţionează programul la un anumit semnal, după terminarea acţiunii, dacă semnalul nu era ignorat, el este actualizat pentru viitor la acţiune implicită. Excepţie fac semnalele SIGILL şi SIGTRAP care sunt generate foarte des şi ar fi ineficientă actualizarea lor de fiecare dată.

Dacă în timpul execuţiei unei funcţii sistem se recepţionează un semnal, apelul este terminat cu eroare. În particular, dacă s-a lansat o operaţie de intrare/ieşire cu un periferic lent şi se recepţionează un semnal, funcţia returnează -1, iar variabila errno ia valoarea EINTR. În acest caz, programul poate să relanseze operaţia de intrare/iesire testând variabila errno.

Semnalele sosite către un proces nu sunt memorate într-o coadă de aşteptare. Dacă ele au fost ignorate, se pierd pentru totdeauna. Singura excepţie este semnalul SIGCLD care aşteaptă să fie luat în considerare când procesul părinte execută apelul wait pentru a lua la cunoştinţă de terminarea fiului. Aceasta pentru ca procesul fiu să poată termina înainte de execuţia de către părinte a apelului wait. Dacă semnalul n-ar fi memorat, procesul părinte ar rămâne blocat până la terminarea unui alt fiu, care foarte probabil n-are nici o legătură cu procesul curent. Semnalul SIGCLD nu este memorat în cazul în care părintele a actualizat explicit la valoarea SIG_IGN rutină de tratare a semnalului. Datorită faptului că semnalele ignorate se pierd, acest mecanism de comunicaţie între procese nu este prea des folosit, pentru că poate provoca probleme.

Un semnal poate fi trimis în orice moment, ocazional de un alt proces, dar de regula de la kernel ca rezultat al unui eveniment excepţional. Semnalul nu conţine informaţie, el se rezumă doar la tipul sau. Procesul care primeşte semnalul nu poate identifica sursa semnalului.

2.1. Funcţia de sistem SIGNAL

Rolul funcţiei de sistem signal este stabilirea modului de tratare a unui semnal de către un proces la primirea lui. Interfaţa sa este următoarea:

#include <signal.h >

int (*signal (semnal, funcţie))()

int semnal;

int (*funcţie)();

sau

#include <signal.h>

void (*signal (int semnal, void (*funcţie)(int)))( int);

S-a prezentat atât stilul vechi de prototip (când nu era definit tipul void) cât şi cel nou pentru a fi mai clar tipul argumentelor: un întreg şi un pointer la o funcţie. Argumentul semnal este semnalul pentru care se stabileşte modul de tratare, iar funcţie descrie modul de tratare a semnalului. Acesta poate avea următoarele trei valori:

a) SIG_DFL - pentru a specifica tratarea semnalului de către nucleu. Aceasta este acţiunea implicită de tratare a unui semnal.

b) SIG_IGN - pentru a ignora semnalul. Semnalul SIGKILL şi SIGSTOP nu pot fi ignorate de nici un proces.

c) un pointer la o funcţie care tratează semnalul. La primirea semnalului, funcţia specificată este apelată. Această funcţie poartă numele de rutina de tratare sau captare a semnalului. Ea are ca unic argument numărul semnalului pentru care este activată. Dupa ce un semnal a fost tratat, recepţia aceluiaşi semnal devine cea implicită. Dacă se doreşte tratarea din nou a aceluiaşi semnal, în cadrul funcţiei trebuie prevăzut acest lucru.

Valoarea întoarsă de funcţia signal este adresa rutinei anterioare de tratare a semnalului. Cazul de eroare este semnalat prin constanta SIG_ERR definită în fişierul err.c:

#define SIG_ERR ( void (*)())-1

Se recomandă ca în cazul în care procesul are de executat înaintea terminării normale câteva operaţii (ştergerea unor fişiere temporare, restaurarea unor fişiere etc.) acesta să capteze semnalele SIGHUP, SIGINT şi SIGTERM şi în cadrul lor să execute operaţiile respective. Pe parcursul unei aplicaţii, semnalul SIGQUIT nu trebuie interceptat, pentru a putea termina procesul cu Ctrl-\, terminare însoţită şi de vidaj de memorie (core dump). În cazul în care un proces este lansat în background, deoarece el se execută cu semnalele SIGQUIT şi SIGINT ignorate funcţia de tratare a acestor semnale trebuie să fie SIG_IGN. În caz contrar programul ar putea fi întrerupt la apăsarea tastelor de întrerupere.

Dacă un proces părinte captează semnalele SIGINT şi SIGQUIT şi aşteaptă terminarea unui fiu există pericolul ca unul dintre aceste semnale să-l scoată din starea de aşteptare înainte ca fiul să termine. Se recomandă în acest caz ca procesul părinte să ignore aceste semnale cât timp se află în starea de aşteptare.

În conjuncţie cu semnalele, de multe ori trebuie executate salturi nelocale într-un program. Există două funcţii care permit realizarea acestora. Funcţia setjmp fixează un punct de salt, prin salvarea stării procesorului şi a stivei din acel punct, iar funcţia longjmp realizează saltul la un punct de salt, specificat prin parametrul său. Din funcţia setjmp se produce revenirea în 2 cazuri:

a) la stabilirea cu succes a punctului de salt, funcţia întoarce valoarea 0;

b) la efectuarea unui salt nelocal funcţia întoarce valoarea val cu care a fost apelată funcţia longjmp. Sintaxa funcţiilor este:

#include <setjmp.h

int setjmp( jmp_buf jmpenv);

void longjmp( jmp_buf jmpenv, int val);

2.2. Apelul sistem KILL

Apelul sistem kill trimite un semnal la un proces sau grup de procese.

Interfaţa apelului este:

#include <sys/types.h

#include <signal.h

int kill( pid_t pid, int sem);

Returnează 0 în caz de succes, -1 la eroare.

Argumentul pid specifică procesul sau grupul de procese spre care se trimite semnalul sem. Există patru condiţii diferite pentru valoarea argumentului pid în apelul kill:

pid 0 Semnalul este transmis procesului al cărui identificator de proces este pid.

pid == 0 Semnalul e transmis tuturor proceselor din acelaşi grup cu emiţătorul şi la care emiţătorul are dreptul să trimită semnalul (se exclud procesele swapper (pid=0), init (pid=1) şi pagedaemon (pid=2)). Acest lucru este des utilizat în comanda kill 0 pentru a şterge procesele ce se execută în background fără a fi referite cu numărul de identificare al lor.

pid < 0

(pid!=-1) Semnalul este transmis tuturor proceselor al căror ID de grup este egal cu valoarea absolută a pid-ului şi la care emiţătorul are dreptul să trimită semnalul.

pid==-1 Posix.1 lăsă condiţia nespecificată.

SVR4 şi 4.3+BSD folosesc această valoare în semnale broadcast. Ele nu sunt transmise proceselor sistem descrise mai sus. Dacă apelantul este superuser, semnalul este transmis tuturor proceselor. Acest lucru este utilizat pentru a trimite SIGTERM la toate procesele la întreruperea sistemului.

Dacă apelantul nu e superuser, semnalul este transmis tuturor proceselor care au uid real ( sau suid, dacă implementrea permite - SVR4) egal cu uid real sau efectiv al apelantului. Acest lucru este utilizat pentru a şterge toate procesele indiferent de grup. Semnalele broadcast sunt folosite doar în scopul administrării sistemului.

Regula de bază la transmiterea unui semnal spre un proces este ca procesul transmiţător să aibă dreptul să trimită semnalul ( ID utilizatorului real sau efectiv al procesului transmiţător să fie egal cu uid real sau efectiv al procesului receptor). Superuser-ul poate trimite un mesaj la orice proces.

2.3. Apelul sistem ALARM

Apelul alarm permite poziţionarea unui timer. La expirarea timpului este generat semnalul SIGALRM. Dacă semnalul este ignorat sau nu e captat acţiunea implicită este de a termina procesul. Interfaţa să este:

#include <unistd.h

unsigned int alarm(unsigned int sec);

Returnează 0 sau numărul de secunde rămase de la cererea anterioară de activare a semnalului SIGALRM.

Argumentul sec reprezintă numărul de secunde după care semnalul SIGALRM este activat. La expirarea timpului, semnalul e generat de nucleu, dar tratarea semnalului poate să fie întârziată din cauza planificatorului de procese.

Exista un singur orologiu de alarmă într-un proces. Un apel nou suprascrie valoarea anterioară. Dacă sec este 0 cererile anterioare de activare a semnalului SIGALRM sunt anulate.

Cu toate că acţiunea implicită pentru SIGALRM este de a termina procesul, multe procese ce folosesc apelul sistem alarm captează acest semnal. Înainte de terminare pot fi realizate diverse operaţii de ştergere.

2.4. Apelul sistem PAUSE

Permite suspendarea (stare de aşteptare) procesului apelant până la primirea unui semnal. Interfaţa ei este:

#include <uninstd.h

int pause(void);

Returnează (-1) cu errno=EINTR.

Dacă semnalul care soseşte nu este tratat sau ignorat, se produce terminarea procesului cu eventual vidaj de memorie. Din apelul pause se revine dacă din rutina de tratare se revine. În acest caz pause returnează valoarea (-1) cu variabila errno având valoarea EINTR.

Apelul sistem pause este cel mai mult utilizat în relaţie cu apelul sistem alarm.

2.5. Apelul sistem SIGACTION

Funcţia permite inspectarea şi/sau modificarea acţiunii asociate unui semnal. Această funcţie înlocuieşte funcţia signal din versiunile de Unix mai vechi. Interfaţa este următoarea:

#include <signal.h

int sigaction( int sem, const struct sigaction *act,

struct sigaction *vact);

Returnează 0 în caz de succes, (-1) în caz contrar.

Argumentul sem este numărul semnalului a cărui acţiune este inspectată şi/sau modificată.

Dacă act!=NULL acţiunea se modifica.

Dacă vact!=NULL sistemul returnează acţiunea precedentă ataşată semnalului.

Structura sigaction flosită de funcţie este:

struct sigaction {

void ( *sa_handler)(); /* adresa rutinei de tratare */

sigset_t sa_mask; /* semnale suplimentare de blocat */

int sa_flags; /* opţiuni pentru semnale */

};

La modificarea acţiunii ataşate unui semnal, în cazul în care sa_handler referă o rutina de tratare semnal, câmpul sa_mask specifică un set de semnale care sunt adăugate la masca de semnale a procesului înainte de apelul rutinei de tratare. La revenirea din rutina de tratare masca de semnale este restaurată la valoarea ei initială. În acest mod, pe timpul execuţiei rutinei de tratare, se pot bloca anumite semnale. Semnalul tratat este automat mascat, astfel ca o altă apariţie (sau mai multe) a acestui semnal va fi blocată atâta timp cât tratarea primei apariţii nu a fost încheiată ( deosebirea esenţiala între funcţia signal din versiunile anterioare de Unix şi funcţia sigaction!). După deblocarea semnalului, indiferent dacă a fost o singura apariţie sau mai multe, rutina de tratare va fi invocată o singura dată.

Asocierea unei acţiuni unui semnal este permanentă până la o modificare explicită printr-un apel sigaction.

Câmpul sa_flag poate avea diferite valori, funcţie de versiunea de sistem flosită ( a se vedea bibliografia).

Folosind funcţia sigaction, se poate implementa funcţia signal (mai completa decât funcţia similară existentă în SVR2):

/*

A se compila cu: gcc -c -o sig.o sig.c

Funcţia signal implementata prin funcţia sigaction (SVR4)

*/

#include <signal.h>

#include "hdr.h"

Sigfunc *

signal( int sig, Sigfunc *func)

{

struct sigaction act, old_act;

act.sa_handler=func;

sigemptyset( &act.sa_mask);

act.sa_flags=0;

if ( sig==SIGALRM) {
 

} else {
 

}

printf(" S I G A C T I O N \n");

if ( sigaction( sig, &act, &old_act) <0)

return( SIG_ERR);

return( old_act.sa_handler);

}

Indicatorul SA_RESTART trebuie poziţionat pentru toate semnalele mai puţin SIGALRM pentru ca orice apel întrerupt de unul dintre aceste semnale să fie reactivat automat. SIGALRM a fost omis pentru a putea fixa o limită de timp la operaţiile de I/E cu periferice lente.

Sistemul SunOS reactivează implicit apelurile sistem întrerupte, deci specificând indicatorul SA_INTERRUPT în cazul semnalului SIGALRM apelurile sistem nu vor fi întrerupte.

Exemplul de mai jos ilustrează diferenta între funcţia signal (existentă în SVR2) şi funcţia signal implementată prin funcţia sigaction. În primul caz semnalul e captat (tratat) o singura dată, iar la a doua generare a sa programul se termină. În al doilea caz, semnalul fiind blocat pe timpul tratării sale, fiecare generare a sa este tratată. Pentru a termina programul se generează SIGQUIT prin tasta Ctrl-\.

/*

A se compila şi compara rezultatele folosind cele doua implementari ale funcţiei signal

*/

#include <stdio.h

#include <sys/types.h

#include <sys/wait.h

#include <signal.h

#include "hdr.h"

void sig_intr( int);

int main( void)

{

char buf[MAXLINE];

pid_t pid;

int status;

if ( signal( SIGINT, sig_intr) == SIG_ERR)
 

printf(" ");

while ( fgets( buf, MAXLINE, stdin) != NULL) {
 

exit(0);

}

void sig_intr( int sig)

{

printf("intrerupt\t\t\tCaptat semnalul SIGINT\n ");

fflush( stdout);

}

Având în vedere mare diversitate de funcţii ce lucrează cu semnale se recomandă consultarea bibliografiei.

3. Aplicaţii

3.1. Să se scrie un program care ilustreaza modurile de tratare ale unui semnal.

#include <signal.h

#include "hdr.h"

static void sig_usr1( int); /* generat cu kill USR1 <pid */

static void sig_intr( int); /* generat la Ctrl-C şi rearmat */

static void sig_quit( int); /* generat cu Ctrl-\ şi resetat */

static void sig_alarm(int); /* generat dupa scurgerea timpului t din alarm(t) */

int main( void)

{

if ( signal( SIGALRM, sig_alarm) == SIG_ERR)
 

if ( signal( SIGUSR1, sig_usr1) == SIG_ERR)
 

if ( signal( SIGINT, sig_intr) == SIG_ERR)
 

if ( signal( SIGQUIT, sig_quit) == SIG_ERR)
 

for ever pause();

}

static void sig_alarm( int sig)

{
 

}

static void sig_quit( int sig)

{

printf("Receptionat semnalul SIGQUIT\n");

if ( signal( SIGQUIT, SIG_DFL) == SIG_ERR)
 

return;

}

static void sig_intr( int sig)

{

printf("Receptionat semnalul SIGINT\n");

if ( signal( SIGINT, sig_intr) == SIG_ERR)
 

return;

}

static void sig_usr1( int sig)

{
 

return;

}

3.2. Să se scrie un programul care citeşte o linie de la intrarea standard şi o afişează la ieşirea standard. Programul stabileşte un interval de timp pentru efectuarea operaţiei. Dacă operaţia nu s-a realizat în acest răstimp ea este abandonată.

#include <setjmp.h

#include <signal.h

#include "hdr.h"

static void sig_alarm();

int main( void)

{

int n;

char line[MAXLINE];

if ( signal( SIGALRM, sig_alarm) == SIG_ERR)
 

alarm( 10);

if ( ( n=read( 0, line, MAXLINE)) < 0)
 

alarm(0);

write( 1, line, n);

exit(0);

}

static void sig_alarm( int sig)

{

return;

}

Codul are două inconveniente:

a) Dacă nucleul întârzie procesul între apelurile alarm şi read pentru un interval mai mare decât perioada alarmei ( 10 secunde), apelul read se blochează pentru totdeauna.

b) Dacă funcţiile de sistem sunt automat relansate, apelul read nu este întrerupt când se revine din rutina de tratare a semnalului SIGALRM. În acest caz alarma nu-şi are rostul.

3.3. Următorul program ilustrează cum pot fi create într-un program regiuni ce nu pot fi întrerupte, semnalul de întrerupere fiind amânat până la terminarea regiunii. Programul preia linii de text de la intrarea standard pe care le afişează la ieşirea standard. Pe timpul preluării textului de la tastatură programul nu va putea fi întrerupt.

#include <signal.h

#include <setjmp.h

#define MAXLIN 81

jmp_buf cs_stack;

int în_reg, s_inreg;

void beg_reg( ); /* funcţie ce marcheaza inceputul regiunii */

void end_reg( ); /* funcţie ce marcheaza sfarsitul regiunii */

int tratare( ); /* rutina de tratare a semnalului */

int read_line( );

void main( )

{

int nr_car;

char buff[MAXLIN];

signal( SIGINT, tratare );

if( setjmp( cs_stack ) ){ /* prelucrare intrerupere */
 

} else

while( 1 ){
 

printf( " Program terminat normal !\n" );

}

int tratare( )

{

if( în_reg ){
 

} else {
 

}

return 0;

}

void beg_reg( void )

{
 

}

void end_reg( void )

{

în_reg = 0;

if( s_inreg ){
 

}

}

int read_line( buff )

char *buff;

{
 

4. Probleme propuse

4.1. Să se scrie un program utilizat pentru copierea intrării standard într-un fişier, specificat prin linia de comandă. Dacă în 3 intervale succesive de 10 sec nu este introdus nici un caracter de la tastatură, programul este terminat. La fiecare interval de 10 sec. neutilizate, utilizatorul va fi atenţionat.

4.2. Folosind alarm şi pause să se implementeze o funcţie sleep2.

4.3. Scrieţi un program ce preia de la tastatură câte 2 numere reale pe care efectuează operaţiile +, - , * şi /. Programul trebuie să trateze erorile aritmetice care pot să apară.

4.4. Un program copiază intrarea standard într-un fişier specificat prin linia de comanda, utilizând un fişier intermediar în acest scop. Scrieti programul în asa fel încât, dacă procesul este întrerupt prin oricare din semnalele SIGINT, SIGQUIT, SIGHUP, SIGTERM, să fie anulate toate efectele execuţiei programului până la întrerupere.

4.5. După execuţia lui fork, nu se ştie ce proces va continua primul. În situaţia în care acestea accesează o resursa partajată, pot să apară probleme de nesincronizare. Pentru ca două procese aflate în relaţie părinte-fiu să se sincronizeze, se pot crea următoarele funcţii:

TELL_WAIT() realizează anumite iniţializări;

TELL_PARENT(pid) anunţă părintele ca poate continua execuţia;

WAIT_PARENT() aşteaptă părintele până ce acesta termină accesul la resursa partajată;

TELL_CHILD(pid) anunţă părintele ca a terminat accesul;

WAIT_CHILD( ) aşteaptă procesul fiu până ce acesta termină accesul la resursa partajată;

Utilizând semnalele, să se implementeze aceste funcţii de sincronizare.

4.6. Să se scrie următorul program pentru a testa sicronizarea părinte-fiu, utilizând funcţiile din programul 4.5.

4.7. Să se scrie două programe MASTER.C şi SLAVE.C. Programul master se lansează la un terminal şi generează câte un proces fiu (SLAVE) pentru fiecare terminal specificat în linia de comandă. Procesul MASTER poate comunica cu procesele SLAVE prin fişier PIPE. să se scrie programele astfel încât procesele SLAVE culeg câte o linie de text pe care o trimit procesului MASTER care le preia şi le afişează pe ecran. Sincronizarea se realizează prin semnale.

4.8. Se dau trei fişiere cu numele NUME.TXT, PREN.TXT şi NOTA.TXT în care sunt înregistrate, câte unul pe linie, numele, prenumele şi nota obţinută de mai mulţi studenţi. Să se scrie un program, prin lansarea căruia se generează 3 procese, fiecare proces citind datele dintr-un fişier dintre cele trei. Să se sincronizeze funcţionarea celor trei procese astfel încât pe ecran să se afişeze linii având structura: NUME PRENUME NOTA

4.9. Să se elimine neajunsurile aplicaţiei 3.2. folosind setjmp şi longjmp.

4.10. Să se scrie un program C care să implementeze problema filozofilor.