| Guida dell'amministratore di sistema di Linux: Versione 0.6.2 | ||
|---|---|---|
| Indietro | Capitolo 2. Panoramica di un sistema Linux | Avanti |
Questa sezione descrive alcuni dei servizi di UNIX più importanti, ma senza scendere molto nei dettagli; verranno descritti più accuratamente nei capitoli successivi.
Il servizio più importante di un sistema UNIX è fornito da init. init viene inizializzato come primo processo su ciascun sistema UNIX ed è l'ultima cosa che il kernel fa all'avvio. Quando parte, init continua il processo di avvio portando avanti vari compiti (controlla e monta i filesystem, avvia i daemon ecc.).
L'elenco esatto delle cose che init fa dipende dal suo tipo: ce ne sono diversi tra cui scegliere. init di solito fornisce il concetto di modalità a singolo utente, in cui nessuno si può collegare e root usa una shell alla console; la modalità usuale viene chiamata modalità multiutente. Alcuni tipi generalizzano questo concetto in runlevel; le modalità utente singolo e multiutente sono considerate due runlevel, e ce ne possono essere altri, ad esempio, per far girare X sulla console.
Nelle normali operazioni, init si assicura che stia girando getty (per poter far collegare gli utenti), e adotta i processi orfani (quelli il cui padre è morto: in UNIX tutti i processi devono essere in un singolo albero, quindi gli orfani devono venire adottati).
Quando il sistema viene spento, è init che deve uccidere tutti gli altri processi, smontare i filesystem e fermare il processore, oltre agli altri compiti per cui è stato configurato.
I login dai terminali (attraverso linee seriali) e dalla console (quando non si sta usando X) vengono forniti dal programma getty. init avvia una getty separata per ogni terminale da cui sono consentiti i login, getty legge il nome dell'utente ed avvia il programma login, che legge la password; se questa corrisponde al nome utente, login avvia la shell. Quando questa termina, cioè l'utente si scollega, o quando login termina perché il nome dell'utente e la password non corrispondono, init lo nota ed avvia un'altra copia di getty. Il kernel non ha nozione dei login, che vengono tutti gestiti dai programmi di sistema.
Il kernel e molti programmi di sistema producono messaggi di errore, di avvertimento e di altro tipo. Spesso è importante che questi messaggi possano essere letti in un secondo tempo, anche dopo parecchio, quindi devono essere scritti in un file. Il programma che lo fa è syslog, che può essere configurato per distribuire i messaggi in file diversi a seconda di chi li genera o del loro grado di importanza; ad esempio quelli del kernel sono spesso rediretti in un file separato dagli altri, dato che spesso sono più importanti e devono essere letti regolarmente per individuare gli eventuali problemi.
Sia gli utenti che gli amministratori di sistema hanno spesso bisogno di avviare periodicamente dei programmi, ad esempio l'amministratore di sistema potrebbe voler avviarne uno che ripulisca le directory che contengono file temporanei (/tmp e /var/tmp) dai file vecchi, per evitare che i dischi si riempiano, dato che non tutti i programmi cancellano correttamente i file generati.
Il servizio di cron funziona proprio per questo. Ciascun utente ha un file crontab, dove elenca i comandi che vuole eseguire ed il momento in cui farlo; il daemon cron avvia poi i comandi scelti al momento specificato.
Il servizio di at è simile a cron, ma vale per una sola volta: il comando viene eseguito al momento indicato, ma non viene ripetuto.
UNIX e Linux non hanno incorporata l'interfaccia nel kernel, ma la fanno implementare da programmi a livello utente, sia per l'ambiente testuale che per quello grafico.
Questa soluzione rende il sistema più flessibile, ma ha lo svantaggio che è facile implementare un'interfaccia diversa per ciascun programma, rendendo il sistema più difficile da imparare.
L'ambiente grafico usato principalmente con Linux si chiama Sistema X Window (in breve, X). X stesso non implementa un'interfaccia utente, ma solo un sistema di finestre, cioè degli strumenti con cui poterne implementare una. I tre stili più conosciuti in X sono Athena, Motif e Open Look.
Una rete è un mezzo per connettere due o più computer in modo che possano comunicare tra di loro. I metodi usati di connessione e comunicazione sono piuttosto complessi, ma il risultato finale è molto utile.
I sistemi operativi UNIX hanno molte capacità di connessione in rete. La maggior parte dei servizi di base (i filesystem, la stampa, i backup ecc.) possono essere usati attraverso la rete; questo può rendere l'amministrazione di sistema più semplice, dato che permette di centralizzare i compiti amministrativi, sfruttando nel contempo i lati positivi dei microcomputer e dell'informatica distribuita, come i costi minori e una più alta tolleranza degli errori.
Questo libro, comunque, dà solo un accenno sulle reti; per ulteriori informazioni c'è la Guida dell'amministratore di rete di Linux (Linux Network Administrators' Guide [NAG]), che comprende anche una descrizione di base del funzionamento delle reti stesse.
I login in rete funzionano in modo leggermente diverso da quelli normali: in questi ultimi infatti c'è una linea seriale fisica separata per ciascun terminale attraverso cui ci si collega, mentre per ciascuna persona che si collega via rete c'è una connessione virtuale separata, e ce ne possono essere infinite[1]. Non è quindi possibile avviare una getty separata per ciascuna connessione virtuale possibile. Ci sono poi diversi modi per collegarsi attraverso una rete: i principali nelle reti di tipo TCP/IP sono telnet e rlogin.
I login di rete hanno, invece di un insieme di getty, un daemon singolo per ciascun modo di collegamento (telnet e rlogin hanno daemon separati) che sta in ascolto per i tentativi di login in ingresso. Quando ne nota uno, inizializza una copia di se stesso per gestire quel singolo tentativo; l'istanza originale continua ad aspettarne altri. La nuova istanza funziona in modo simile a getty.
Una delle cose più utili che si possono fare con i servizi di rete è la condivisione di file attraverso un filesystem di rete. Quello che viene usato di solito si chiama Network File System, o NFS, ed è sviluppato dalla SUN.
Con un filesystem condiviso qualsiasi operazione su file fatta da un programma su una macchina viene spedita attraverso la rete ad un altro computer. In questo modo si inganna il programma e gli fa pensare che tutti i file sull'altro computer siano in realtà sul computer su cui sta girando, il che rende molto semplice la condivisione di informazioni, non richiedendo modifiche ai programmi.
La posta elettronica è di solito il metodo più importante per comunicare usando il computer. Un messaggio di posta elettronica viene immagazzinato in un file in un formato speciale e per inviare e leggere i messaggi vengono usati dei programmi appositi.
Ciascun utente ha una casella di posta in arrivo (un file nel formato speciale) dove viene immagazzinata tutta la nuova posta in ingresso. Quando qualcuno spedisce un messaggio, il programma di posta ritrova la casella del destinatario e lo aggiunge al file. Se la casella di posta del destinatario si trova su un altro computer il messaggio viene inviato a quella macchina, che lo aggiunge alla casella nel modo che ritiene migliore.
Il sistema di posta consiste di molti programmi: la distribuzione a caselle locali o remote viene fatta dall'agente di trasferimento di posta (mail transfer agent o MTA), cioè sendmail o smail, mentre i programmi utilizzati dagli utenti sono molti e vari (gli agenti di posta utente, mail user agent o MUA, come ad esempio pine o elm). Le caselle di posta vengono in genere tenute in /var/spool/mail.
Solo una persona alla volta può usare una stampante, ma è poco economico non condividerla tra vari utenti. La stampante viene quindi gestita da un software che implementa una coda di stampa: tutti i job di stampa vengono messi in una coda e quando la stampante ne ha finito uno gliene viene mandato un altro automaticamente. Questo solleva gli utenti dall'organizzazione della coda di stampa e dal litigare per il controllo della stampante[2].
Il software di stampa fa anche lo spool delle stampe sul disco, cioè il testo viene mantenuto in un file finché il job è in coda. Ciò permette ad un programma applicativo di inviare velocemente i job di stampa al software di coda; l'applicazione non deve così aspettare finché il job è realmente stato stampato per poter continuare. È veramente conveniente, dato che permette di stampare una versione di un file e non dover aspettare che abbia finito per farne una nuova completamente diversa.
Il filesystem è diviso in molte parti: di solito in un filesystem radice, con /bin, /lib, /etc e /dev che formano un singolo filesystem, /usr con i programmi ed i dati che non vengono modificati, /var con quelli che vengono modificati (come i file di log), ed /home con i file personali dei vari utenti. A seconda della configurazione dell'hardware e delle decisioni dell'amministratore di sistema la divisione può cambiare, e potrebbe esserci anche un unico filesystem che comprende tutto.
Il Capitolo 3 descrive la struttura del filesystem abbastanza approfonditamente: il Linux Filesystem Standard [LFS] lo fa in maniera ancora più dettagliata.
| [1] | Beh, almeno ce ne possono essere parecchie. La larghezza di banda della rete è ancora una risorsa piuttosto scarsa, c'è ancora una limitazione pratica al numero di login contemporanei su una singola connessione di rete. |
| [2] | Invece formano una nuova coda alla stampante, aspettando le stampe, dato che nessuno sembra mai capace di far sapere esattamente al software di coda quando i vari job sono veramente finiti: un gran passo avanti per le relazioni sociali inter-ufficio. |