Il termine Linux, a rigore, si dovrebbe riferire solo al kernel, un computer con Linux oltre al kernel contiene molto altro:

• librerie di base, ( librerie del progetto GNU della FSF ) che permettono al software di accedere ai servizi offerti dal kernel (system call), che implementano funzioni matematiche o altro;
• utilities di sistema della GNU, come : editor emacs, archiviatore tar, compressore gzip , plotutils per semplici grafici, la shell bash, etc .etc
• software di sistema; sviluppato da gruppi diversi, che implementa tutte le funzionalita' che non sono nel kernel, come servizi di rete, sistema grafico X11, window managers, desktops ( gnome e KDE) , sistema di stampa, etc .etc
• software di sviluppo: in particolare i compilatori GNU, i debugger, i sistemi di sviluppo come make o grafici come il kdevelop.
• software applicativo: OpenOffice, gimp, snd, database, server web etc etc.

• kernel: il kernel e' il "cuore" del sistema, e' un programma sempre residente in memoria, controlla tutto il sistema e l'accesso alle device.
  • Il kernel di Linux e' monolitico, cioe' fatto di un unico grande programma, non di piu' programmi indipendenti che comunicano con messaggi o altro (approccio a micro-kernel)
  • Il kernel e' modulare, cioe' parti del kernel possono essere caricate o scaricate dal sistema, a seconda delle necessita', in modo automatico od a richiesta dell'utente, mentre il computer va.
• multi-processing : molti processi sono presenti contemporaneamente nel sistema e si alternano nell'uso della CPU , in base ad algoritmi di scheduling gestiti dal kernel. I processi hanno una priorita' , che puo' essere cambiata dall'utente. Ogni processo nel sistema e' identificato da un numero: il "pid". La creazione dei processi avviene in modo gerarchico (meccanismi di fork ed exec con cui il processo padre crea un processo figlio).
• memoria virtuale: i processi vedono un loro spazio di indirizzi di memoria, (virtuale) e solo quello. In un certo senso ogni processo "crede" di avere a disposizione esclusiva un computer con Gbytes di memoria. Se un processo cerca di scrivere fuori da questo spazio causa un errore di "segmentation fault" ed il processo termina, ma in nessun modo un processo puo' interferire con la memoria utilizzata da altri processi.
  Il sistema operativo gestisce la memoria in modo da far corrispondere la memoria virtuale di ogni processo a quella vera. Questo viene fatto organizzando la memoria in "pagine", e portando le pagine dal disco in memoria solo quando servono, in modo che i processi possano utilizzarle, in questo modo occupano la memoria solo le pagine che servono al momento.
  Se un processo ha bisogno di piu' memoria di quanta ne esista realmente nel sistema, la memoria viene simulata su disco, utilizzando uno o piu' file (swap files ) o partizioni del disco (swap partitions). Quando questo si verifica si dice che si "swappa" e le prestazioni del sistema calano in modo considerevole, poiche' l'accesso al disco e' molto piu' lento dell'accesso alla memoria.
  Un processo puo' comprendere piu' threads; che sono specie di sotto-processi, che pero' condividono lo stesso spazio virtuale di indirizzi.
  
• Multi-user :
  • molti utenti possono essere contemporaneamente presenti nel sistema, i loro processi si alternano nel tempo nell'uso della CPU e delle risorse. I turni sono gestiti dal kernel, in base a complessi algoritmi di "scheduling".
  • L'utente root e' un utente speciale, che puo' fare qualunque cosa sul sistema, gli altri utenti hanno limiti, ed ognuno ha un suo spazio disco riservato. Non va utilizzato root se non quando serve.
  • Ogni utente e' identificato da un numero "uid" , gli utenti sono raggruppati in gruppi identificati da un numero "gid". Ogni utente ha un gruppo di appartenenza principale, ma puo' far parte anche di altri gruppi.
    Ogni file appartiene ad un utente e ad un gruppo, siccome anche le "device" sono viste come files, ed appartengono ad un utente e ad un gruppo, l'uso opportuno di utenti e gruppi permette di decidere chi puo' utilizzare certi dispositivi, come CD, floppy, modem etc etc. Il meccanismo e' spartano ma funzionale. Solo recentemente in Linux sono stati inseriti meccanismi di protezione piu' ricchi, del tipo delle ACL di Windows o del vecchio sistema VMS dei Vax Digital.
  
  
