The book's corner

Ho studiato su questo parziale elenco di libri che ritengo indispensabile per chiunque voglia iniziare a parlare seriamente di architettura, progettazione, programmazione e amministrazione di sistemi operativi.
Come detto, ben lungi dall'essere completo, ma essenziale...


Testi su linguaggio assembly
- Blum "Professional Assembly Language"
- Britton "MIPS Assembly Language Programming" 
- Paul "SPARC Architecture, Assembly Language Programming, and C"

Testi sui linguaggi di programmazione e oltre
- Alfred V. Aho "Compilers: Principles, Techniques, and Tools"
- Mogensen "Basics of Compiler Design" 
- Peter van der Linden "Expert C Programming: Deep C Secrets"
- Kelley & Pohl "C didattica e progrmammazione"
- Kernighan &  Ritchie "Il Linguaggio C"
- Malatesta "Linguaggio C in ambiente linux"
- Robert Love  "Linux kernel developer"
- Corbet, Alessandro Rubini, Kroah-Hartman "Linux Device Drivers"

Testi sull'architettura dei calcolatori e sistemi operativi
- Hennessy & Patterson "Computer architecture - a quantitative approach"
- Hamacher "Introduzione all'archittettura dei calcolatori"
- Tanenbaum "Structured computer organization" 
- Winn L. Rosch "Hardware Bible"
- Tanenbaum "I moderni sistemi operativi"
- Silberschatz "Sistemi operativi, Concetti ed esempi" 
- Stallings "Operating Systems: Internals and Design Principles"
- Tanenbaum "Operating Systems: Design and Implementation" 
- Tanenbaum "Sistemi distribuiti" 

Testi sulle reti di calcolatori
- Tanenbaum "Reti di calcolatori"
- Kurose & Ross "Reti di calcolatori e Internet" 
- Stallings "Data and Computer Communications"
- Lorenzi, Pizzigalli, Rizzi "Reti Internet & tecnologie web"

Solo in seguito, una full immersion su specifiche tecnologie: Oracle, MySql, Solaris, Linux, Windows, Cisco e vari linguaggi di p-scripting: Perl, Python.

Personalmente, nello studio dei Sistemi Operativi ho trovato di eccellente aiuto: Minix, SolOS e RTEMS

NetApp non solo snapshot

Mi sono spinto a scrivere questo articolo che step by step spiega la tecnologia adottata da NetApp per gestire le snapshot, perché considero questo metodo un modo elegante e alternativo al più comune copy-on-write.

 

In the beginning was...

All'inizio le snapshot erano gestite in modo molto semplice: un backup solo più veloce. Si leggeva tutto il contenuto del disco e quindi lo ricopiava su un secondo disco.

Simple. Effective. Expensive.

Immagina questo tipo di snapshot come una fotocopiatrice: prendi un foglio, scrivi qualcosa su di esso, quando esegui una snapshot, semplicemente, fermati di scrivere e metti il foglio nella fotocopiatrice e fanne una copia.... In questo modo avrai 2 copie del foglio.
Un database potrebbe essere rappresentato come 100 fogli. Fare una snapshot potrebbe essere un procedimento lungo dal momento che dovresti copiare ogni pagina...
Certo, è un procedimento più veloce che copiare tutto a mano!
ok, l'analogia non è proprio perfetta, ma ci si avvicina.

Copy-on-Write Snapshots

