Cos'è Linux?

Linux è un sistema operativo. Un sistema operativo è un insieme di software e programmi specifici, grazie al quale diventa possibile, per l'utente, interagire con il computer. Windows è un sistema operativo, Android è un sistema operativo, iOS è un sistema operativo, Unix è un sistema operativo. Un sistema operativo è in grado di accettare le nostre richieste ( input ), interpretarle, elaborarle, eseguirle, per poi restituirci il risultato dell'esecuzione ( output ). Un sistema operativo conosce tutto l'hardware collegato al computer, sa come contattarlo e come inviare ad esso i comandi che devono essere eseguiti e i dati che debbono essere elaborati. Un sistema operativo, quindi, è sempre a disposizione dell'utente, sempre pronto ad accogliere le sue richieste. La modalità di immissione dell'input dell'utente determina il tipo di interfaccia utilizzata da un sistema operativo. Un tempo esisteva esclusivamente l'interfaccia testuale: per eseguire un qualsiasi comando, era necessario scriverlo a terminale ed inviarlo al sistema operativo. Oggi, è molto diffusa l'interfaccia grafica a finestre ( Windows ), chiamata Desktop, dove i comandi vengono rappresentati da disegni ( icone ) e l'utente deve solo cliccare sull'icona specifica, per eseguire uno specifico comando. Linux è un sistema operativo Unix-like, essendo composto da un kernel Unix. In realtà, Linux non può essere considerato un sistema operativo Unix completo, poichè il kernel non comprende tutte le applicazioni presenti in Unix, quali le utility per il fileystem, oppure l'interfaccia grafica a finestre, gli editor testuali, i compilatori, etc, anche se questi programmi, come il kernel, possono essere installati in qualsiasi sistema Linux, poichè sono liberamente e gratuitamente disponibili con licenza GPL ( General Public License ). Grazie alla licenza GPL, il codice sorgente del kernel e dei programmi addizionali installati sono aperti ( open source ) e disponibili a chiunque, per poter essere studiati, analizzati, modificati, perfezionati. Molte distribuzioni Linux lasciano il codice sorgente del kernel nella directory:

	/usr/src/

