***********************<[Processi di elaborazione]>*********************


Autore:Evilcry                      
E-Mail:evilcry@virgilio.it  

Innanzitutto che cos'è un processo??,un processo non è altro che un 
singolo programma nel momento in cui viene eseguito. La nascita di un processo
si può avere soltanto se viene chiamato da un altro processo, ovviamente
già esistente :D. Si forma quindi una gerarchia di processi, il processo (root)
che sta al vertice è chiamato init in pratica quello che darà vita agli altri processi. 
Il processo init è attivato cioè nasce dal kernel.

*********[Tabella dei processi]***********************

Una delle funzioni del kernel è quella di gestire una tabella di processi,
che serve a tener traccia del loro stato di esecuzione.I valori che si trovano in questa 
tabella sono:

-il nome dell'eseguibile in funzione; 
-gli eventuali argomenti passati all'eseguibile attraverso una riga di
 comando; 

-il numero di identificazione del processo; PID (Process IDentification)
che è un numero preso in un intervallo da 1 a 30000. Il PID di un processo viene assegnato
al momento della sua nascita, quindi dipende dal momento in cui è stato creato.

-il numero di identificazione del processo che ha generato quello a cui si  riferisce; 

-il nome del dispositivo di comunicazione se il processo è controllato da un  terminale; 

-il numero di identificazione dell'utente; 

-il numero di identificazione del gruppo; 

Linux mette a nostra disposizione questa tabella,attraverso un filesystem
virtuale montato nella directorty /proc. Tutti i programmi che gestiscono
i processi fanno riferimento a questo filesystem. Andate a guardarlo
pure per curiosità! :=)

Per vedere lo stato dei processi non è necessario andare a vederli
in /proc, ma basta usare il comando "top" oppure "ps", mi raccomando 
senza apici

***************<[Nascita e morte di un processo]>***************

Prima avevamo detto che un processo nasce quando viene chiamato da uno già esistente,ma
 non solo,infatti può essere chiamato attraverso la funzione fork().

Un processo termina, quando fa una chiamata alla funzione exit(), trasformadosi cosi in zombie
(ihhihi),tocca poi al processo genitore eliminarne tutte le tracce. Il processo genitore per 
poter eliminare i suoi processi zombie,deve essere avvisato che ne esiste la necessità 
attraverso il segnale SIGCHLD. Questo segnale agisce proprio sulla funzione exit(), se non 
dovesse funzionare potete anche inviare manualmente il segnale SIGCHLD, al processo genitore,
BADATE AL PROCESSO GENITORE!!. In casi non dico estremi ma inusuali potete terminare il processo
padre. Il processo che è stato ucciso potrebbe avere dei processi figli che in questo caso 
vengono affidati init, il padre di tutti i processi.

****************<[Core-Dump]>******************

Quando un processo termina accidentalmente provoca uno scarico di memoria (permettetemi di
chiamarlo così), o core dump. In pratica si ha un file chiamato core, che contiene l'immagine 
del processo interrotto. Questi file servono solo a documentare l'incidente in cui è incappato 
il processo. Se volete fare una ricerca degli eventuali core che si trovano nel vostro sistema 
fate:

# find / -name core -type f

MA state attenti perchè esistono dei file che si chiamano core ma che non 
hanno niente a che vedere con i core dump, quindi OCCHIO!!!!!!!!.

**************<[Comunicazione tra processi]>*************
Quando l'attività di un processo dipende da un altro,ci deve essere una forma di comunicazione
tra i due.Questo viene normalmente chiamato IPC (Inter Process Comunication) da non confondere 
con il sistema di comunicazione IPC di system V. I metodi di comunicazione sono i pipe e system
V IPC.

I segnali possono essere definiti come dei "messagi" elementari che possono essere inviati ad
un processo, informando quest'ultimo di una particolare condizione che si è manifestata,e di
conseguenza una reazione del processo a cui è arrivato il segnale. Può capitare anche che un 
programma ignori un segnale.Se volete vedere quali sono i segnali andate a vederli su signal.h
Ma ora passiamo in rassegna i segnali più significativi:

- SIGINT:Questo è un segnale di interruzione,che normalmente viene inviato dalla tastiera
tramite la pressione dei tasti ctrl+c (oppure in linux ctrl+z).SIGINT inoltre è intercettabile.
Mi viene in mente qualche implementazione.... :)