Copiare tutti i dati ogni volta, può essere un operazione lunga che richiede molto spazio disco con costi tempo-denaro a volte eccessivi.
Inoltre, dovremo aggiungere il tempo di restore di tutti i dati del backup (snapshot)....
E se potessimo copiare solo i byte modificati?
A questo punto entra in gioco la snapshot copy-on-write. La prima snapshot registrerà una sorta di baseline prima che qualsiasi byte possa cambiare.
Dal momento che nulla è ancora stato modificato, non si avrà spazio utilizzato nella snapshot appena creata.
Ci si aspetta comunque che, prima o poi, qualcosa verrà modificato; si dovranno allora “registrare” queste modifiche. Il sistema copy-on-write andrà perciò a copiare il “vecchio” dato – prima che sia modificato – in un'area di snapshot, quindi sovrascriverà il dato.
Semplice ed efficace!
Ora il nostro backup non occuperà molto spazio dal momento che la snapshot registrerà solo i cambiamenti (delta).
Ma... ci sono dei lati negativi,
Ogniqualvolta che si andrà a modificare i blocchi dati, il sistema dovrà prima leggere il vecchio dato, poi scriverlo nell'area di snapshot, e quindi scrivere il dato aggiornato nella sua posizione.
Nota come il sistema, per ogni aggiornamento, dovrà eseguire due scritture e una lettura.
Questo modo di agire rallenta le cose.
In definitiva, si tratta di un compromesso; perdi in scrittura, ma in compenso non hai bisogno di grandi volumi per gestire la tua snapshot.
Oggi, questo problema viene gestito usando particolari algoritmi di cacheing, i quali possono ridurre la menzionata perdita di performance.



Ok, ma...cosa succede se non hai i dati originali?

NetApp Snapshots

NetApp con il suo filesystem WALF, gestisce il problema in modo differente. Invece di copiare i vecchi dati prima che essi siano modificati, NetApp (ok.. Ontap...) andrà a scrivere queste nuove informazioni in una zona speciale del disco chiamata SnapReserve; successivamente, il puntatore che identifica nel sistema quel dato verrà aggiornato per puntare al nuovo dato scritto nella SnapReserve.

Questo è il motivo per cui ogni volta che viene cambiato un dato (e la cancellazione è intesa come modifica) quest'area si andrà a riempire.
Questo metodo porta con sé indubbi vantaggi; si dovranno registrare solo i delta dei dati – è già un miglioramento rispetto alle performance del copy-on-write - . Dal momento che le snapshot sono solo dei puntatori, quando vorrai fare il restore dei dati (usando il SnapRestore) tutto ciò che il sistema dovrà fare è aggiornare i puntatori ai dati originali, il che è molto più veloce che copiare tutti i dati dell'area di snapshot nella posizione originale, come farebbe il copy-on-write.
Bene, ma c'è dell'altro...

Snapshots Are Views

Sarebbe bello pensare alla snapshot come ad una sorta di vista dei tuoi dati al momento della snapshot... ed essendo dei puntatori ciò è possibile! Se, per esempio, incorri in una delete accidentale di un dato, ti sarà possibile accedere ad una sotto cartella (.snapshot), la quale sarà difatto la tua vista (in read only) verso il passato....

A questo devo aggiungere che anche ZFS è in grado di offrire questa vista tramite la directory .zfs, ma ad eccezione di questa, non conosco altre tecnologie che posseggano questo splendido servizio.

JumpStart installation

Ammetto che l'installazione di Solaris tramite JumpStart, è un'attività abbastanza tediosa...per questo propongo questa guida.

Rispetto al sistema di esempio che ho utilizzato, il lettore, eventualmente, dovrà personalizzare la configurazione in relazione al proprio sistema.

La procedura è stata testata con una macchina Solaris 10 x86 virtualizzata su Vmware (server jumpstart) d'ora in poi SRV-SOL_VM e un SunFire V240 (client jumpstart) d'ora in poi SRV-SOLV240.

STEP #1

Creiamo una directory per salvare l'immagine di Solaris OS.

# mkdir /export/install

Inseriamo il primo CD di Solaris 10 (uno di due) oppure se si ha il DVD inserire questo disco nella macchina SRV-SOL_VM.

Posizionarsi nella directory del CD/DVD dove è anche presente il file setup_install_server.

# cd /cdrom/sol_10_811_sparc/Solaris_10/Tools

Lanciamo lo script setup_install_server per salvare l'immagine del sistema nella directory appena creata.

# ./setup_install_server