• Indipendenza delle componenti:
  • kernel, software si sistema, software applicativo, librerie, sono in zone del disco ben separate secondo un'organizzazione quasi standard.
  • il comportamento delle varie componenti del software e' definito da files testuali, (files di configurazione) ogni software ha i suoi, ognuno con la sua sintassi.
  • ogni software puo' essere fermato, fatto partire, modificato mentre il computer va, indipendentemente dalle altre parti.
• Dipendenza dalle librerie.
  • Le librerie sono programmi di uso comune, contenuti in files di formato particolare, per essere utilizzati da altri programmi. Un programma, dopo essere stato compilato, viene "linkato" con le librerie, ovvero in esso vengono inserite le parti delle librerie che gli servono. Nel caso di "link statico" le librerie vengono di fatto inserite dentro l'eseguibile, nel caso di "link dinamico" nell'eseguibile viene inserito solo la posizione delle librerie nel file system e solo all'esecuzione si va a cercare la libreria. Questo permette di avere eseguibili piu' piccoli e maneggevoli. Supera inoltre certi problemi di licenze.
    Purtroppo accade che le librerie di base siano aggiornate continuamente e che non venga garantita la compatibilita' con le vecchie versioni.
    Garantire la retrocompatibilita' renderebbe il lavoro molto piu' oneroso e sarebbe un freno al miglioramento delle librerie.
    Quando escono nuove versioni delle librerie occorre di nuovo compilare e linkare tutto il software che le usa in modo dinamico.
    Una distribuzione deve avere tutte le versioni delle librerie ed i programmi perfettamente coerenti. Ed aggiornare una componente del sistema senza dover mettere le mani da per tutto a volte e' difficile.
    Questo problema dovrebbe essere meno grave in Windows, che invece cerca di garantire la retrocompatibilita', a prezzo di un prodotto piu' complesso da mantenere e sviluppare.

• si possono avere massimo 4 partizioni primarie;
• per avere piu' di 4 partizioni su usa un trucco: una partizione primaria puo' essere una partizione estesa, che contiene tante partizioni logiche, che sono collegate fra loro come in una link-list, cioe' ognuna ha un header che punta alla partizione successiva.
• Nei primi 512 bytes del disco ( un settore) si trova l' MBR (master boot record), in cui viene messo un programmino che carica il sistema operativo ( programma di boot, creato col software lilo o grub). L'MBR contiene anche la tabella delle partizioni (primarie)
• Nei primi 512 bytes di ogni partizione si trova il BR ( boot record), anche qui puo' stare un programma per il boot.
• una partizione puo' contenere:
  • un file system, cioe' un insieme di files, organizzati in una struttura gerarchica
  • uno spazio di swap ( per la memoria virtuale )

• In un sistema Linux possono coesistere file systems diversi, ognuno in una sua partizione, questi possono essere:
  • ext2 : il file system di default di Linux
  • ext3 : una estensione di ext2, che prevede il journal.
    Il journal contiene una registrazione delle ultime transazioni effettuate sul disco, che possono essere quindi recuperate in casi di crash del sistema.
  • reiserfs : un altro file system con journal
  • nfs : un file system di rete, cioe' che e' su un altro sistema unix
  • VFAT : filesystem di Windows 98
  • NTFS : il file system di Windows NT ed XP
  • ISO9660 : il file system standard dei CD-ROM
  • i file systems dei diversi unix e tanti altri.
• i file systems vanno collegati in un unico file system globale, con un'unica radice. L'operazione di collegamento si fa con il comando mount ( si dice che si monta il file system, il comando umount smonta ); mount fa corrispondere la radice del file system da montare con un direttorio del file system globale. Eventuali files presenti nella directory vengono nascosti. Esistono sempre, ma non sono piu' visibili finche' nella directory e' montato il file system.

• Case sensitive: nomi di files, comandi, etc. sono case sensitive
• Nomi files:
  • ammessi nomi lunghi,
  • le estensioni non hanno significato particolare
  • si consiglia di evitare caratteri speciali e blanks nei nomi dei files.
