Corso Linux

Corso Base su
Linux
Basato su Fedora 7
Lezione 1

Linux: Corso base
Obiettivi del corso
● Fornire le informazioni per installare, configurare e amministrare un sistema Linux.
● Dare una buona preparazione sistemistica, utile sia per sysadmin Linux che Unix in

genere.
● Mettere in grado i partecipanti di approfondire necessità specifiche conoscendo le basi

del sistema operativo.
● Affrontare problematiche reali, confrontare Linux con altri sistemi operativi e fare diretti

riferimenti al mondo Internet.

Prerequisiti
● Buona conoscenza e affinità con i computer (hardware e software) ed Internet.
● Conoscenza dei protocolli TCP/IP
● Conoscenza di altri sistemi operativi Unix e dell'inglese (preferibile).

Linux: Corso Base Dott. Ing. Pierluigi Bucolo – 6 ott 2007 Pag. 2

Background e storia
Cos'è Unix ?
Unix è un sistema operativo, nato nel 1969 presso i Bell Labs ad opera di Dennis
Ritchie, Ken Thompson, Brian Kernighan ed altri programmatori.

Inizialmente chiunque fosse interessato e possedesse l'hardware occorrente, poteva
chiedere ad un costo irrisorio un nastro del software ed i relativi manuali stampati.

Questo accadeva prima dell'avvento dei personal computer, pertanto si trattava in
genere di università e centri di ricerca. I singoli centri modificavano il codice sorgente
ampliando e personalizzando il sistema in base alle loro necessità.

Una tappa importante è stata raggiunta alla fine degli anni '70 con la realizzazione
della versione BSD (Berkley System Distribution) ad opera di alcuni esperti di
informatica dell'Università della California di Berkley, che apportarono diverse migliorie,
la più importante fu l'adozione del protocollo TCP/IP.
Il codice sorgente venne reso pubblicamente disponibile con una licenza che ne
consentiva la distribuzione con o senza codice sorgente, a condizione che queste parti
del codice venissero ascrittte a Berkley.


Il software libero (free)
Evoluzione di Unix
La popolarità di Unix aumentò con il trascorrere degli anni.
La Berkley cedette ad AT&T i diritti sul software e Unix divenne un prodotto
commerciale, con costo elevato ed il codice sorgente non era incluso.
Anche acquistando separatamente una copia dei sorgenti, non era più possibile
modificarli e condividere le migliorie apportate con altri programmatori.
Altre società commerciali adottarono la modalità di distribuzione del software senza
sorgenti, ponendo le basi di un nuovo modello di sviluppo proprietario.