(se si sta installando con CD, inserire il CD2 e dalla stessa directory lanciare:

# ./add_to_install_server /export/install).

Queste procedure salveranno dentro la directory install l'immagine del sistema operativo che si andrà ad installare.

STEP #2

[operazione opzionale]: se non vengono inseriti nel file sysidcfg, questi dati verranno richiesti durante l'installazione.

Il file sysidcfg contiene informazioni di sistema come: security, time zone, ecc...

Creiamo una directory per queste informazioni.

# mkdir -m 775 /export/jumpstart

Quindi spostarsi nella directory appena creata, e creare il file sysidcfg, poi inseriamo questi dati di esempio:

# touch sysidcfg

# vi sysidcfg

network_interface=primary

{protocol-ipv6=no netmask=255.255.255.0}

security_policy=none

name_service=none

time_zone=Rome/Europe

system_locale=en

… salva il file..

STEP #3

Se non fatto in precedenza (step#2), creare una directory jumpstart.

# mkdir -m 775 /export/jumpstart

Spostiamoci nella directory appena creata e creiamo il file rules

# touch rules

# vi rules

any - - profile -

..salva il file.

Nella stessa directory creare un nuovo file chiamato profile

# touch profile

# vi profile

install_type initial_install

pool rpool auto auto mirror c0t0d0s0 c0t1d0s0

bootenv installbe bename sxce-xx

Da un terminale facciamo partire il servizio RARP:

# /usr/sbin/in.rarpd -d -a

STEP #4

Prima che un client JumpStart possa iniziare l'installazione, bisogna creare il file rules.ok. Per creare questo file, eseguire check; un run file che si trova nel CD/DVD di Solaris.

# cd /cdrom/sol_10_811_sparc/Solaris_10/Misc/JumpStart_sample

Copiamo il file check nella directory jumpstart.

# cp check /export/jumpstart

Cambiamo directory ed eseguiamo il file

# cd /export/jumpstart

# ./check

Produrrà un'output simile a questo:

Vlidating rules...

Validating profile profile...

The custom JumpStart configuration is ok

Bene, ora verifichiamo se nella directory è stata creato il file rules.ok

STEP #5

Aggiungiamo al file /etc/ethers il MAC-ADDRESS del client ed il suo nome host

# vi /etc/ethers

00-C1-AA-98-C3-B5 SRV-SOLV240

Salva il file..

Modifichiamo il file /etc/inet/hosts con i dati del client

# vi /etc/inet/hosts

SRV-SOLV240 192.168.0.111

..Salva il file

Posizioniamoci nella directory dove si trova il file add_install_client

# cd /export/install/Solaris_10/Tools

Eseguire il file add_install_client con i parametri desiderati

# ./add_install_client -c SRV-SOL_VM:/export/jumpstart SRV-SOLV240 sun4u

Modifichiamo il file /etc/dfs/dfstab

# vi /etc/dfs/dfstab

share -F nfs -o ro, anon=0 /export/install

share -F nfs -o ro, anon=0 /expoer/jumpstart

Lanciamo il comando shareall per esportare i mountpoint di /export/install e /expoer/jumpstart.

# sahreall

Verifichiamo che siano correttamente esportati:

# share

STEP #6

Avviamo la macchina JumpStart client (SRV-SOLV240)

# init 6

Dall'OpenBoot PROM eseguiamo il boot:

ok> boot net – install

FINE!

Solaris 10 from DHCP to Static IP

 

Questo esempio mostra come passare dalla configurazione DHCP ad un ip statico:

modifica il file /etc/hosts

# Internet host table
::1                    localhost
127.0.0.1         localhost
192.168.0.161 quorum-srv     loghost

quindi questi files:
/etc/hostname.INTERFACE
quorum-srv

/etc/defaultrouter
192.168.0.1

/etc/nodename
quorum-srv

rm /etc/dhcp.INTERFACE

cp /etc/nsswitch.files /etc/nsswitch.conf

That' all...