• Tipi di files:
  • regular files: quelli usuali,
  • directory: files che contengono dati che fanno corrispondere i nomi dei files ai descrittori dei files. Questi descrittori, detti i-node, si trovano in blocchi speciali del file system, e contengono tutte le informazioni sui files ed una mappa dei settori occupati dal files sul disco
  • links
    • soft links: files finti, che contengono solo un indirizzo che punta al file vero, usare un link e' equivalente ad usare il file, ma:
      • distruggere il link non tocca il file
      • i permessi di accesso del link non contano, contano quelli del file vero.
      • il link puo' puntare ad un file di un filesystem diverso
    • hard links: alias del nome del file, indistinguibile dal nome vero, devono essere nello stesso filesystem del file vero.
  • pipes, sockets : sono canali di comunicazione fra processi
  • device files: le device sono viste dal sistema come files, possono essere a blocchi od a caratteri. Cioe' che usano un buffer e trasmettono i dati a blocchi, oppure che trasmettono un byte alla volta.
• Accesso ai files :
  • i files hanno un proprietario ( in genere chi li ha creati )
  • i files appartengono ad un gruppo ( il gruppo di chi li ha creati )
  • separatamente per le 3 categorie: il proprietario, il gruppo, e tutti gli altri, sono definiti, tramite una bit-mask i seguenti diritti di accesso:
    • w: un permesso di lettura, che permette di leggere il file ( o listare i files di un direttorio)
    • r: un permesso di scrittura, che permette di scrivere sul file ( o creare files in un direttorio)
    • x: un permesso di esecuzione che permette di far correre un eseguibile ( o entrare in un direttorio)
  • Il proprietario puo' cambiare i permessi con chmod, esempio:
    • chmod u+rwx file : il proprietario (u) ha permessi read, write execute sul file
    • chmod g-w file : al gruppo e' tolto il permesso di scrittura
    • chmod o=r file: tutti gli altri possono solo leggere il file
    • chmod a+rwx : chiunque puo' fare tutto sul file
  • s: permesso setuid; un eseguibile assume i poteri del proprietario, quando viene eseguito , anche se lo esegue un altro utente;
  • s: permesso setgid; un eseguibile assume i permessi del suo gruppo, quando viene eseguito, anche se lo esegue un utente di un altro gruppo;
  • t: sticky bit: in un direttorio con questo bit settato i files dei diversi utenti possono essere cancellati solo dal proprietario ( si usa su /tmp )
  • root puo' cambiare proprietario e gruppo di un file col comando chown, Es.:
    • chmod max:gruppo3 file : il file ora appartiene all'utente max ed al gruppo3

• / : root : radice del file system
• /etc : files di configurazione dei programmi e del sistema
• /bin : programmi di base (in genere statically linked)
• /sbin : programmi di base di sistema (in genere statically linked)
• /lib : librerie di sistema, che servono ai programmi in /bin ed in /sbin, e moduli del kernel in /lib/modules
• /dev : device drivers
• /tmp : files temporanei
• /var : files di sistema di dimensioni variabili nel tempo
  • /var/log : Log di sistema (ove viene registrato cosa accade nel sistema)
  • /var/spool : files relativi a code di stampa, per i mail etc.
    • /var/spool/mail : posta in arrivo
    • /var/spool/lpd : code di stampa
• /usr : software di uso generale
  • /usr/bin : eseguibili
  • /usr/lib : librerie
  • /usr/X11R6 : sistema grafico X11
  • /usr/doc : documentazione
  • /usr/include : include files del C
  • /usr/man : help in linea
  • /usr/share : parti comuni a vari programmi
  • /usr/src : sorgenti
    • /usr/src/linux : sources del Kernel di linux
• /usr/local oppure /opt : software che non fa parte del sistema, in senso stretto, ma di uso comune ai diversi utenti,
• /home una directory per ogni utente del sistema