Nel 1984 Richard Stallman, invece di cedere a questa nuova tendenza, decise di dare
vita ad un nuovo sistema operativo di tipo Unix il cui codice sorgente potesse essere
liberamente copiato e modificato. Nacque il progetto GNU (GNU is Not Unix).
Il nuovo modello di sviluppo prese il nome di Software Libero (free software).
Venne scritta una licenza specifica GNU General Public License (nota come GPL,
http://www.gnu.org/copyleft/gpl.txt) che aggirasse i limiti imposti dai diritti d'autore e
consentisse a chiunque di copiare e modificare un lavoro, seppur nel rispetto di
condizioni e termini rigorosi.
E' anche nota come licenza copyleft in contrapposizione al più noto copyright.


Open Source
Open Source o Sorgente Aperto
Il termine Open Source venne introdotto nel 1998 quale termine commerciale per
indicare il “software libero”.
Si voleva enfatizzare il fatto che il software Open Source non vuol dire
necessariamente GRATUITO.
E' stata fondata la OSI (Open Source Initiative) allo scopo di promuovere il software
conforme alla Open Source Directive.
Libero indica diverse “libertà” ad esempio:
- Ridistribuzione Libera del software e del codice
- Il Codice Sorgente è Aperto e disponibile per lettura, modifiche, analisi, controllo
- Prodotti derivati da prodotti GPL devono avere licenza GPL
- Copyright dell'autore

Differenza tra Open Source e Software Libero
free as beer vs. free as speech
Riferimenti
http://www.opensource.org/
http://www.gnu.org/philosophy/free-software-for-freedom.html


Linux
La genesi
Agli inizi degli anni '90, Linus Torvald, uno studente finlandese in scienze
dell'informazine iniziò ad apportare variazioni a Minix, un sistema operativo di tipo Unix
per personal computer allora utilizzato nei corsi universitari sui sistemi operativi.

Torvald decise di migliorare il componente principale del software alla base di Minix,
chiamato kernel, e di scriverne uno proprio.

Alla fine del 1991, Torvald pubblicò la prima versione di questo kernel su Internet e la
battezzò “Linux”, un gioco di parole basato sul suo nome e Minix.

La forza di questo progetto fu l'adozione della licenza GNU GPL, in questo modo
Linux risultava un software che poteva essere liberamente utilizzato, copiato e
modificato da chiunque, a condizione che le stesse libertà fossero estese a tutte le
copie e le varianti.

Nel tempo e da tutto il mondo migliaia di programmatori sparsi sull'intero pianeta
contribuirono al suo progetto e Linux è diventato un sistema operativo completo,
moderno e che può essere utilizzato sia da programmatori che da non addetti ai lavori.


Fasi dello sviluppo
Date importanti
Luglio 1991 Linus Benedict Torvalds, ancora un giovane studente dell' Università
di Helsinki, inizia a lavorare al suo hobby: Linux.

5 Ottobre 1991 Nello stesso anno viene rilasciata la versione 0.02. Il post su usenet
che ne annuncia la presenza è diventato un classico.

Gennaio 1992 Viene rilasciata la versione 0.12. Risulta relativamente stabile e
supporta vario hardware.

Aprile 1992 Rilasciate la versione 0.95 e 0.96. Il salto è diretto dalla 0.12.
Nascono le prime distribuzioni: la MCC Linux e la SLS.

1994 Viene rilasciata la prima versione definitiva 1.0.
Nascono RedHat, Debian, SUSE ad oggi le distribuzioni più diffuse.
Linux, che resta copyrighted by Linus Torvalds, diventa ufficialmente
un software aperto, abbracciando in pieno la General Public License
(GPL) del movimento GNU Open Source.
Nascono i primi LUGs (Linux User Groups), ormai diffusi anche in
Italia.


Fasi dello sviluppo
Date importanti
1995 Compaiono sul mercato nuove distribuzione commerciali come Caldera Linux.
Kernel 1.2 out in Marzo.
Dal kernel 1.3 in sviluppo si passerà direttamente al 2.0

1996 Rilasciata la versione 2.0.
Compaiono le prime versioni tradotte in più lingue.
Linux necessita di una mascotte: nasce TUX, il pinguino più famoso al mondo.

1999 Dopo lunga attesa il kernel 2.2 vede la luce.

2001 Agli inizi dell'anno, dopo varie pre-version, su kernel.org appare l'immagine da
19.788.626 byte del 2.4.0 La prima release di un altro stable thread.

Oggi Linux è una reale alternativa al mondo Microsoft e Unix, si ritrova milioni di
utenti, migliaia di sviluppatori e un mercato in espansione.
E' presente in sistemi integrati, è usato per il controllo di dispositivi robotizzati
e ha volato a bordo dello shuttle, praticamente gira su oggetti elettronici di tutti
i tipi, dai palmari alle workstation Alpha, risultando l'OS in assoluto più
soggetto a porting.


Kernel
Cos'è il kernel ?

Per kernel si intende il cuore di un sistema operativo.

Il codice che gestisce le risorse presenti sul sistema e le rende disponibili alle
applicazioni.

Il kernel si occupa principalmente di gestire:

- le comunicazioni con l'hardware del sistema (device driver)
- i file system e la memoria
- l'accesso alle risorse da parte dei processi (le applicazioni eseguite sul sistema)


Kernel
Versioni del kernel
Le versioni del kernel Linux sono identificate con numeri dal significato ben preciso.
Per esempio il kernel 2.6.22 uno degli ultimi rilasciati ha:

2 Major Number

6 Minor Number

22 Revision (patch)

Major Number

Il Major Number identifica il valore più alto della revisione del kernel.

Il rilascio di un kernel con un Major Number successivo rappresenta un evoluzione
“notevole” in termini di funzionalità e/o di architettura rispetto il precedente.
I kernel della serie 1.x sono ormai piuttosto vecchi e non più usati.


Kernel
Minor Number

Se Pari il kernel viene considerato stable e pronto per sistemi in produzione,
Se Dispari si considera in development da usare con cautela o per sperimentazione.
Le release stable sono sempre figlie delle devel precedenti.
Per esempio il kernel stable è la versione 2.6.22, mentre quello in sviluppo è la 2.7.x
(da cui deriverà la 2.8.x o direttamente la 3.0.x).
Solitamente nei kernel stable si tende a fare maintenance e ad implementare solo le
features strettamente necessarie, lasciando a quello in development lo sviluppo di
nuove funzionalità.

Revision (patch)
Indica la revisione (patch) corrente.
E' un numero progressivo che parte da 0.
Tra due revisioni successive possono passare da pochi giorni a varie settimane.
Esistono inoltre varie patch temporanee, anche non di Torwalds stesso (comuni sono
le -ac patch, di Alan Cox) che rappresentano stadi intermedi STABILI prima della
release di una revisione definitiva. Ha senso utilizzarle subito solo in caso di utilizzo di
kernel con gravi problemi di sicurezza o stabilità.


Kernel
Monolitico o modulare ?
Monolitico E' un singolo file binario eseguibile in modalità quot;kernelquot; che contiene il
gestore del processo, della memoria, del sistema, device driver ecc..
Esempi di tali sistemi sono UNIX, Linux, MS-DOS.

Modulare Per kernel Modulare si intende un kernel, con la capacità di caricare o
scaricare parti di codice (moduli) secondo necessità e richieste.
Può esserlo Linux configurandolo in fase di pre-compilazione.

Vantaggi e svantaggi
● Il kernel monolitico è più veloce, poichè tutto il codice è già stato caricato al
bootstrap dell'OS, ma di contro occupa maggiori risorse del sistema.

● Un altro punto a favore è la maggiore stabilità: non richiede moduli evitando così
pericolose dipendenze.

Il kernel modulare è quello utilizzato da tutte le distribuzioni LINUX.


Distribuzioni
Kernel e Programmi
Una Distribuzione (distro) è un confezionamento (packaging) di Linux, con procedure
che rendono comoda e semplice l'installazione del Sistema Operativo e degli
applicativi.

Le distribuzioni differiscono per:
● Numero e versioni dei programmi installabili;

● Versione del kernel utilizzata e modalità di pre-installazione (il kernel solitamente non

viene compilato durante una normale installazione);
● Procedura di installazione (interfaccia utente e possibilità di definire opzioni e

scegliere quale software installare);
● Organizzazione di file di configurazione, programmi, log nel file system;

● Configurazioni predefinite del software installato.

Alcune distribuzioni sono disponibili in forma gratuita sotto licenza GPL.
Altre sono a pagamento. Il costo è giustificato da:
● maggiore stabilità (viene eseguito un debug più spinto prima di rilasciare una

versione)
● presenza di programmi con licenza NON GPL

● supporto tecnico


Distribuzioni
Principali distribuzioni

Distribuzione Note Web
RedHat Orientata ad applicazioni di tipo Enterprise www.redhat.com
Fedora 7 Versione Open Source derivata da RedHat fedoraproject.org
Mandriva 2007 ex Mandrake ha dovuto cambiare nome per www.mandriva.org
Spring problemi di copyright
S.U.S.E 10.2 Acquisita da Novell. Tramite Novell Open www.suse.com
enterprise Server supporta i servizi Netware.
Slackware 12 Una delle prime amata dai “puristi” www.slackware.co
mndriva.org
Debian 4.0 Rev 1 Storica www.debian.com
Ubuntu 7.04 Preinstallata da DELL (Acer e Asus a breve) www.ubuntu.com
Kubuntu 7.04 KDE come Desktop Environmet www.kubuntu.com
(Feisty)
Linspire Pubblicizzata come la più facile da usare www.linspire.com


Distribuzioni
Distribuzioni specifiche

Distribuzione Note Web
CAElinux Specifica per il Computer Aided www.caelinux.com
INSERT Engineering sistemi Windows/Linux
Recovery di www.inside-security.de
Gentoox Per l'utilizzo su su XboX gentoox.shallax.com
EduKnoppix Interamente Italiana orientata a studenti e www.eduknoppix.org
docenti
Devil-Linux Firewall su CD Live www.devil-linux.org
floppyfw Firewall che sta su un floppy da 3.5” www.zelow.no/floppyfw
Edubuntu 7.04 Contiene programmi educativi www.edubuntu.com
Xubuntu 7.04 Ottimizzata per le prestazioni, indicata per www.xubuntu.com
(Feisty Fawn) computer poco potenti
FreeNAS Per realizzare un server NAS www.freenas.org

Un sito che contiene un elenco ragionato delle distribuzioni è: http://distrowatch.com


Installazione - Preparazione
Raccolta informazioni sull'Hardware
Solitamente durante l'installazione l'hardware viene rilevato automaticamente, ma
possono esserci rari casi in cui questo non accade.
In genere se si usa un PC standard con una nuova distribuzione non ci sono problemi
nel riconoscimento di componenti e periferiche.
E' buona norma prima di iniziare una installazione conoscere le seguenti informazioni:
● Sapere quali e quanti Hard Disk sono presenti sul sistema, come sono partizionati,

quali sono cancellabili.
● Il tipo di computer su cui viene fatta l'installazione (server, desktop, laptop)

● Configurazione di rete, se prevista (indirizzo IP, subnetmask, nome macchina, server

DNS).
● Configurazioni base del sistema (layout di tastiera, nomi utenti e password, timezone)

● I servizi che dovrà offrire (deve diventare un server? Di che tipo? Web, ftp, ecc ?)

● I programmi che interessa installare (solitamente è possibile sceglierli per gruppi).

Importante
Linux non è scritto SOLO per CPU Intel, vengono supportate moltissime architetture,
ad esempio: Motorola 68K, Sun SPARC, Alpha, HP PA-Risc, ecc., nonché processori
per sistemi embedded (System On Chip): ARM, Xscale, Etrax, ecc.


Installazione – Requisiti di sistema
Importante
In realtà, non esistono requisiti minimi, scegliendo la giusta distribuzione è possibile
ancora oggi installare Linux su computer con processore Intel 80386, 4 Mb di RAM e
HD da 20 Mb.
Tutto dipende dall'uso che si deve fare.
Configurazione consigliata
Distinguiamo tra i due principali campi di applicazione
Desktop
Processore di classe Pentium minimo 2 Ghz
RAM 512 Mb (meglio 1 Gb)
Hard Disk 60 Gb (IDE o SATA)
CD-ROM (meglio DVD)
Scheda video con 32 Mb RAM (128 Mb e compatibile Open GL per usare effetti 3D)
Server
Processore di classe Pentium minimo 2 Ghz
RAM 1 Gb (maggiori quantità dipendono dai servizi attivi)
Hard Disk 60 Gb per il sistema operativo
Hard disk aggiuntivi per i dati meglio se in architettura SCSI
CD-ROM (meglio DVD)


Installazione – Partizionamento
Durante l'installazione verrà chiesto come partizionare il disco rigido.
diskdruid o fdisk sono i programmi più utilizzati dalle varie distribuzioni.

Minimo
Sono richieste almeno due partizioni:
- una partizione generale (/, root) in cui saranno memorizzati tutti i file.
- una partizione di swap (usata come Memoria Virtuale)

Consigliato
E' preferibile creare le seguenti partizioni:
- / (root), sotto la quale stanno tutte le altre directory
- /boot (dove risiedono il kernel ed i file di boot. 120 Mb di spazio possono bastare)
- /var (file che cambiano di dimensione, tipicamente i log. E' utile averla su partizione
indipendente per evitare che un aumento inatteso dei log riempa tutto il filesystem
(100 Mb).
- /home (file di tutti gli utenti. Può essere piccola e praticamente inutilizzata (mail, dns
server) o molto grossa e piena di documenti (web, file server)
- /tmp dove risiedono file temporanei.


Installazione – Ripartizionamento
Qualora ci trovassimo con un disco rigido già partizionato è possibile installare
ugualmente Linux senza perdere i dati esistenti utilizzando Gparted.

Gnome PARTition Editor - http://gparted.sourceforge.net/

E' possibile ridimensionare le partizioni esistenti mantenendone il contenuto inalterato
e liberare lo spazio necessario all'installazione di Linux.

Alcune distribuzioni permettono di utilizzare questo software durante l'installazione.

Si può scaricare una distribuzione Live minima (circa 50 Mb) per creare un CD o una
chiave USB avviabile per eseguire il partizionamento e poi procedere all'installazione
della propria distribuzione.

IMPORTANTE
ESEGUIRE SEMPRE UNA COPIA DEI DATI. In caso di un problema o una errata
operazione è FACILISSIMO perdere il contenuto del proprio disco rigido.


Installazione – Dispositivi
Device
In Linux (come in Unix) i dispositivi sono rappresentati da file contenuti all'interno della
cartella /dev.
In particolare i dischi rigidi di tipo IDE vengono indicati con:

/dev/hda per il primo disco presente sul primo controller IDE
/dev/hdb per il secondo disco IDE
e così via.....

Qualora il disco fosse con architettura SCSI o SATA verrebbe identificato con /dev/sda
Allo stesso modo le partizioni presenti nel disco /dev/sda vengono indicate con:
/dev/sda1, /dev/sda2, ecc..

Mount Point
Le partizioni per essere visibili devono essere montate all'interno di una directory
sotto /.
Per ognuna va indicato il relativo punto di mount:

/dev/hda1=> /home
/dev/sda2 => /


Installazione – Boot Loader
Definizione
Il boot loader effettua il caricamento del sistema operativo (NTLDR in Windows).
I boot loader più diffusi sono LILO (LInux LOader) e GRUB, quest'ultimo sta
progressivamente sostituendo LILO poiché essendo nato successivamente, ha
migliorato alcune funzionalità e superato alcuni limiti di LILO.
Boot Manager
LILO o GRUB non si limitano SOLO al caricamento di Linux, ma sono a tutti gli effetti
dei veri e propri BOOT MANAGER.
Questo vuol dire che possono eseguire il caricamento di altri sistemi operativi
(windows ad esempio) presenti sul disco rigido, dando all'utente in fase di boot la
possibilità di scegliere quale usare.
Installazione
Durante l'installazione verrà chiesto se installare il boot loader nel Master Boot Record
(MBR) o all'interno di una partizione Linux (ext2 o ext3).
Normalmente si installa nel MBR quando Linux è il solo sistema operativo o si vuole
usare il boot loader anche come come boot manager.
Utilizzando un boot manager differente l'installazione VA ESEGUITA all'interno della
partizione principale di Linux / (root).
L'installazione del boot loader va eseguita con molta cura, un errore può causare
l'impossibilità di avviare il/i sistema/i operativo/i presenti su disco rigido.


Installazione – Pacchetti
Tipologia

In genere ogni distribuzione permette di scegliere il tipo di installazione che si vuol fare
proponendo tra 3 tipologie:

● Desktop – Per un utilizzo personale (equivalente a Windows XP/Vista)
● Server

● Ufficio – Con programmi specifici per office automation

Oltre a questo esistono delle distribuzioni create per utilizzi specifici, ad esempio per
CAE, Educative, Media Center, ecc..


Installazione – Pacchetti
Package Manager (PM)
L'utilizzo dei Package Manager permette di installare, aggiornare, verificare o
rimuovere i programmi con molta facilità.
I programmi vengono raccolti all'interno di un singolo file che contiene anche le
istruzioni per l'installazione e la disinstallazione necessarie al Package Manager.
I PM esistenti sono:
● rpm nato con le distribuzioni Red Hat (Red Hat Package Manager) è utilizzato oggi

da diverse distribuzioni.
I file pacchettizzati hanno come estensione .rpm.
● dpkg creato da Debian e utilizzato dalle distribuzioni da essa derivate, utilizza un
formato differente con estensione .deb.
E' stato il primo ad avere uno strumento per la soluzione delle dipendenze chiamato
apt (Advanced Package Tool)
Altri PM che riconoscono le dipendenze tra i pacchetti sono (su base rpm):
YUM (Yellow dog Updater Modified) utilizzato da Fedora
YaSt (Yet Another Setup Tool) utilizzato da SUSE
urpmi utilizzato da Mandriva


Installazione – Utenti
Differenze tra gli utenti
In ambienti Unix e quindi anche su Linux esistono differenze fra i vari utenti, definite
dai permessi e dall'acceso ai file e comandi che un'utente può lanciare.

E' convenzione che i semplici utenti possono scrivere, leggere e modificare file solo
all'interno del loro ambiente (home) e lanciare semplici comandi che non influiscono
sulla configurazione del sistema.

Per poter accedere completamente alle risorse del sistema bisogna accedere al
sistema come superuser ovvero come utente root.

In fase di installazione di una macchina Linux si consiglia di scegliere una password di
root piuttosto complicata (ma ricordabile!) e di creare immediatamente un normale
utente con il quale operare per tutte le attività di tipo NON AMMINISTRATIVO.


Installazione – root
Utente root

L'utente root è l'amministratore del sistema con tutti i poteri che comporta questo
ruolo, quindi è molto importante che l'accesso a root sia limitato solo al reale
amministratore di sistema (sysadm) E PER IL TEMPO STRETTAMENTE
NECESSARIO.

●L'utente root ha poteri assoluti sul sistema:

● Aggiungere, Eliminare e modificare account (altri utenti)
● Installare e configurare servizi

● Accesso completo (lettura e scrittura) di tutti i file presenti nel filesystem

● Aggiungere e Modificare il Filesystem

● Distruggere tutto con un solo comando

IL POTERE DI ROOT SUL SISTEMA È ASSOLUTO


Installazione – Problemi comuni
Molti problemi che si presentano in fase di installazione possono essere risolti
passando dei parametri al kernel in fase di avvio tramite il bootloader:

ide=nodma Il sistema si blocca dopo il boot dal CD/DVD

apm=off Il sistema si blocca dopo aver abilitato l'APM o in modo casuale

acpi=off Il sistema si blocca in modo casuale
nohlt

nofirewire Il sistema si blocca durante la ricerca di dispositivi firewire

nofb Se lo schermo diventa bianco o mostra caratteri strani dopo il boot
(specialmente per LCD)

altri parametri che permettono di superare il blocco del sistema durante l'installazione:
noapic, nopcmcia, nousb, pci=off


Interfaccia grafica
X Windows
Linux oltre ad offrire la possibilità di interagire con il sistema via linea di comando
propone un ambiente grafico a finestre che è sicuramente più familiare per chi è
abituato a Windows.
Questo ambiente viene comunemente chiamato X (X windows system) che nel tempo
è diventato lo standard GUI (graphic user interface) di Unix e Linux.
L'ambiente grafico X è composto essenzialmente da tre parti:

Windows manager E' il gestore delle finestre, cioè fornisce un metodo per
lavorare con le finestre. Esistono molteplici gestori: motif è lo
standard commerciale più utilizzato ma i gestori più famosi
utilizzati in ambiente Linux sono KDE, Enlightenment, Sawfish,
AfterStep, e FVWM

Server X E' il processo che si occupa di gestire il display, ovvero si occupa
di far interagire l'utente con la GUI. Esistono molteplici server X,
ma su Linux il più utilizzato è di gran lunga Xfree86 oggi sostituito
da Xorg, fornito gratuitamente. Alternative commerciali sono
Accelerated-X e Metro-X.


Ambiente Desktop
KDE vs. Gnome

Kde (K Desktop Enviroment)

Comprende oltre un windows manager un'intero ambiente desktop molto user
friendly, inoltre fornisce vari sistemi integrati per la gestione e configurazione del
sistema

Gnome (GNU Network Object Model Enviroment)

A differenza di KDE Gnome è solo l'ambiente desktop per cui ha bisogno di un
windows manager come FVWM (Fantastic Virtual Windows Manager).
Anche Gnome offre dei propri sistemi integrati per la gestione della macchina.

Ogni distribuzione solitamente prevede la possibilità di installare ed utilizzare sia
Gnome che KDE, è poi possibile modificarli e aggiornarli secondo le proprie necessità.


Programmi
Le varie distribuzioni attingono i loro software prevalentemente da progetti Open
Source, pertanto differenti distribuzioni forniscono gli stessi software a meno della
versione.

Il “project management” di ogni distribuzione decide quale release utilizzare di un
particolare software preferendo ad esempio, la stabilità o una maggiore funzionalità.
Anche in questo caso come per il kernel esiste sempre una versione stable del
software ed una in stato di develop.

E' possibile anche che in qualche distribuzione vengano applicate delle patch o
delle customizzazioni al fine di migliorare qualche aspetto o risolvere qualche bug.
Nell'ottica della licenza GPL queste modifiche saranno disponibili anche sulle altre
nel giro di poco tempo sempre se ritenute necessarie dai rispettivi “project
management”, in genere tramite la distribuzioni di pacchetti di update.

Alcune distribuzioni dispongono di un repository chiamato contrib o extra, nel
quale si trovano software (sotto forma di packages) non distribuiti “ufficialmente” e
quindi non supportati, ma di interesse per la comunità che qualcuno o qualche gruppo
di lavoro ha adattato per integrarli nella specifica distribuzione.


Programmi di uso comune
Suite Office

Open Office Suite office che comprende word processor, foglio elettronico,
presentazione, database. E' disponibile anche per l'ambiente
windows.
Star Office Come il precedente però con licenza commerciale, vanta maggiori
funzionalità soprattutto per il database.

Posta Elettronica

Thunderbird Deriva dal progetto Mozilla
Evolution Posta Elettronica simile ad Outlook

Browser

Firefox Browser perla navigazione su Internet
Ies4Linux Uno script che permette di installare sotto Linux, Internet Explorer 5,
5.5 e 6
Opera Analogo alla versione per Windows


Programmi - PVR


Installazione – Demo
Qemu

E' un software di virtualizzazione disponibile nelle varie distribuzioni Linux.
Permette di emulare un computer e relative periferiche via software.

Nell'uso base è sufficiente usare due comandi:
qemu-img per creare un disco virtuale
qemu per eseguire il software di virtualizzazione

Sintassi:
qemu-img create -f qcow <nome_file_img> <dimensione>
es:
qemu-img create -f qcow mandriva.img 4G

Sintassi:
qemu [-kernel-kqemu] -m 512 -cdrom immagine_cd.iso -boot d <nome_file_img>
es:
qemu [-kernel-kqemu] -m 512 -cdrom mandriva.iso -boot d mandriva.img


Installazione – Demo
Kqemu – Full virtualization mode
E' un modulo acceleratore che velocizza l'esecuzione della macchina virtuale (qemu).
Implementa il “Full Virtualization mode” dove le istruzioni della macchina virtuale
vengono eseguite direttamente dalla CPU senza traduzione.
L'accelerazione è possibile solo quando si emula un Sistema Operativo (guest)
per CPU x86 su un computer (host) con lo stesso tipo di CPU.
Kqemu è un modulo kernel che va caricato manualmente prima dell'esecuzione di
Qemu.
insmod kqemu oppure modprobe kqemu
e bisogna richiamare qemu con l'opzione “-kernel-kqemu”

Può essere utile qualora si debbano usare programmi scritti per altri S.O., ad esempio
Windows 2000/XP.

DURANTE L'INSTALLAZIONE DI WINDOWS NON VA' ABILITATA!!
CAUSA IL CRASH DEL SISTEMA OPERATIVO GUEST IMPEDENDONE
L'INSTALLAZIONE.
SI PUO' ABILITARE AD INSTALLAZIONE CONCLUSA.


Corso Base su
Linux
Fine Lezione 1

Corso Base su
Linux
Basato su Fedora 7
Lezione 2

File system
Per file system si intende l'astrazione (metodi e protocolli) con cui si organizzano i
file su un supporto fisico ad accesso casuale (floppy, cdrom, hard-disk, ecc)

Le informazioni riguardanti un oggetto (file o directory) di un file system sono
contenute in un inode, che viene identificato da un numero progressivo e descrive
le caratteristiche base di un oggetto: permessi, data di modifica, tipo, posizione
ecc.

Un sistema Linux, come ogni sistema Unix, ha una directory principale, chiamata
root ed indicata con / sotto la quale si trovano TUTTE le altre directory e TUTTI gli
altri file system eventualmente montati sul sistema (floppy, cdrom, condivisione di
rete ecc.).

Il principio è radicalmente diverso da quello presente nel mondo Windows, dove
ogni device o risorsa ha un suo nome o lettera identificativa al cui interno si trovano
le directory del relativo file system.

Il file system usato in Linux è l' ext2
Dal kernel 2.4.x è disponibile un'evoluzione dell'ext2, l'ext3 che ha il vantaggio di
essere un journal file system


Organizzazione del file system
/ Radice (root)
------------------------------------------------------------------------------------------------------------
/root Home dell'utente root
------------------------------------------------------------------------------------------------------------
/boot Contiene tutte le immagini del kernel e file indispensabili al bootstrap
------------------------------------------------------------------------------------------------------------
/etc Contiene i file di configurazione del sistema e dei programmi installati
------------------------------------------------------------------------------------------------------------
/home Contiene le home degli utenti tranne quella di root
------------------------------------------------------------------------------------------------------------
/usr Contiene binari, documentazione, librerie e sorgenti della maggior parte
dei programmi (e i sorgenti del kernel)
------------------------------------------------------------------------------------------------------------
/var File contenenti informazioni dinamiche (log, pid file, directory di spool).
------------------------------------------------------------------------------------------------------------
/proc File system virtuale. Contiene, come se fossero file e directory, dati
dinamici sul sistema e sui processi
------------------------------------------------------------------------------------------------------------
/dev Contiene i file per la gestione dei dispositivi sia a blocchi (hdd) che a
carattere (tty) oltre a file speciali (/dev/null)


Organizzazione del file system
/sbin Contiene comandi e programmi riservati a root ( altri comandi sono in
/usr/sbin/ )
------------------------------------------------------------------------------------------------------------
/bin Contiene comandi e programmi base per tutti gli utenti (altri comandi
sono in /usr/bin/ )
------------------------------------------------------------------------------------------------------------
/lib File delle librerie di sistema utilizzate dai programmi
------------------------------------------------------------------------------------------------------------
/tmp Contiene i file temporanei
------------------------------------------------------------------------------------------------------------
/usr/tmp Altra directory che contiene file temporanei
------------------------------------------------------------------------------------------------------------
/usr/doc Documentazione sul sistema
------------------------------------------------------------------------------------------------------------
/mnt Directory sotto la quale vengono montati altri file system (floppy,
cdrom, chiavi USB, oartizioni NTFS, ecc)
------------------------------------------------------------------------------------------------------------
/media Come /mnt si trova in diverse distribuzioni, ma non fa parte della
struttura standard (è usata dal demone automount).


Montaggio del file system
Prima di poter utilizzare un file system (es: CDROM, floppy, tape, condivisione di
rete windows, directory nfs, partizione fat32 di un hard disk, ecc) questo deve
essere formattato e montato in una sotto directory della root ( / ).

Una volta montato il file system risulta accessibile a programmi e utenti in modo
trasparente e diventa parte integrante dell'albero delle directory sotto /

Dopo l'uso il file system può essere smontato (operazione necessaria per espellere
un CDROM, un floppy o una chiave USB).

La directory su cui viene montato un file system (mount point) può anche non
essere vuota, ma nel momento in cui ci viene montato un file system, i dati ivi
contenuti non sono più visibili fino a quando non si smonta il file system.

Per montare un file system si usa il comando mount.

Sintassi:
mount -t [tipo fs] [opzioni] device mount_point
esempio:
$ mount -t ntfs -o r /dev/sda1 /mnt/windows


Mount
mount -t [tipo fs] [opzioni] device directory

[tipo fs] è il tipo di file system da montare.

Linux riconosce un elevato numero di file system:
adfs, affs, autofs, cifs, coda, coherent, cramfs, debugfs, devpts, efs, ext, ext2, ext3,
hfs, hpfs, iso9660, jfs, minix, msdos, ncpfs, nfs, nfs4, ntfs, proc, qnx4, ramfs,
reiserfs, romfs, smbfs, sysv, tmpfs, udf, ufs, umsdos, usbfs, vfat, xenix, xfs, xiafs.

Il parametro [-t tipo_fs] è un parametro opzionale, se non viene specificato il
comando mount tenterà di individuare il file system in automatico.

Qualora il file system non venisse riconosciuto, il comando terminerebbe con un
errore e bisogna ripeterlo specificando manualmente il tipo di file system.
Per montare tutti i file system indicati nel file /etc/fstab si usa il prametro '-a'
$ mount -a

Per ulteriori informazioni consultare la pagina del manuale:
$ man mount


Comandi per i file system
Altri comandi utili nella gestione dei file system sono:

umount [ opzioni ] device Smonta un dispositivo (necessario)
df [opzioni] [file] Verifica lo spazio libero su disco
du [opzioni] [file] Visualizza lo spazio occupato da file e directory
fsck [opzioni] dispositivo Verifica l'integrità e ripara il file system
mkfs [opzioni] dispositivo Crea un file system (formatta)
fdformat device Formatta a basso livello un floppy

Si ricordi che un file system è individuato con il device corrispondente:

/dev/hda1 Prima partizione del primo disco IDE
/dev/sda2 Seconda partizione del primo disco SCSI
/dev/fd0 Primo floppy disk


FSTAB
Nel file /etc/fstab vengono configurate le informazioni sui vari file system
(da montare al boot o no) preimpostati sul sistema.
Il suo formato prevede per ogni riga le seguenti informazioni:
1- Dispositivo da montare, si può indicare il device corrispondente (/dev/hda1)
o l'etichetta del file system (ext2 o xfs) preceduta dalla keyword LABEL.
2- Mount point sul file system principale
3- file system Type da utilizzare (es: ext2, ext3, iso9660, nfs...)
4- Opzioni specifiche per il mount:
defaults= monta il dispositivo al boot
noauto = montaggio solo su richiesta dell'utente
user = permette il montaggio anche agli utenti
5- Indica se deve essere eseguito il backup usando il comando dump (0=NO).
6- Controllo del file system al boot. Uno 0 indica NESSUN CHECK.
Il controllo viene eseguito in ordine numerico crescente.
#/etc/fstab
LABEL=/ / ext3 defaults 11
LABEL=/boot1 /boot ext3 defaults 12
/dev/cdrom /mnt/cdrom iso9660 noauto, user 00
proc /proc proc defaults 00
/dev/sda2 none swap defaults 00


LINK
Il comando ln crea un link (alias) di un file o directory.
Quando si opera sul link è come se si operasse direttamente sul file tranne che
quando si rimuove il link (non si cancella il file).

Hard Link
Per default ln crea un hard link: di fatto un altro nome per un file esistente.
Originale e link sono indistinguibili, condividono lo stesso inode.
Non si possono creare hard link fra file system diversi e su directory.
$ ln [opzioni] nome sorgente [nome destinazione]

Link symbolico
Detto anche soft link o symlink, si ottiene specificando l'opzione “-s”.
E' un tipo speciale di file che si riferisce ad un file (inode) diverso
Può essere creato su file system diversi (nfs, cdrom ecc.) e su file che non
esistono. Si capisce di quale file sono un link.
$ ln -s nome file [nome link]

L'uso dei link è completamente trasparente e NON impatta sulle performance del
sistema.


Utenti e Gruppi
UTENTI
Si possono creare più account che vengono memorizzati nel file /etc/passwd.
Ogni riga del file passwd è del tipo:
username:passwd:UID:GID:user_data:home_dir:shell

UID = User IDentifier è un valore numerico univoco
GID = Group Identifier è un valore numerico univoco
user_data = Nome e Cognome dell'utente, telefono, ecc...
home_dir = directory di lavoro dell'utente
shell = shell che utilizzerà l'utente
es: root:passwd:0:0:root:/root:/bin/bash
GRUPPI
Linux gestisce anche gruppi di utenti, per condividere file e per favorire la
collaborazione. Ogni utente deve appartenere ad almeno un gruppo.
I gruppi sono definiti nel file /etc/group, ogni riga ha la forma del tipo:
group_name:passwd:GID:users_list
es: adm:passwd:4:root, adm, daemon


Attributi di file e directory
Ogni file appartiene ad un utente e a un gruppo.
Per visualizzare utente e gruppo di un file si usa il comando “ls -l”.
$ ls -l /etc/passwd
-rw-r--r-- 1 root adm 77266 Dec 13 17:18 /etc/passwd

In questo caso l'utente proprietario è root, mentre il gruppo è adm.

E' possibile cambiare (avendo i permessi) l'utente ed il gruppo con i comandi:
chown (change owner) e chgrp (change group)
Sintassi: chown nome_utente nome_file
es:
$ chown topolino /etc/passwd
-rw-r--r-- 1 topolino adm 77266 Dec 13 17:18 /etc/passwd
Sintassi: chgrp nome_gruppo nome_file
es:
$ chown pluto /etc/passwd
-rw-r--r-- 1 topolino pluto 77266 Dec 13 17:18 /etc/passwd

Al posto del nome utente e del gruppo è possibile specificare i rispettivi UID e GID.


Permessi su file e directory
Ogni file dispone di permessi separati per tre categorie di utenti:
- utente proprietario
- gruppo proprietario
- il resto degli utenti

Per ogni categoria esistono tre tipi di permessi:
- lettura definito dal flag r (Read)
- scrittura definito dal flag w (Write)
- esecuzione definito dal flag x (eXecution)

Per le directory questi flag hanno un significato diverso:
- lettura = poter visualizzare i file contenuti
- scrittura = creare, copiare o spostare i file contenuti
- esecuzione = poter usare il nome della directory in un PATH

$ ls -l /etc/passwd
-rw-r--r-- 1 root root 77266 Dec 13 17:18 /etc/passwd
permessi altri utenti
permessi gruppo proprietario
permessi utente proprietario


Modifica dei permessi su file e directory
Per modificare le modalità di accesso ad un file si usa il comando:
chmod (change mode)

Sintassi: chmod operazione nome_file

L'operazione a sua volta è composta da: categoria , azione e permesso

Carattere Categoria
u utente proprietario del file
g gruppo proprietario del file
o tutti gli altri utenti del sistema
a tutti gli utenti; equivale a 'ugo'

Operazione Azione
+ Aggiunge permessi ai permessi esistenti
- Rimuove permessi dai permessi esistenti
= Assegna i permessi al file

Permesso: r,w,x hanno il significato visto in precedenza


Uso di chmod
Proteggere un file dalla scrittura
$ chmod go-w cruise
Rendere un file privato
$ chmod go= cruise
Rendere un file pubblico
$ chmod a+rw cruise
Rendere un file pubblico
$ chmod a+x myscript

IMPORTANTE!!
Il superutente, root, può sempre accedere a qualsiasi file presente sul sistema,
indipendentemente dai suoi permessi di accesso.

NOTA
Di fatto rwx, sono la rappresentazione dello stato di tre bit, partendo dal più
significativo si ha: r = 4, w=2, x= 1
pertanto i comandi chmod possono essere impartiti anche in forma numerica:
$ chmod 700 myscript abilita tutti i permessi solo all'owner (file privato)


Comandi di uso frequente
$ touch nome file [INVIO]
aggiorna la data e l'ora di un file, se il file non esiste crea un file vuoto

$ mkdir nome directory [INVIO]
crea una directory

$ mkdir –p work/completed/2001 [INVIO]
crea la directory 2001 e le directory superiori se non esistono.

$ cd nome directory [INVIO]
cambia directory

$ cd [INVIO]
rende come corrente la directory home

$ pwd [INVIO]
visualizza il PATH in cui ci si trova

$ ls -R [INVIO]
visualizza il contenuto della directory corrente e delle sotto directory.


$ cp file_sorgente file_destinazione [INVIO]
copia il file_sorgente creando il nuovo file_destinazione

$ mv file_sorgente file_°destinazione [INVIO]
rinomina o sposta il file_sorgente in file_destinazione

$ ls -a
visualizza i file nascosti quelli in cui il primo carattere del nome è un punto (.)

E' possibile utilizzare dei caratteri speciali all'interno del nome dei file:
* Corrisponde ad una serie di nessuno o più caratteri.
* da solo indica tutti i file
*.txt indica i soli file con estensione txt
? Simile ad * ma sostituisce un generico carattere
cas? equivale a tutti i file di 4 caratteri la aventi le prime tre uguali a cas
~ rappresenta la home directory dell'utente
~ = /home/pippo
cd ~/prova equivale al comando: cd /home/pippo/prova


$ find percorso -name nome_file [INVIO]
visualizza tutti i file che si trovano sotto “percorso” aventi “nome_file”.

$ find /tmp -size +10000k [INVIO]
visualizza i file memorizzati sotto /tmp aventi dimensione maggiore di 10000k

$ find /home -user topolino [INVIO]
visualizza i file memorizzati sotto /home di proprietà di topolino

$ which programma [INVIO]
visualizza il percorso completo di dove si trova il comando

$ grep nome [INVIO]
filtra le righe che contengono la parola “nome”

$ more programma [INVIO]
interrompe la visualizzazione quando si riempie lo schermo ed attende la
pressione di un tasto per proseguire

$ man comando [INVIO]
visualizza la pagina del manuale relativa a “comando”


Il processo di boot
Il processo di boot di una macchina Linux comporta diverse fasi:

1- All'accensione il BIOS (Basic Input Output System) memorizzato su memoria
ROM non volatile, definisce l'ordine dei device da usare per effettuare il boot.

2- Il BOOT SECTOR del primo device di boot contiene il codice (o i riferimenti su
dove trovarlo) del loader che esegue il bootstrap del sistema operativo.

3- Il loader lancia il caricamento del kernel di Linux, che si copia in memoria ed
esegue i controlli e il riconoscimento dell'hardware presente.

4- A fine caricamento il kernel esegue il processo init, padre di tutti i processi,
che gestisce il caricamento di tutti gli altri programmi da eseguire per
completare il boot


Il BIOS
Ogni sistema Intel ha sulla motherboard un BIOS su ROM (ormai su memorie
FLASH) con cui gestire l'hardware del sistema.

All'avvio di un computer non c'è nulla in RAM e nessun programma predefinito da
caricare.
Le istruzioni su come procedere sono nella memoria non volatile del BIOS, in cui,
fra le impostazioni definibili dall'utente, c'e' la sequenza dei dispositivi da usare per
il boot.

Nei BIOS più recenti è possibile effettuare il boot da floppy, cdrom, dvd, hard disk
(potendo scegliere se dare precedenza a HD IDE, SATA o SCSI) e altri dispositivi
quali chiavi USB, Zip o scheda di rete.

Il BIOS cerca, nell'ordine configurato, il boot sector sui diversi dispositivi di boot
previsti.

Gli hard disk hanno un boot sector per ogni partizione e un unico Master Boot
Record (MBR) che è il boot sector dell'intero hard disk.
Se si esegue il boot da un hard disk, è il codice contenuto nel MBR che viene
eseguito


I Linux Loader
Esistono diversi loader che eseguono il bootstrap del sistema operativo Linux:

Su sistemi Intel Based: LILO, GRUB, LOADLIN, SYSLINUX, BOOTLIN;
su sistemi Alpha si usa MILO, mentre su sistemi Sparc SILO.

Tutti svolgono la stessa funzione. Loadlin e Syslinux sono programmi DOS che
eseguono il kernel caricandolo da una partizione DOS, altri sono adattamenti di LILO
che riguardano sistemi non basati su processori Intel.

Windows usa come loader VBR (Volume Boot Record) che si occupa di caricare
l'NTLDR ed utilizza il file boot.ini per la configurazione.
Kernel
Il kernel, invocato dal loader, viene caricato in memoria ed inizializza i vari device
driver, visualizzando vari messaggi utili per capire e conoscere il proprio sistema.
INIT
L'ultima operazione eseguita dal kernel alla fine del suo caricamento è il lancio del
processo init, il padre di tutti i processi.
Da questo momento tutto il codice eseguito lavora in user space (in kernel space
lavorano solo il kernel e i suoi moduli).


LILO
LILO è uno dei LInux LOader più diffusi, permette il boot sia di Linux che di altri
sistemi operativi.
Generalmente l'installazione di Linux provvede a creare ed installare LILO (se si è
scelto di installare il loader direttamente sull'hard disk e non su floppy) ma in caso
di kernel upgrade o aggiunta di un nuovo sistema operativo sulla macchina può
essere necessario modificare le impostazioni di LILO manualmente.

Tutte le impostazioni di LILO sono definite nel file /etc/lilo.conf che contiene una
parte di configurazione globale e una o più parti relative alle diverse immagini del
kernel o sistemi operativi che si vogliono poter caricare.

Il comando /sbin/lilo installa sul MBR o sul settore di boot di una partizione il LILO
secondo le indicazioni date in /etc/lilo.conf.
Al momento del boot LILO inoltre presenta la possibilità di dare comandi vari e di
scegliere quale sistema operativo o versione di kernel lanciare.

ATTENZIONE: Operare maldestramente con LILO e il MBR può impedire il boot
del sistema operativo, si suggerisce sempre di avere un dischetto di boot
disponibile da utilizzare in caso di danni o problemi con l'MBR.


Configurare il LILO
Il file /etc/lilo.conf è diviso in diverse sezioni, analizziamole in dettaglio:
Global Options
prompt Visualizza un prompt per scegliere il Sistema operativo
di cui eseguire il boot e passare dei parametri al kernel.
timeout=50 Definisce il tempo in decimi di secondo che lilo
aspetta prima di caricare l'immagine di default.
default=linux Indica quale sistema operativo caricare di default.
boot=/dev/hda Indica il device dove installare LILO.
/dev/hda1 = boot record della prima partizione
map=/boot/map Indica la posizione del map file, che
contiene la posizione fisica del kernel in un formato
interpretabile da LILO.
install=/boot/boot.b Definisce il file che il comando /sbin/lilo installa sul
settore di boot. E' il binario vero e proprio di LILO.
message=/boot/message Definisce un file contenente del testo da visualizzare al
boot.
linear Genera indirizzi di settore lineari, invece di indirizzi di
settore/head/cilinder, che possono dare problemi nel caso di
dischi di grandi capacità. E' consigliabile metterlo.


Configurare il LILO
Label Options per Linux
image=/boot/vmlinuz-2.4.7-10 Indica dove risiede l'immagine del kernel da caricare.

label=linux Definisce il nome associato a questa immagine, è
quello che si può scrivere nel LILO command prompt
all'avvio per caricare questa immagine.

initrd=/boot/initrd-2.4.7-10.img Definisce la posizione dell'immagine dell'initial ram disk.
Il kernel usa questo file system come RAM disk, ne
esegue il file linuxrc e poi monta il vero file system su
Hard Disk. Serve, ad esempio, per installare un kernel
modulare su Hard Disk SCSI, per i quali i driver sono
disponibili come moduli e non possono essere caricati
direttamente.

read-only Indica al kernel di montare la root, sotto definita, in modo
read-only durante la fase di boot. Così facendo è possibile
eseguire un file system check durante il boot senza rischi.
Prima di passare il controllo delle operazioni al processo
init, il kernel monta nuovamente la root in read-write.

root=/dev/hda3 Definisce in quale partizione si trova la root del sistema.


Configurare il LILO
Label Options per Windows

label=Windows_2000 Definisce il nome della label associata a questo OS
other=/dev/hda1 Indica la partizione in cui risiede un sistema operativo
diverso da Linux.
optional Omette l'immagine del kernel se non è disponibile al
momento della creazione del map file.
Opzioni aggiuntive
Al boot quando appare la scritta LILO:, premendo il tasto [TAB] vengono visualizzate le label
disponibili per il boot.
Per passare dei parametri al kernel dal LILO prompt, si usa il comando append
Per una scheda di rete, ad esempio, che usi l'IRQ 10 e l'indirizzo di I/O 210 (potrebbe essere
necessario per schede di rete ISA o EISA non PnP):
append = quot;ether=10,0x210,eth0quot;
Opzioni importanti per la sicurezza (utilizzabili sia nell'area global che label) sono:
password=pippo Indica che è necessaria una password (pippo) per poter dare
comandi al prompt di LILO
restricted Indica che la password serve solo quando si devono passare dei
parametri al boot, ma non per scegliere la label da caricare.


GRUB
GRUB è un boot loader multipiattaforma estremamente flessibile e potente.

Ha un propria CLI in cui inserire a mano i parametri di boot o può presentare
un'interfaccia a menu configurabile tramite il file /etc/grub.conf.

Per installare grub sul settore di avvio basta dare il comando:
grub-install /dev/hda

Differentemente da LILO non c'è bisogno di ridare il comando ogni volta che si
cambia la configurazione.

E' sufficiente modificare il file di configurazione e al successivo riavvio del
computer verranno presentate le nuove opzioni.

E' più sicuro poiché si evita di riscrivere il MBR e di avere un boot loader
inconsistente a causa di una opzione non corretta.

Utilizzando la CLI di GRUB, disponibile durante la fase di boot, si possono variare i
parametri di boot esistenti o specificare un comando di boot completamente nuovo.


Configurazione di GRUB
Segue un esempio di /etc/grub.conf che esegue le stesse operazioni del file /etc/lilo.conf
mostrato in precedenza.
default=0 Imposta come default la prima quot;labelquot; sotto indicata
timeout=10 Imposta a 10 secondi il tempo di attesa prima di caricare
automaticamente l'entry di default.
splashimage=(hd0,2)/boot/grub/splash.xpm.gz
Indica dove trovare l'immagine da visualizza nella schermata di boot
password --md5 $1$6ðòüZßXÈ$bXTLL8IbDhnwmjyaNNcPG.
Imposta una password, criptata, da fornire per poter accedere al
menu o alla command-line.
title Red Hat Linux (2.4.7-10)
Titolo della prima scelta del menu (quot;labelquot;)
root (hd0,2) Hard disk (primary master) e partizione (terza) del device di root.
kernel /boot/vmlinuz-2.4.7-10 ro root=/dev/hda3
Path nel quale si trova il kernel
initrd /boot/initrd-2.4.7-10.img
Path del file system da montare su Ram Disk al boot.
title DOS Il titolo della seconda scelta del menu
rootnoverify (hd0,0) Hard disk (primary master) e partizione (prima) del device di root.
Non tenta di montare la partizione.
chainloader +1 Prova a caricare in cascata il primo blocco della partizione sopra
definita.


Kernel
Quando il boot loader esegue il kernel, questo prosegue con il riconoscimento e
l'inizializzazione dell'hardware presente.

Per ridurre l'occupazione di memoria su disco il kernel normalmente è compresso,
pertanto la prima operazione da eseguire è quella di decomprimerlo in memoria.

Durante il caricamento presenta a video una serie di informazioni, a volte fin troppo
dettagliate, sull'hardware trovato.

Per vedere i messaggi del kernel creati durante l'ultimo boot basta digitare il
comando dmesg, che visualizza esattamente quanto viene visualizzato dal kernel
durante il boot (a volte in tempi troppo rapidi per essere leggibile).
A fine caricamento il kernel lancia il processo init il padre di tutti i processi.


Messaggi del Kernel
Segue un esempio di un dmesg. Alcune parti variano a seconda dell'hardware
presente sul sistema, altre sono sostanzialmente uguali su tutti i sistemi Linux.
Linux version 2.4.13 (root@llocalhost) (gcc version 2.96 20000731 (Red Hat Linux 7.1 2.96-81)) #5 Fri
Nov 9 16:36:50 CET 2001
Mostra le versioni del kernel (2.4.13), del compilatore interno (gcc) e del sistema operativo
Calibrating delay loop... 666.82 BogoMIPS
Test per verificare la velocità del processore. Valori più alti indicano prestazioni migliori.
Memory: 62272k/65536k available (1091k kernel code, 2880k reserved, 315k data, 212k init, 0k highmem)
Rilevazione della memoria fisica disponibile.
CPU: Intel Pentium II (Deschutes) stepping 01
Identificazione del processore
Serial driver version 5.05c (2001-07-08) with MANY_PORTS SHARE_IRQ SERIAL_PCI enabled
ttyS00 at 0x03f8 (irq = 4) is a 16550A
ttyS01 at 0x02f8 (irq = 3) is a 16550A
Inizializzazione delle porte seriali
hda: IBM-DTTA-351010, ATA DISK drive
Identificazione dell'hard-disk

Partition check:
hda: hda1 hda2 < hda5 hda6 hda7 hda8 >
Verifica dell'integrità delle partizioni da montare.


INIT
Init è il padre di tutti i processi, il suo ruolo consiste nel gestire il lancio di tutti i
programmi necessari per rendere il sistema attivo creando i processi a partire da
uno script nel file /etc/inittab.
Nell'inittab vengono definiti:
● le directory con gli script di avvio per i diversi runlevel (/etc/rc.d/rc.0);

● il runlevel di default;

● altri script e comandi che vengono eseguiti al boot o in condizioni particolari.

Il primo script lanciato da inittab è (su Fedora 7) /etc/rc.d/rc.sysinit.
Tra le varie operazioni di init viene eseguito il controllo sulla consistenza dei file
system, se si trovano errori che non possono essere riparati automaticamente è
possibile che il processo di boot si blocchi.
In questo caso viene richiesta la password di root e viene eseguita una shell dalla
quale si può eseguire un file system check manuale.
Dopo aver verificato su quale partizione il kernel si è fermato, si può dare il
comando: fsck.ext2

Es: fsck.ext2 /dev/hda5


/etc/inittab
Il primo script lanciato da inittab è (su Fedora 7) /etc/rc.d/rc.sysinit, che esegue
varie operazioni tra cui:
● Impostazioni di alcuni path generali nella variabile $PATH;
● Configurazione dell'ambiente di rete;
● Avvio della partizione di swap per la memoria virtuale;
● Impostazione del nome dell'host;
● Check del file system root;
● Check delle quote di spazio assegnate agli utenti, se previste;
● Mount del file system root in modalità scrittura/lettura;
● Preparazione del sistema per caricamento dei moduli;
● Check delle dipendenze dei moduli;
● Check di tutti i file system ed eventuali riparazioni;
● Mount di tutti i file system;
● Pulizia di file di supporto al boot e di processi non più attivi;
● Umount dell'initrd;
● Impostazione dell'orologio;
● Inizializzazione delle porte seriali;
● Caricamento Moduli;
● Attivazione dei servizi del runlevel.


Runlevel
Init viene configurato in modo da potere portare il sistema in diversi livelli operativi
ognuno dei quali presenta caratteristiche diverse (programmi e servizi in
esecuzione), detti runlevel.
In genere su Linux sono utilizzati i seguenti livelli:
Runlevel 0 : /etc/rc.d/rc0.d Avvia la sequenza di arresto del sistema (shutdown)
Runlevel 1: /etc/rc.d/rc1.d Modalità singolo utente, nessun altro utente può collegarsi, il
servizio di rete è disabilitato.
Runlevel 2: /etc/rc.d/rc2.d Multiutente, il servizio rete è attivo ma è disabilitato il file
sharing.
Runlevel 3: /etc/rc.d/rc3.d Multiutente, predefinito quando si opera in modalità testuale,
tutti i servizi sono attivi.
Runlevel 4: /etc/rc.d/rc4.d Inutilizzato. Può essere dedicato ad usi personali
Runlevel 5: /etc/rc.d/rc5.d E' il runlevel predefinito quando si vuole avviare Linux in
modalità grafica (viene eseguito il server X)
Runlevel 6: /etc/rc.d/rc6.d Il runlevel 6 è quello di reboot.
Lo script /etc/rc.d/rc gestisce quali processi far partire a seconda del runlevel,
andando ad analizzare le singole directory /etc/rc.d/rc#.d.


Runlevel
Gli script per la gestione dei processi di tutti i runlevel si trovano nella
directory /etc/rc.d/init.d.
Nelle directory dei vari runlevel, invece, esistono una serie di symlink con nomi del
tipo S12syslog o K65identd che puntano agli script contenuti in /etc/rc.d/init.d.
I nomi dei link presentano la seguente nomenclatura:
<azione><ordine><nome>
azione può essere S (start) o K (kill).
S fa partire il servizio associato
K ferma il servizio corrispondente.
ordine indica in l'ordine di esecuzione degli script (dal più basso al più alto).
nome è lo stesso del file presente sotto init.d

Lo script /etc/rc.d/rc è lo script “padre”, quello che a secondo del runlevel richiesto
si occupa di eseguire gli script contenuti nella directory corrispondente.


Runlevel
Esempi:

Se abbiamo il file /etc/rc.d/rc3.d/S85httpd (link a /etc/rc.d/init.d/httpd), si avrà un
server web avviato quando la macchina si troverà al runlevel 3.

Se vogliamo, invece, che venga avviato il server web in questo runlevel, basterà
rinominare il file, sostituendo la lettera K alla S:
mv /etc/rc.d/rc3.d/S85httpd /etc/rc.d/rc3.d/K85httpd

Gli script possono anche essere utilizzati direttamente dall'utente per gestire i
singoli servizi:
/etc/rc.d/init.d/httpd [start | stop | restart] fa partire, ferma, riavvia il server Web

Sotto Fedora i servizi possono essere attivati anche con il comando:
service nome_servizio (start | stop | restart)


Gestione dei servizi
La configurazione dei servizi per i vari runlevel mostrata finora permette una
grande versatilità, ma non è facilmente gestibile.

Per aiutare l'utente nella configurazione dei servizi disponibili al boot si possono
usare dei tool testuali o grafici.

I più comuni sono:

serviceconf permette di configurare i servizi per i singoli runlevel (grafico)
ntsysv per configurare i servizi del runlevel corrente
(testuale con interfaccia semigrafica)
chkconfig per tutti i runlevel. (testuale a riga di comando)

E' consigliabile disattivare tutti i servizi che non si utilizzano per due OTTIMI motivi:

● minore consumo di risorse: soprattutto CPU e RAM
● sicurezza: un servizio attivo è passibile di attacchi da parte di hacker


Installazione dei programmi
Inizialmente in Unix l'installazione dei programmi doveva essere eseguita
manualmente e richiedeva la compilazione dei sorgenti in genere scritti in C/C++.
Ancora oggi questo metodo è utilizzato anche se è stato affiancato da soluzioni più
sofisticate e più facili da utilizzare.
Per installare un programma partendo dal codice sorgente è necessario:
● scaricare i file sorgente normalmente raccolti in un file di tipo tar.gz

● decomprimere il file di archivio: tar xvzf programma.tar.gz

● posizionarsi nella cartella ottenuta: cd programma

● se presente il file configure digitare: ./configure

verrà creato il file con le istruzioni per la compilazione, il Makefile
● digitare il comando: make

● digitare il comando (opzionale): make install

Per disinstallare un programma se presente si usa il comando: make unistall
Diversamente vanno cancellati a mano tutti i file installati.
La personalizzazione del kernel di Linux deve essere eseguita in questo modo.
Nella cartella che contiene i sorgenti del kernel digitare:
make menuconfig per selezionare le opzioni necessarie
make bZimage per creare l'immagine compressa del kernel


Vantaggi nell'uso dei sorgenti
Lo svantaggio dovuto ad una maggiore complessità e necessità di una conoscenza
più approfondita delle fasi di compilazione, viene ampiamente ripagato dai vantaggi
forniti dall'uso dei sorgenti.

Poter installare software e compilare lo stesso kernel tramite i sorgenti ha dei
grandi vantaggi che l'installazione diretta di binari non offre.

● Aumento delle performance tramite ottimizzazioni e razionalizzazioni,
● Possibilità di customizzazione,
● Possibilità di correzione di bugs tramite patch
● Possibilità di eseguire aggiornamenti in modo rapido, appena sul sito del
produttore appaiono i sorgenti di una nuova versione.

In particolare per il kernel la necessità di compilazione è quasi d'obbligo su sistemi
in produzione per i quali non si vogliano mantenere kernel generici o con il
supporto di innumerevoli moduli come quelli comunemente forniti nelle distribuzioni
standard.
Si ricordi che un kernel monolitico, ad esempio, ha una maggiore velocità di
esecuzione, una minore occupazione di memoria ed una maggiore stabilità.


RPM
Red Hat ha creato diversi anni fa una utility, RPM (Red Hat Package Manager),
che facilità tutte le operazioni necessarie alla gestione dei programmi.
RPM, serve per installare, disinstallare, aggiornare, interrogare, verificare e
costruire pacchetti software (packages).
RPM gestisce le dipendenze solo di primo livello (non è recursivo).
Se per l'installazione di un package come prerequisito è necessario un altro
package, RPM indica il package mancante, ma non se a sua volta “dipende” da
altri.
Analogamente se si prova a disinstallare un package da cui ne dipendono altri si
viene avvisati di questa evenienza e l'operazione viene interrotta.

Gli RPM automaticamente copiano i file di un pacchetto nelle directory giuste (logs
in /var/log, file di configurazione in /etc/, binari in /usr/bin o /usr/sbin, script di
startup in /etc/rc.d/init.d/ ecc.) e verificano la presenza di conflitti o installazioni più
recenti.
Un RPM non cancella mai nulla che non abbia installato.
Se deve sostituire o cancellare un file di configurazione, per esempio, mantiene il
file esistente aggiungendo il suffisso .rpmsave.


Uso di RPM
Comandi principali
rpm -i [opzioni] [pacchetti] Installazione pacchetti RPM
rpm -U [opzioni] [pacchetti] Aggiornamento di pacchetti RPM
rpm -e [opzioni] [pacchetti] Disinstallazione di pacchetti RPM
rpm -q [opzioni] [pacchetti] Interrogazione di pacchetti RPM
rpm -V [pacchetto] Verifica del pacchetto
esempi:
$ rpm -qa | grep smb Visualizza i pacchetti il cui nome contiene “smb”
libsmbios-libs-0.13.10-1.fc7
libsmbclient-3.0.26a-0.fc7
smb4k-0.8.4-1.fc7
$ rpm -ql smb4k | more Elenca file contenuti in un pacchetto installato
$ rpm -qlp smb4k.rpm | more Elenca file contenuti in un pacchetto rpm
rpm usa un database nel quale memorizza i pacchetti installati.
Fedora durante la fase di installazione crea il file /root/install.log che contiene
l'elenco di tutti i pacchetti installati.
Per avere un elenco aggiornato di tutti i pacchetti installati sul sistema, si può
impartire il comando: rpm -qa | sort > /root/install.log


RPM
Convenzione dei nomi dei package
nome-versione-release.arch.rpm
esempio:
efax-0.8a-11.i386.rpm ottimizzato per cpu Intel 386
efax-0.8a-11.i686.rpm ottimizzato per cpu Intel P4 e successive
efax-0.8a-11.x86_64.rpm ottimizzato per S.O. a 64 bit e cpu Intel a 64 bit
Per la ricerca dei pacchetti precompilati si può usare il comando rpmfind o il sito:
http://rpmfind.net/linux/RPM/
Interfacce grafiche per RPM
Per un uso più comodo si possono gestire gli rpm usando delle interfacce grafiche.
Le più comuni sono: gnorpm, kpackage, xrp, rpmdrake, pkgview
Svantaggi
● I file sono già compilati, se si intende customizzare alcuni flag di compilazione si
deve sempre farlo manualmente partendo da un tar.gz;
● Non sempre nuovi RPM vengono resi disponibili in tempi brevi quando esce una
nuova versione di un programma.
● La gestione delle dipendenze non prevede la recursione.
Ulteriori informazioni sono disponibili su: http://www.rpm.org


YUM Yellow dog Updater, Modified
Yum (http://linux.duke.edu/projects/yum/) è un gestore di package automatico per
sistemi che usano il formato rpm.
Yum trova le dipendenze e mostra quali altri package devono essere installati oltre
quello indicato per una corretta installazione.
Rispetto RPM presenta le seguenti caratteristiche:
● Uso di Repositori multipli

● File di configurazione semplice

● Calcola correttamente le dipendenze (anche recursivamente)

● Uso del formato rpm

● Interfaccia utente semplificata.

L'uso è molto semplice:
yum [install | update | remove] package_1 [package_2 .... package_n]
Per configurare yum si usa il file /etc/yum.conf
Per la ricerca dei package yum si appoggia a dei Repository

Anche per yum esistono dei frontend grafici, fedora usa pirut
Si può installare un altro frontend che presenta delle funzioni avanzate: yumex
$ yum install yumex


YUM Repository
Fedora si appoggia ai suoi Repository ufficiali, ma è conveniente aggiungerne altri
al fine di poter scegliere tra un più ampio ventaglio di software già precompilato per
la propria distribuzione.
Per aggiungere dei repository è sufficiente creare un nuovo file con
estensione .repo all'interno della cartella /etc/yum/repos.d

$ cat /etc/yum.repos.d/livna.repo
[livna]
name=Livna for Fedora Core $releasever - $basearch - Base
baseurl= http://rpm.livna.org/fedora/$releasever/$basearch/
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-livna

$ cat /etc/yum.repos.d/dries.repo
[dries]
name=Extra Fedora rpms dries - $releasever - $basearch
baseurl=http://ftp.belnet.be/packages/dries.ulyssis.org/fedora/fc$releasever/
$basearch/RPMS.dries/
gpgkey=http://dries.ulyssis.org/rpm/RPM-GPG-KEY.dries.txt
gpgcheck=1
enabled=1


Altri package manager
Quanto detto finora per la gestione dei pacchetti rpm, vale non solo per Fedora, ma
per tutte le distribuzioni che utilizzano l'rpm come package manger.
Altri package manager evoluti tipo yum sono:
YaSt (Yet Another Setup Tool) utilizzato da SUSE
urpmi utilizzato da Mandriva

DPKG
Le distribuzioni debian e quelle su essa basate usano dpkg (al posto di rpm) e apt
(equivalente a yum)

Le funzionalità sono simili a quelle di rmp ed yum, cambia la sintassi dei comandi.
Per ulteriori approfondimenti si rimanda alla pagina del manuale:
man dpkg
man apt
e al link: http://it.wikipedia.org/wiki/Advanced_Packaging_Tool

Anche in questo caso esistono dei frontend grafici che ne facilitano l'utilizzo:
apitude, synaptic, dselect e gnome-apt


Corso Base su
Linux
Fine Lezione 2

Corso Base su
Linux
Basato su Fedora 7
Lezione 3

Multiutenza
Linux è un sistema operativo multiutente

● Utenti diversi possono avere accesso al sistema e alle risorse ad esso connesse
simultaneamente
● Accesso diretto: tramite console
● Accesso remoto: via rete.
● Ad ogni utente viene assegnato un identificativo (nome utente) ed una password.
● I dati, i programmi e le impostazioni sono completamente separati tra utenti
diversi.
● La sicurezza è garantita da meccanismi di protezione basati su ACL (Access
Control List) che permettono di limitare l'accesso ai files.


Login e Logout
Login
E' l'operazione di autenticazione, tramite nome utente e password, che permette
all'utente l'accesso alle risorse del sistema.

L'accesso può avvenire in modalità testuale (shell) oppure in modalità grafica

Il login può essere eseguito da locale o da remoto.

Lo scopo è di verificare che l'utente abbia i requisiti per accedere al sistema o ad
un suo servizio e metterlo in condizione di interagire con la macchina.

Logout
E' il processo opposto del login: chiude la shell (o l'ambiente grafico) aperta con il
precedente login e tutti i programmi lanciati dall'utente.

Fa in modo che l'utente debba ripetere il login per accedere nuovamente al
sistema.


La Shell
La shell è l'interfaccia testuale tramite la quale l'utente può operare sul sistema.
Viene lanciata dal processo di login dopo che il processo di autenticazione è
andato a buon fine.

La shell è un programma che gestisce la comunicazione fra utente e sistema
operativo interpretando ed eseguendo i comandi dell'utente.

Può avere diversi utilizzi:

● Uso interattivo: il sistema attende i comandi digitati dall'utente, che possono
redirezionare input ed output;
● Configurazione: definire variabili e parametri che vengono utilizzati in ogni
interazione dell'utente con la macchina;
● Programmazione: utilizzando comandi di sistema e funzionalità della shell è
possibile realizzare piccoli programmi (script shell) in grado di
automatizzare operazioni e reagire ad eventi.


Quale Shell ?
Esistono molteplici shell, ognuna delle quali presenta caratteristiche e peculiarità
proprie, di seguito sono riportate le più utilizzate in ambiente Unix.

sh Bourne shell, è disponibile su qualsiasi ambiente UNIX, quindi è la più
utilizzata per creare script shell compatibili e cross-platform.
csh C shell, prende il nome dal linguaggio di programmazione, ovviamente le
funzionalità di tale shell derivano in modo diretto dal C.
bash Bourne Again Shell. Una delle ultime nate, offre le stesse capacità della C
shell, con l'aggiunta di alcune funzionalità come l'history dei comandi e la
TAB Completion
ksh Korn shell. Largamente diffusa è compatibile con la sh sulla parte di scripting
ed ha tutte le funzionalità di interazione della csh. http://www.kornshell.com/
tcsh E' un'evoluzione della csh, con cui mantiene piena compatibilità e introduce
feature come command line editing e name completion.

Sulla gran parte delle distribuzioni Linux è preimpostata di default la shell bash.
La sintassi dei comandi presenti in questo corso è basata sulla bash.


BASH
Bash acronimo di Bourne Again SHell, è la shell di gran lunga più utilizzata in
ambiente Linux.

Alcune sue caratteristiche (presenti anche in altre shell):
- Possibilità di editare la command line
- Autocompletion dei comandi usando il tasto TAB
- Possibilità di definire alias per i comandi
- History infinita (o quasi) dei comandi inseriti
- Funzionalità di scripting e funzioni condizionali e di ciclo.
- Possibilità di definire funzioni e alias
- Possibilità di gestire array indicizzati di dimensioni infinite
- Gestione e controllo dei job
- Espressioni aritmetiche
- Caratteri jolly (metacaratteri) nella gestione dei nomi di file

Nel seguito utilizzeremo i principali comandi della shell, ma l'unico vero modo per
conoscere la bash è usarla.

Sui sistemi Linux viene lanciata automaticamente dopo il login, alternativamente
basta scrivere bash (trovandosi in un'altra shell) per eseguirla.


BASH - Prompt
Il prompt dei comandi si presenta, in genere, con la seguente forma:

[username@hostname ~]$ (prompt utente)

Nel caso dell'utente root il carattere finale $ è sostituito con un # per ricordare che
si ha il controllo completo sul sistema ed un comando errato può creare problemi
rilevanti.

[username@hostname ~]# (prompt root)

Il carattere tilde (~) denota la home directory, cioè la directory di lavoro
dell'utente, nella quale ci si trova dopo aver eseguito il login.

Quando si esegue un cambio directory la tilde viene sostituita dal nome della
directory stessa.

[username@hostname Desktop]$


BASH – Personalizzazione del prompt
Cambiando il valore della variabile d'ambiente PS1, si può personalizzare il prompt
della shell.

Per modificare il contenuto di una variabile, basta digitarne il nome seguito dal
segno uguale (=) e dalla stringa che deve sostituire l'attuale contenuto.

$ PS1='Mio prompt W $:' [INVIO] => Mio prompt ~ $:

Esistono alcuni caratteri speciali che permettono di ottenere un particolare output:
Carattere speciale Output di testo
d Data corrente
h Hostname
w Path corrente
W Directory attuale
u Username
t Ora corrente nel formato 24 ore
@ Ora corrente nel formato 12 ore


Caratteri speciali
Stringhe
Alcuni caratteri sono riservati e hanno un significato particolare per la shell, per
poter trasferire uno di questi caratteri ad un comando come argomento è
necessario racchiuderlo tra apici (').

Una qualunque sequenza di caratteri racchiusa tra apici è una STRINGA.

'mia stringa'

Qualora la stringa contenga un apice al suo interno è possibile racchiuderla tra due
caratteri doppio apice (“).

“l'aurora”

Per passare una stringa contenente caratteri speciali ad un comando è necessario
farla precedere dal carattere $


Sequenze di Escape
Alcuni caratteri speciali devono essere scritti come sequenze di codici Escape.

In tabella sono riportati i principali:

Sequenza di Escape Descrizione
a Avviso (fa suonare il campanello di sistema)
b Backspace
e Escape
f Avanzamento foglio
n Nuova riga
r Ritorno a capo
Barra rovesciata
NNN Carattere il cui codice ASCII è NNN (in base 8)

$ echo $'Prima riganSeconda rigan'

Si ricordi di anteporre il carattere $


Cronologia e Line editing
La shell bash ha la proprietà di conservare la cronologia dei comandi impartiti in un
elenco sequenziale.

Vengono memorizzati i comandi della sessione corrente e delle precedenti.

Per impostazione predefinita la bash conserva 500 eventi, ma è un parametro che
pùò essere variato.

La cronologia è memorizzata in un file di testo all'interno della home
chiamato .bash_history

Per ripetere il comando precedente è sufficiente premere il tasto “freccia su” (↑).
Usando i tasti cursore su (↑) e giù (↓) ci si muove tra i comandi precedentemente
impartiti.

Quando viene evidenziato il comando cercato, si può editare spostandosi
all'interno della riga con i tasti cursore sinistra (←) e destra (→) .


Cronologia uso avanzato
Il comando history visualizza l'intero elenco della cronologia dei comandi.
E' di aiuto quando l'elenco è lungo e l'uso dei tasti cursore richiederebbe molto
tempo per individuare un evento dato diversi comandi fa.
$ history [INVIO]
1 who
2 ls
3 ps
4 history
$

Se l'elenco supera la lunghezza di una pagina è possibile usare il comando:
$ history | more (è necessario premere un tasto per avanzare)

e per cercare un particolare comando si può usare:
$ history | grep ls (filtra le righe che contengono la parola “ls”)
2 ls
$


Cronologia uso avanzato
Conoscendo il numero dell'evento è possibile eseguirlo digitando il punto
esclamativo (!) seguito dal numero dell'evento:
$ !<numero evento> [INVIO]

Premendo i tasti <CTRL>+r è possibile eseguire una ricerca inversa all'interno
della cronologia:
$ <CTRL>+r
(reverse-i-search)'': grep

Una volta impostata la stringa di ricerca per trovare gli altri elementi contenuti nella
cronologia bisogna ripetere la pressione dei tasti <CTRL>+r.


Ridirigere Input ed Output
La shell sposta il testo in “stream”, ovvero in flussi.
Sono presenti tre flussi:

Standard output: costituito dallo schermo del terminale
Standard input: di default è la tastiera.
Standard error: è un flusso specifico per i messaggi di errore normalmente
indirizzato anche esso allo schermo.
Ognuno di questi flussi può essere rediretto ad un file o anche ad un altro comando.

Reindirizzamento dei flussi ad un file
Standard input: si usa l'operatore minore '<'.
$ apropos < my_keywords [INVIO]
Standard output: si usa l'operatore maggiore '>'.
$ ls > my_dir [INVIO]
Standard error: si usa l'operatore '2>'.
$ gcc -c my_program.c 2> my_errors [INVIO]


Ridirigere Input ed Output
Ridirigere l'output all'input di un altro comando

Tale operazione è detta piping, e si verifica quando si connette lo standard
output allo standard input di un altro comando.

Questa operazione viene eseguita specificando i due comandi in sequenza,
separati dal carattere barra verticale “|” (detto pipe).

I comandi così costituiti prendono il nome di pipeline

esempio:
$ ls -l | more

In questo modo lo standard output del comando ls viene ridiretto allo standard
input del comando more, che si occupa di bloccare lo scrolling ed attendere la
pressione di un tasto per continuare la visualizzazione.


Ridirezione nella BASH
La BASH identifica con un numero i flussi:
0 = Standard input - 1 = Standard output - 2 = Standard error
&n è la sintassi con la quale si ridirige un flusso ad un file già aperto.
Ad esempio 2>&1 ridirige 2 (standard error) a 1 (standard output).
Se 1 è stato ridiretto ad un file anche 2 verrà rediretto allo stesso file.
NOTA: In altre shell i caratteri usati per effettuare il Redirectory possono variare

Carattere Azione
> Ridirige lo standard output
2> Ridirige lo standard error
2>&1 Ridirige lo standard error sullo standard output
< Ridirige lo standard input
| Esegue il pipe dello standard output su un altro programma
>> Ridirige lo standard output accodando i dati
2>&1 | Esegue il pipe dello standard error e standard output


Gestione dei JOB
I processi eseguiti in una shell costituiscono i JOB dell'utente.

Più job possono essere eseguiti all'interno di una shell, ma solo un job può essere
attivo sul terminale, quello che legge lo standard input e scrive lo standard output.

Questo processo prende il nome di job in foreground (primo piano), mentre
l'esecuzione degli altri job viene definita in background (sfondo).

La shell assegna a ciascun processo un numero di job univoco che può essere
utilizzato come argomento per i comandi che operano sui job.

Per passare un numero di job ad un programma bisogna farlo precedere dal
carattere %

Visualizzazione dei job in esecuzione
Si utilizza il comando jobs:
$ jobs [INVIO]
[1] – Stopped vi
[2] + Stopped apropos shell


Operazioni sui JOB
Arrestare un job
Digitando <CTRL>+c si interrompe il job in foreground prima del suo
completamento uscendo dal programma.
Utilizzando il comando kill si può interrompere un job in background, specificando
il numero di job come argomento.
Per interrompere il job numero 2, digitare:
$ kill %2 [INVIO]

Sospendere un job
Digitando <CTRL>+z, il job in foreground viene sospeso ed appare il seguente
messaggio sul terminale:
[1] + Stopped apropos shell

Se ci sono job sospesi al momento della disconnessione, la shell impedisce il
logout e visualizza quanto segue:
$ logout [INVIO]
There are stopped jobs.


Operazioni sui JOB
Eseguire un job in background
I nuovi job vengono eseguiti in foreground a meno che non si specifichi
diversamente.
Per eseguire un job in background si deve terminare la riga di comando con il
carattere “&”
$ apropos shell > shell-commands & [INVIO]
[1] 6575

La shell visualizza il numero di job (in questo caso 1) ed il PID (Process IDentifier)
del job (in questo caso 6575)

Al termine del job in background, la shell visualizza il numero di job, il comando e il
testo “Done”, per indicare che il job è stato correttamente ultimato.

[1]+ Done apropos shell > shell-commands


Operazioni sui JOB
Spostare un job in background
Per spostare un job dall'esecuzione in foreground a quella in background bisogna:

● Sospenderlo (<CTRL>+z)
● Digitare il comando bg (per “background”)

Per eseguire un job in background si deve terminare la riga di comando con il
carattere “&”
$ apropos shell > shell-commands [INVIO]
<CTRL>+z
[1]+ Stopped apropos shell > shell-commands
$ bg [INVIO]
[1]+ apropos shell &

Se ci sono diversi job in stato sospeso (Stopped) si deve specificare il numero di
job che si vuole portare in background

$ bg %4 [INVIO]


Operazioni sui JOB
Spostare un job in foreground

Per spostare un job dall'esecuzione in background a quella in foreground si usa il
comando fg.

Per spostare in foreground il job in background più recente:

$ fg [INVIO]

Se ci fossero più job in background si deve specificare il numero di job:

$ fg %3 [INVIO]


Personalizzare la Shell
L'ambiente di lavoro può essere personalizzato in modo da rendere il lavoro più
confortevole o migliorarne l'efficienza.
Una delle personalizzazione è la modifica del prompt vista in precedenza.

Alias di un comando

L'alias è un nome che rappresenta un altro comando.
$ alias ll=”ls -l --color=tty”

Modificare il percorso di ricerca (PATH)

E' possibile modificare il percorso di ricerca tramite la variabile d'ambiente PATH.

Il comando: $ PATH=/usr/bin:/bin:/sbin
assegna le directory /usr/bin, /bin e /sbin al percorso di ricerca

Mentre il comando:
$ PATH=$PATH:/mia_directory
appende /mia_directory al percorso di ricerca. E' equivalente a scrivere:
$ PATH=/usr/bin:/bin:/sbin:/mia_directory


Configurare la Shell
Le personalizzazioni operate in precedenza vengono perse se si esegue il logout.
Per rendere permanenti le impostazioni si possono inserire i comandi all'interno di
file di configurazione che vengono richiamati all'apertura della Shell.

Si usano i seguenti file di configurazione:

/etc/profile Permette una configurazione globale
Modificabile solo dall'utente root (o da un utente amministratore)

.bash_profile, .bash_login, .profile, .bashrc e .bash_logout
Modificabili dai singoli utenti e contenuti nella home directory:

Se la shell è richiamata dal processo di login (login shell) vengono richiamati
nell'ordine i file:
/etc/profile, .bash_profile, .bash_login, .profile

Se non è una login shell viene richiamato il file .bashrc

Alla chiusura della shell viene richiamato il file .bash_logout


Configurare la Shell
Un esempio di file di configurazione della shell è riportato di seguito:

# Make color directory listing
alias ll=”ls –color=auto”
#Set a custom PATH
PATH=”/usr/local/bin:/usr/bin:/bin”
#Set a custom shell prompt
PS1=”[W] $ “

Queste righe possono essere inserite in uno dei file visti in precedenza, è cura
dell'utente scegliere quello corretto in base al risultato che vuole ottenere.


Editor di testo
In Linux esistono una moltitudine di editor di testo alcuni utilizzabili in terminale altri
in ambiente grafico.

Noi approfondiremo l'uso di “VI” (si legge “vi-ai” o “vai”), uno degli editor più
utilizzati nel mondo Unix.

In particolare nelle distribuzioni Linux più recenti si trova VIM un clone di VI,
migliorato in alcune funzionalità.

Un altro editor molto popolare in ambiente Unix è Emacs.

Da segnalare anche LaTeX che è uno dei migliori linguaggi per la stampa e la
realizzazione di testi di carattere scientifico.
A differenza di altri word-processor del tipo quot;WYSIWYG”, LaTeX è un vero e
proprio linguaggio di programmazione che consente di gestire il testo e le immagini
nel modo desiderato, oltre ad offrire la possibilità di implementare nuove funzioni
per specifiche esigenze.


Corso Linux

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (12)

Similaire à Corso Linux

Similaire à Corso Linux (20)

Corso Linux