- SIGKILL:Penso che questo segnale sia uno dei più conosciuti,serve letteralmente ad "uccidere"
un processo.Inoltre non è intercettabile.

-SIGHUP:Questo viene definito segnale di aggancio che rappresenta l'interruzione di una 
comunicazione tra processi.

Il comando "kill" a differenza di quello che molti pensano, può essere usato per inviare un 
qualsiasi segnale conoscendo, il PID del programma.

*************************<[I PIPE]>*****************

Il termine pipe significa tubo infatti serve per redirigere lo standard output di un programma 
sullo standard input di un altro. Attraverso una shell è possibile collegare più processi tra di
loro utilizzando una pipeline, come vediamo nell'esempio seguente:

$ last | more

Ogni connessione tra processi può essere effettuata tramite l'uso della barra  | pipe, che 
si comporta come un serbatoio provvisorio di dati (definizione del cazzo :=), con accesso
FIFO (FIRST IN FIRST OUT) cioè il primo dato ad essere inserito è il primo ad uscire.

Questi serbatoi FIFO si possono creare esplicitamente senza far ricorso ad una shell,poichè
sono semplicemente dei file definiti FIFO e che possono essere gestiti e creati attraverso
il programma mkfifo. Adesso vi faccio un esempio che comprende tutte le nozioni apprese su le
pipe o più precisamente eseguirò la stessa operazione dell'esempio precedente usando mkfifo.

$ mkfifo  fifo1 fifo2
Crea due file FIFO: fifo1 e fifo2. 
$ cat miofile >> fifo &
Invia miofile a fifo1 senza attendere (&). 
$ sort < fifo1 >> fifo2 &
Esegue il riordino di quanto ottenuto da fifo1 e invia il risultato a fifo2 senza attendere (&). 
$ lpr < fifo2
Accoda la stampa di quanto ottenuto da fifo2. 
I file fifo si possono anche chiamare named pipe e si contrappongono alle normali che vengono
definite pipe anonime.

BROKEN PIPE.
Viene definito broken pipe, l'interruzione di un processo all'interno di una pipeline, che 
invierà un segnale SIGPIPE e di conseguenza si interromperà. La rottura di una pipe provoca
l'interruzione del flusso di dati, e anche l'interruzione dei programmi a cui era diretto.

SYSTEM V IPC
Il system V IPC è un sistema abbastastanza complesso di comunicazione tra processi,che permette
di gestire code di messaggi, semafori e memoria condivisa. 


***********************<[SCHEDULING E PRIORITA']***************

La CPU riesce a gestire la moltitudine di processi che ci sono in un o.s. attraverso una 
suddivisione del tempo, in maniera che a turno ogni processo possa essere eseguito tutto o in
parte.Il metodo con cui vengono regolati questi turni è lo scheduling ovvero pianificazione
di questi processi. La percentuali di tempo (della CPU) che ogni processo ha a sua disposizione
è regolata dalla priorità espressa da un numero. Il valore che rappresenta questa priorità
è inversamente proporzionale al numero stesso, cioè un valore elevato rappresenta una bassa 
priorità quindi meno tempo a disposizione, mentre un valore basso indica una priorità alta
perciò più tempo a sua disposizione. La priorità di esecuzione di un processo è devinita in 
maniera autonoma da parte del sistema, ma può essere modificata dall'utente sommandogli il 
valore definito nice, quindi un valore positivo incrementa la priorità mentre uno negativo
la decrementa.

Bene,per ora abbiamo finito, spero che sia stato interessante e che vi abbia stimolato ad 
approfondire le vostre conoscenze su questo argomento,soprattutto sotto al nostro bene amato
linux che tanto ci permette di sperimentare ed imparare. Ricordatevi che quella che ho scritto 
qui è soltanto una "piccola" introduzione a questo vastissimo argomento. Ho fatto anche qualche
accenno al System V IPC, se vi interessa mandatemi una mail.

PS: Mi trovate anche in irc sui canali #noflyzone,#hackmaniaci e #hack
ed ora .......

Saluti e tnx a :la noflyzone crew che mi ha permesso di partecipare,cityhunter,BIGAlex,cyberdude
e4m, la error404 crew,lord vicio,Xian,[Evil],_1/2matto,AndreaGeddon,Quequero [V]lad.