• Il BIOS carica il boot program ( in MBR, floppy o CD )
• il boot program carica in memoria il kernel ( file /boot/vmlinuz) , il kernel viene eseguito e gestisce il sistema. Il kernel e' sempre in memoria, non viene mai swappato, non viene interrotto da altri processi (ma il kernel 2.6 puo' essere interrotto (pre-empitive). Successivamente in kernel compie le seguenti azioni:
  • inizializza tutte le sue tabelle interne;
  • inizializza l'hardware;
  • fa partire il processo init in user space: ( init e' il programma: /sbin/init oppure /etc/init oppure /bin/init) init e' il processo con pid=0;
    • init esegue quanto indicato in /etc/inittab ; che specifica processi associati a terminali virtuali, a modems etc. che devono essere fatti partire;
    • in base a quanto specificato in /etc/inittab vengono eseguiti i files in /etc/rc0.d , rc1.d etc. che fanno partire tutti i vari processi del sistema;
    • il processo init si mette in "idle" ed aspetta comandi, anche il kernel si mette in attesa e reagisce a chiamate di sistema ed interrupts.
    • I processi associati ai terminali virtuali attendono che un utente si colleghi, controllano che sia autorizzato ad entrare nel sistema, poi fanno partire una shell che accetta i suoi comandi.
    • Su alcuni terminali virtuali vengono fatti partire dei server X ed un display manager, che fa collegare l'utente in un ambiente grafico.
    I files che fanno partire i processi sono tutti in /etc/init.d;
    distribuendo in modo opportuno links a questi files nelle directory /etc/rc0.d , rc1.d etc. vengono definiti i modi operativi del sistema (run levels); i files che fanno partire i processi del runlevel 1 sono in /etc/rc1.d , per il runlevel 2 in /etc/rc2.d etc. I links iniziano con S se fanno partire un processo, con K se lo fermano, e vengono eseguiti al boot in ordine alfabetico.
    Il comando telinit dice ad init di cambiare il run-level

Ci sono 2 modi operativi della CPU : user mode (o protected mode) e system mode, i processi di sistema sono eseguiti in system mode, quelli degli utenti in user mode, ed in questa modalita' non hanno accesso a risorse di sistema od a memoria al di fuori della loro memoria virtuale. Per indicare questi due modi operativi si parla anche di kernel-space ed user-space.

I processi utente che hanno bisogno di interagire con l'hardware (I/O od altro) utilizzano per questo chiamate a routines di sistema. Allora il processo si interrompe ed il controllo passa al kernel.

Un processo si interrompe anche quando gli arrivano particolari segnali da altri processi. Il comando kill puo' essere usato per mandare segnali ai processi, Es.:
kill -9 729 : manda il segnale 9 al processo con pid 729
Il segnale 9 fa terminare un processo.

L'hardware interagisce col sistema operativo tramite interrupts. La fine di un'operazione di I/O, il click del mouse etc. innescano meccanismi hardware che fanno arrivare un segnale di interrupt alla cpu ( per questo c'e' un apposito cip: l'interrupt controller); la cpu reagisce salvando i registri in un'apposita area di memoria ed eseguendo una routine in un'altra area predefinita (in dipendenza dal tipo di interrupt). Ogni dispositivo hardware ha il suo numero di interrupt (IRQ).

Quando un processo viene interrotto interviene lo scheduler, che in base a code di eventi decide a quale processo tocca la cpu, fra quelli pronti. Questo in base a complicati algoritmi basati su priorita'. L'utente puo' abbassare la priorita' di un suo processo (col comando nice oppure renice). Il passaggio della CPU da un processo ad un'altro e' detto context switch, comporta il salvataggio dei registri (es altri dati), per poter riprendere il processo da dove si era fermato.

SMP: simmetric multi process: sono sistemi con piu' cpu, in questi sistemi sono in esecuzione piu' processi contemporaneamente ( su diverse CPU) ci sono code usate dallo scheduler per assegnare i processi alle cpu libere.
Un processo quindi puo' correre ora su una cpu, ora su un'altra, ( ma sempre su una sola) Il kernel di Linux, che e' un processo monolitico, occupa anche lui sempre una cpu sola.

I processi sono quindi organizzato secondo il diagramma che segue, in una struttura a strati (layers): l'utente interagisce con la shell, via terminale od un'interfaccia grafica e tramite la schell fa partire i suoi processi ed accede al sistema; programmi utente e shell usano le system call, che lavorano in kernel mode; queste a loro volta si interfacciano con le diverse componenti del kernel, come gestione memoria, accesso ai files, device drivers, rete etc. Il kernel si interfaccia poi con l'hardware.

-----------------------------------------------------------
  diagramma generale:
  -----------------------------------------------------------
 
                           Utente 
		             | 
		           shell 
		             |
	programmi utente             accesso al sistema 	    

              |                             | 
                        
 .................... sopra user mode, sotto kernel mode ........
 
			 System Calls 
                              |
			      
  Memoria        Device drivers      Processi  File system    Rete 
  
  
                           Hardware