Il kernel ( nocciolo ) è il cuore di un sistema operativo. Il kernel è un programma, il cui compito è accedere a tutti i componenti di un computer, quali il processore, o CPU ( Central Processing Unit ), la memoria RAM, la memoria di massa ( dischi fissi ). Il kernel è il primo programma caricato in memoria, in fase di boot ( accensione o avviamento ) del sistema operativo, e resta in memoria per l'intera sessione di lavoro, relegato in un'area protetta della memoria, un'area che non può essere sovrascritta da altri programmi. Quest'area protetta viene chiamata kernel space ( corrispondente al privileged mode, o modalità con privilegi, o Kernel mode ), in contrasto allo user space ( corrispondente all'unprivileged mode, o modalità senza privilegi, o User mode ), destinato ai programmi utente. Un programma utente non può accedere direttamente alle risorse del computer, ma deve farlo attraverso il kernel, utilizzando le cosiddette system call, funzioni di sistema, che permettono, ad un programma utente, di richiedere al kernel di accedere ad una qualche risorsa del computer. Linux, come tutti i sistemi operativi Unix-like, nasconde, a tutte le applicazioni eseguite da un utente, tutti i dettagli di basso livello relativi all'organizzazione fisica del computer. Quando un programma utente desidera utilizzare una risorsa hardware, deve inviare una richiesta al sistema operativo. Il kernel valuta la richiesta e, se decide di soddisfarla, agisce, nei confronti dei componenti hardware coinvolti, per conto del programma utente originale. Le modalità User Mode e Kernel Mode sono modalità di esecuzione dell'unità centrale ( processore o CPU ). Alcune CPU possono avere più di due modalità di esecuzione, ma tutti i kernel Unix/Linux standard utilizzano solo le due modalità Kernel Mode ed User Mode. Ogni CPU prevede una serie di istruzioni che permettono di passare da una modalità all'altra ( dallo User Mode al Kernel Mode e viceversa ).

Unix e Linux: cenni storici

Anno: 1969. Luogo: AT&T ( American Telephone and Telegraph Incorporated ) Bell Laboratory, New Jersey, US. Protagonisti: Ken Thompson, Dennis Ritchie ed altri ricercatori dei Bell Laboratory. Evento: nasce UNICS ( Uniplexed Information and Computing System ), poi UNIX, un sistema operativo multi-tasking, scritto in linguaggio Assembly. Nel 1973, Ken Thompson e Dennis Ritchie riscrivono il kernel di Unix in un nuovo linguaggio di programmazione, C, scritto proprio da Dennis Ritchie e Ken Thompson, insieme a Brian Kernighan, un loro collega, presso i Bell Labs. Il linguaggio di programmazione C viene, a volte, definito come " il linguaggio assembly di alto livello ". Il linguaggio assembly è intrinsecamente legato alla macchina sulla quale viene utilizzato. Il linguaggio C permette, al contrario, di creare programmi " portabili ", che possono essere eseguiti su macchine diverse. Una vera rivoluzione, a quei tempi! A causa della sua posizione dominante, trattandosi dell'azienda che, in quegli anni, gestiva le linee telefoniche degli Stati Uniti, la Commissione Antitrust americana vietò ad AT&T l'ingresso nel business dell'informatica, negandole la possibilità di vendere software. AT&T, di conseguenza, rinunciò ad esercitare qualsiasi diritto sulla distribuzione del nuovo sistema operativo, Unix, permettendo una sua rapida diffusione, attraverso la distribuzione gratuita del suo codice sorgente alle principali Università sparse nel mondo. Ciascuna di queste Università iniziò a sviluppare nuove applicazioni per il nuovo sistema operativo, generandone, di fatto, molteplici varianti. La più nota di queste varianti fu la variante BSD ( Berckley Software Distribution ), sviluppata dall’Università di Berckley, California, su richiesta del Dipartimento della Difesa americano ( DARPA ). Nel 1984, AT&T venne smembrata, in seguito ad una delibera della Commissione Antitrust americana del 1982, in più società, proprio per spezzarne la posizione di dominio. Scomparso ogni vincolo legale, AT&T fu libera di commercializzare il suo sistema operativo Unix, interrompendo la consuetudine della sua distribuzione libera e gratuita. Unix System III fu la prima release Unix di AT&T protetta ( senza codice sorgente ) e non gratuita, immediatamente seguita dalla più nota release UNIX System V ( SysV o SVR1, System V Release 1 ). Anche la variante BSD ( Berckley Software Distribution ) di Unix, fino al 1988, incluse codice sorgente di AT&T, restando, quindi, legata alla licenza AT&T. Il gruppo di ricerca della University of California a Berkeley, il Computer Systems Research Group ( CSRG ), nel corso degli anni, aveva arricchito il sistema operativo Unix con funzionalità rivoluzionarie, quali la suite di protocolli TCP/IP. Solo nel giugno 1989, la University of California di Berkeley ( UCB ) rilasciò la versione " Networking Release 1 " di Unix, contenente la suite di protocolli di rete TCP/IP, senza alcun pezzo di codice sorgente riconducibile ad AT&T: la release venne rilasciata con una licenza aperta, che lasciava libero chiunque di modificare e distribuire il codice sorgente. Nel giro di un paio di anni, furono riscritti i codici sorgente di tutte le utility di AT&T, fino ad arrivare ad una release completa di Unix, libera da ogni codice sorgente di AT&T: la release Networking Release 2, rilasciata sotto la medesima licenza aperta della precedente release. Nel 1991, uno studente, iscritto presso l'Università di Helsinki, Linus Torvalds, pensò bene di realizzare una versione di Unix che fosse liberamente disponibile alle università ed agli studenti. Nel progetto entrarono migliaia di collaboratori appassionati, dal contributo dei quali si sviluppò il sistema operativo che, oggi, è noto sotto il nome di Linux. Linux è un clone completo di UNIX, che serve sia il computer domestico o aziendale, la workstation, sia i server di qualsiasi dimensione e potenza.

La shell e il terminale

Quando si parla di Linux, ancora oggi, si parla di shell. Perchè è la shell dove Linux esprime tutta la sua potenza, soprattutto nei confronti dei sistemi operativi commerciali, Windows compreso, e racchiude tutta la sua storia, mostrando, qua e là, le tracce dell'antica e solida filosofia Unix. Per un utente medio di Windows, la shell, probabilmente, è, ancora oggi, un oggetto sconosciuto. Eppure, anche Windows, ancora oggi, conserva una shell, che viene chiamata: "emulatore di DOS" oppure "emulatore di terminale". E' una finestra nera, in cui l'utente può inserire alcuni comandi, per chiedere al sistema operativo di eseguire alcuni programmi. Mentre la storia di Windows è una rincorsa continua ad un'interfaccia grafica ( GUI ) sempre più sofisticata, grazie alla quale l'utente possa interagire con i programmi, senza porsi troppe domande ( ambiente Desktop ), la storia di Linux è una storia, fondamentalmente, di shell. Naturalmente, Linux possiede più di un desktop ( interfaccia grafica ) da offrire ai suoi utenti, così da rendere la vita facile anche ai nuovi arrivati, abituati esclusivamente all'ambiente grafico di Windows. E un utente può benissimo sopravvivere, anche in ambiente Linux, senza mai aprire una finestra di shell. Ma, nel momento in cui un utente decidesse di voler comprendere il reale funzionamento della macchina sulla quale opera, non esiste al mondo un sistema operativo così ricco di comandi e di possibilità, quale Linux. Non solo: se avete un sito web, installato su un qualche server nel mondo, è altamente probabile ( ed auspicabile ) che quel server sia gestito da un sistema operativo GNU/Linux. In questo caso, sarebbe davvero auspicabile che voi interagiate con il vostro server, utilizzando la shell. In Unix e Linux, la shell è un semplice programma. Ciò che rende la shell un programma un po' speciale è che la shell è il programma che interpreta tutti i comandi che inserite nella finestra del terminale, esegue tutti i programmi che, attraverso la riga di comandi, avete richiesto di eseguire e, normalmente, coordina quello che avviene tra voi ed il sistema operativo ( kernel ). La shell viene eseguita all'interno di una finestra terminale. Per aprire un terminale, da un'interfaccia grafica, dovreste trovare un menù "Terminale" in uno dei menù della finestra principale. Per esempio, in Xubuntu, il terminale si trova in:

Applicazioni
	Accessori
		Terminale

Questo tipo di shell viene chiamata "shell interattiva non di login", poichè il login utente è stato già eseguito al momento dell'accesso al desktop ( GUI: Graphical User Interface ). In alternativa alla "shell interattiva non di login", è possibile premere i tasti CTRL+ALT+F1 per aprire il terminale ( CTRL+ALT+F2 per aprirne un secondo, e così via ) e CTRL+ALT+F7 ( o CTRL+ALT+F8 ), per chiuderlo. Attenzione: con questo secondo metodo, il terminale sostituirà interamente l'interfaccia grafica, simulando alla perfezione il processo di accesso al sistema di shell, compreso il processo di autenticazione ( login e password ). In questo caso, abbiamo una "shell di login interattiva": il solo modo per tornare all'ambiente grafico sarà: chiudere il programma di shell:

	exit

e chiudere il terminale: CTRL+ALT+F7. Se volete aprire una shell sul vostro server remoto, invece, è necessario utilizzare un programma che permetta di aprire una shell in remoto, quali SSH ( Secure Shell ) o Telnet. Il programma SSH sarebbe preferibile, visto che permette la cifratura dei dati. Ma, attenzione: per potersi connettere ad un server tramite SSH o Telnet, è necessario essere abilitati. Se il vostro sito web è installato su un server condiviso da decine o centinaia di altri utenti, come nel caso dei servizi di hosting, è molto probabile che voi non abbiate l'abilitazione all'utilizzo di questi comandi. In questo caso, solitamente, il solo protocollo che siete abilitati ad utilizzare è FTP, che, come dice il nome stesso, File Transfer Protocol, permette il semplice trasferimento ( invio e ricezione ) di file, senza alcuna possibilità di inviare comandi al vostro server Una volta, il terminale era un apparato fisico ( composto da un monitor ed una tastiera ) che accettava l'input dell'utente, lo inviava ad un computer remoto ( host ) e stampava a video ( monitor ) i dati ricevuti dal computer host. Si chiamava TTY ( TeleTYpewriter ) ed inviava i suoi dati ad un modem, che utilizzava, come mezzo di trasporto, una linea telefonica. Un modem trasmette i dati in modalità seriale, un bit alla volta. Ecco perchè, nel tempo, il termine TTY venne assegnato anche a tutte quelle periferiche che utilizzano la stessa modalità seriale di trasmissione. Erano gli anni in cui non esistevano i personal computer ed il solo modo di accedere alle capacità computazionali di un computer era collegarsi ad esso via terminale. Ad uno stesso computer venivano collegati più terminali: uno per ciascun utente connesso. Ciascun terminale era collegato al computer centrale attraverso una porta seriale. A ciascuna porta seriale veniva assegnato un nome ed un numero:

	ttyS0
	ttyS1
	ttyS2
	...

La porta ttyS0 corrisponde alla porta seriale COM1 di DOS o Windows, mentre la porta ttyS1 corrisponde alla porta COM2. Quando un computer host veniva acceso, eseguiva un programma chiamato "getty" ( GET TTY ) che, a sua volta, eseguiva il programma "login", per permettere all'utente di accedere al sistema remoto. Ciascun terminale fisico connesso al computer host doveva avere il suo processo "getty" aperto. Una volta entrati nel sistema host, era possibile digitare un testo o un comando, utilizzando la tastiera del terminale: le lettere digitate venivano inviate al computer host, il quale le reinviava ( echo ) immediatamente allo schermo del terminale ( Full Duplex Mode ). Nel caso di un comando, il computer host inviava al terminale l'output generato dall'esecuzione del comando. Oggi, visto che non ha più senso parlare di terminali fisici, questi ultimi sono stati sostituiti dai terminali virtuali ( pseudo terminale ), software che simulano le operazioni che, una volta, venivano svolte dai TTY fisici. Uno pseudo terminale, quindi, viene generato e gestito da un software emulatore di terminale, senza essere connesso ad alcuna porta seriale, né ad alcuna periferica reale ( terminale ). Per sapere quale emulatore di terminale è in esecuzione nel vostro sistema, stampate a video il contenuto della variabile d'ambiente TERM:

	echo $TERM

Uno pseudo terminale è composto da una coppia di periferiche virtuali, che rappresentano il terminale utente reale ( slave ) e l'host al quale il terminale è connesso ( master ). Tutto ciò che viene scritto sul master viene inviato al processo associato allo slave, proprio come se lo slave fosse un terminale. Allo stesso tempo, tutto ciò che viene scritto nello slave viene inviato al processo associato al master. Gli pseudo terminali vengono usati da applicazioni quali i programmi di accesso remoto al sistema, ssh(1), rlogin(1), telnet(1) e dagli emulatori di terminale. Per inviare un messaggio testuale ad un terminale ( reale o virtuale ), è sufficiente reindirizzare l'output di un qualche comando alla periferica ( reale o virtuale ) appropriata. Se si ha a che fare con un terminale reale ( tty ):

	echo test > /dev/ttyS1

Se, invece, si ha a che fare con un terminale virtuale:

	echo test 1>/dev/pts/1

Per sapere quale terminale ( o pseudo terminale ) è in uso, eseguire:

	tty

La shell è un programma e, come per tutti i programmi, è possibile reperirne diverse versioni. E' possibile che tra una shell e l'altra esista una qualche differenza, anche se la gran parte dei comandi GNU/Linux dovrebbero essere comuni a tutte le shell. Quale shell carica, di default, il vostro sistema? Per saperlo, leggete il valore di una delle due variabili $0 ( zero ) o $SHELL:

	echo $0
	echo $SHELL

E' molto probabile che i valori restituiti da questi comandi siano:

	bash
	/bin/bash

Questo perchè bash o Bourne Again Shell è la shell GNU standard. A proposito: il comando echo fa quello che dice: ripete ( echoes ) quello che riceve come input. Ma, torniamo alla nostra shell. Quante shell esistono in Linux? Per saperlo, possiamo leggere ( cat ) il file shells, nella cartella etc:

	cat /etc/shells

/bin/bash
/bin/sh
/bin/tcsh
/bin/csh
/bin/dash

Come sa, il sistema, quale shell caricare? Quando un utente entra nel sistema, esegue il login, inviando al sistema il proprio username ( e la password ). Il sistema verifica che username e password siano corretti, andando a leggere il file:

	/etc/passwd

In questo file, sono memorizzati tutti gli utenti presenti nel sistema e, per ciascuno di essi, è riportata la shell di default abbinata. Per esempio:

mulo:x:504:504:mulo,,,:/home/mulo:/bin/bash

Avete bisogno di caricare, momentaneamente, una shell diversa da bash? Per esempio, dash? Lanciatela, da shell, come uno dei tanti comandi, scegliendo una delle due sintassi:

	dash
	/bin/dash

Entrambi questi comandi, lanciano una shell dash. O meglio: una subshell, cioè una shell dash, eseguita come processo figlio della shell bash. Ma, ricordate: da questo momento, state conversando con una shell dash, non più bash. Non innervositevi se, inserendo un comando che state leggendo dalla guida bash, non riuscite a farlo eseguire. Ora siete in dash! Per chiudere la shell dash e tornare alla shell bash, digitate:

	exit

I file di startup della shell Bash

La shell di Bash, quando viene lanciata, carica una serie di file, grazie ai quali il sistema operativo crea un ambiente di lavoro ( environment ), ottimale per l'esecuzione della shell stessa. I file di startup salvati nella directory:

	/etc

vengono usati, generalmente, per le impostazioni globali, mentre, per le impostazioni personalizzate, ci si serve dei corrispondenti file, salvati nella directory HOME di ciascun utente registrato nel sistema. Se il nome di un utente fosse pierpaolo, per esempio, la directory HOME di questo utente si troverebbe nella directory:

	/home/pierpaolo

Per l'utente pierpaolo, inoltre, la directory HOME viene rappresentata con il solo simbolo:

	~

La sottodirectory Documenti dell'account pierpaolo, quindi, può essere rappresentata in una delle due seguenti sequenze:

	/home/pierpaolo/Documenti
	~/Documenti

Una shell interattiva di login viene eseguita subito dopo la verifica delle credenziali, effettuata dal programma:

	/bin/login

e legge i file:

	/etc/passwd
	/etc/profile
	~/.bash_profile
	~/.bash_login
	~/.profile

Una shell interattiva non di login, invece, viene eseguita da un programma ad ambiente grafico, quale xterm o konsole, ereditando, da quest'ultimo, le variabili d'ambiente e caricando il file

	/etc/bash.bashrc
	~/.bashrc

per eventuali configurazioni di startup addizionali. Molte distribuzioni Linux utilizzano, per la shell interattiva non di login, anche il file di configurazione:

	/etc/bashrc

Le istruzioni e le variabili che desideriamo vengano eseguite e impostate, per la nostra sessione di lavoro, quindi, devono essere inserite in uno di questi file di startup, in modo che siano caricate in memoria all'apertura del sistema. Una variabile può essere creata o modificata da shell, o direttamente:

	name[=word]

oppure attraverso il comando builtin ( codificato nel kernel del sistema operativo ) export:

	export [-fn] [name[=word]] ...

oppure, ancora, attraverso il comando builtin ( codificato nel kernel del sistema operativo ) set:

	set [--abefhkmnptuvxBCEHPT] [-o option] [arg ...]
	set [+abefhkmnptuvxBCEHPT] [+o option] [arg ...]

	set [name[=word]] ...

In questi ultimi esempi, abbiamo creato la variabile name, impostandone il valore a word. Eseguendo questi comandi dal terminale, renderemo disponibili le nuove variabili o i nuovi valori delle variabili solo per la sessione corrente. Inserendo questi comandi, invece, nei file di startup, renderemo disponibili le nuove variabili o i nuovi valori delle variabili per la sessione corrente e per tutte le sessioni future.

Le variabili d'ambiente

Esistono una serie di variabili che sono necessarie al sistema operativo per funzionare correttamente ed alla shell per poter eseguire alcuni comandi. Queste variabili vengono chiamate variabili d'ambiente ( environment variables ) e sono gestite direttamente dalla shell. Al contrario delle normali variabili di shell, le variabili d'ambiente vengono ereditate da tutti i programmi eseguiti dalla shell, incluse le nuove shell:

	bash

I nuovi processi ricevono una copia di queste variabili e ciascun processo è in grado di leggerle, manipolarle, assegnarle ai loro processi figli ( child ). Il comando printenv stampa a video tutte le variabili d'ambiente:

	printenv

oppure, il valore della variabile d'ambiente specificata:

	printenv PATH

E' possibile creare una nuova variabile d'ambiente, utilizzando il comando builtin ( codificato nel kernel del sistema operativo ) export.

Il comando export

Il comando export esporta una variabile. Esportare significa: rendere la nuova variabile o il nuovo valore di una variabile preesistente disponibile all'ambiente globale di shell, in modo che sia utilizzabile da qualsiasi altro programma o comando. Il comando export, quindi, fa, di una variabile di shell, una variabile d'ambiente:

	export [-fn] [name[=word]] ...

L'opzione -f dice a export che name è una funzione. L'opzione -n dice a export che name non è più da esportare. Un esempio pratico: il comando:

	NEW='test'

crea una nuova variabile, chiamata NEW, il cui valore è 'test'. Per verificare se NEW è una variabile d'ambiente, proviamo ad eseguire:

	printenv NEW

Risultato? Nulla. La variabile NEW viene riconosciuta solo dal comando echo:

	echo NEW

Quindi, la variabile NEW non è una variabile d'ambiente. Questo significa che la variabile NEW sarà disponibile esclusivamente alla mia shell, ma non alle nuove eventuali shell, o ai programmi che eseguirò dalla mia shell. Per rendere NEW una variabile d'ambiente, dovrò esportarla:

	export NEW

Proviamo, ora, a ripetere il comando printenv:

	printenv NEW

e scopriremo che la variabile NEW è diventata una variabile d'ambiente. Per farla tornare a semplice variabile di shell, dovremo eseguire:

	export -n NEW

Da questo momento, la variabile verrà letta solo dal comando echo. Naturalmente, è possibile dichiarare ed inizializzare la nuova variabile d'ambiente in un solo comando:

	export NEW='test'

Nelle assegnazioni, non devono essere lasciati spazi, tra il segno uguale ( = ), il nome della variabile ed il suo valore. Il comando export, con l'opzione -p, elenca tutte le variabili esportate:

	export -p

Il comando unset

Il comando builtin ( codificato nel kernel del sistema operativo ) unset rimuove le variabili e le funzioni di shell:

	unset [-fv] [name ...]

dove -f indica che name è una funzione, mentre -v indica che name è una variabile ( impostazione di default ). Le variabili di sola lettura, read-only, quali PATH, PS1, PS2, MAILCHECK, non possono essere eliminate.