1.3: Software di Base

1.3: Software di Base
●
Messa a punto di programmi
–
Assemblatori, compilatori e interpreti
–
Linkaggio di programmi
–
Il compilatore GNU gcc
–
Ciclo di sviluppo del software
–
Librerie statiche e dinamiche
–
Editor di testo
–
Supporto durante l'esecuzione
●
Salvataggio e ripristino dei dati
●
Amministrazione del sistema
1.3.1
Introduzione
●
●
Software di Base: vedi slide seguenti, riprese da Disp. 1.1, "Introduzione ai Sistemi Operativi"
Consideriamo qui solo alcune categorie di software di base: quelle che riguardano
–
Messa a punto di programmi
–
Salvataggio e ripristino dei dati
–
Amministrazione del sistema
1.3.2
Introduzione (Cont.)
●
Componenti di un sistema di calcolo:
–
Hardware
●
–
Kernel
●
–
Fornisce le risorse di calcolo basilari: CPU, memoria, dispositivi di I/O.
Controlla e coordina l'uso dell'hardware tra i vari programmi per tutti gli utenti; è la parte di un S.O. sempre in memoria e sempre pronta a eseguirsi.
Software di base
●
Le sue componenti definiscono i modi in cui le risorse del sistema vengono usate per risolvere i problemi computazionali degli utenti.
–
–
Utenti
●
Compilatori, sistemi di data base, sistemi di automazione d'ufficio, programmi di calcolo scientifico, video games, etc.
1.3.3
Introduzione (Cont.)
1.3.4
Introduzione (Cont.)
●
●
●
I sorgenti del Kernel sono spesso meno del 5% dei sorgenti complessivi di una distribuzione.
Distinzione non netta tra programmi di sistema e programmi applicativi.
Il software di base fornisce un ambiente standard per lo sviluppo e l'esecuzione di programmi, e più in generale per l'utilizzazione pratica del sistema. Può essere diviso in varie categorie:
–
Programmi a complemento delle funzionalità del kernel (lilo, init, ...; daemons)
–
Interfaccia utente (sh, ksh, bash, ...)
–
Librerie di funzioni standard di uso comune (libc, libm, libcrypt, ...)
–
Supporto per linguaggi di programmazione (cc, as, ld, ar, pc, perl, python, javac, ...)
–
Caricamento, esecuzione e profiling di programmi (sh, adb, sdb, prof, time, ...)
–
Modifica di file (ed, vi, emacs, ...)
–
Manipolazione di file (cp, mv, rm, mkdir, ...)
–
1.3.5
Assemblatori, Compilatori, Interpreti
●
Calcolatore: capisce solo linguaggio macchina
●
Uomo: preferisce linguaggi di alto livello (più vicini alla logica umana)
●
Assemblatore: traduce linguaggio macchina simbolico (assembler) in linguaggio macchina
–
●
Compilatore: traduce linguaggio ad alto livello in assembler (o direttamente in linguaggio macchina)
–
●
C, C++, Pascal, Fortran, ..., indipendenti dal tipo di CPU
Interprete: legge ed esegue linguaggio ad alto livello (senza rappresentazione in assembler né linguaggio macchina)
–
●
Linguaggio assembler, specifico per ogni tipo di CPU
Shell, Perl, Lisp, Basic, ...
Approccio intermedio: compilazione in linguaggio intermedio, 1.3.6
Assemblatori, Compilatori, Interpreti (Cont.)
●
●
Programmi interpretati:
–
tempi di esecuzione molto maggiori dei programmi compilati
–
diagnostica migliore ⇒ tempi di messa a punto più veloci, specie per applicazioni complesse ⇒ maggiore produttività
–
Maggiore concisione e potenza del linguaggio.
Più un linguaggio è complesso e sofisticato, più è lento.
Naturalmente esistono eccezioni:
Tempo di esecuzione
Unix, 250 Mhz
Windows/NT, 400 Mhz
Ling. C
0.36 sec
0.30 sec.
Ling. C++
1.7 sec
1.5 sec
Java
4.9 sec
9.2 sec
Perl
1.8 sec
1.0 sec
●
Righe di codice
150
70
105
18
1.3.7
Assemblatori, Compilatori, Interpreti (Cont.)
●
●
●
Dal punto di vista di un S.O., un assembler o compilatore è un programma eseguibile (come gli altri)
–
Input: file sorgente (codice ASCII, con frasi aderenti alla sintassi del linguaggio)
–
Output: file oggetto (contenente del codice oggetto rilocabile, eventualmente dopo compilazione+assemblaggio); il codice (linguaggio macchina) va assiemato con quello di altri moduli (ad es. funzioni di libreria) per produrre un file eseguibile, cioè il programma vero e proprio.
–
Il file eseguibile, dopo la fase di caricamento in memoria (loading), può fare uso di routine di librerie dinamiche, richieste al S.O. durante l'esecuzione, se e quando necessario.
Un file oggetto contiene il codice generato, ma manca dei riferimenti completi agli indirizzi delle routine del codice comprese in altri moduli (che al momento della singola compilazione sono sconosciuti).
1.3.8
Questi riferimenti vengono impostati dal linker, che produce il file eseguibile La Fase di Link
Collegamento tra tre moduli: il modulo A include chiamata a prog1() nel modulo B, che include chiamata a prog2() nel modulo C.
●
000000 intern: ­­­­
intern: prog1
intern: prog2
extern: prog1
extern: prog2 extern: ­­­­ prog0:
000000 call 000000
b00000 dati0 Modulo A
prog1: 000000 prog2: call 000000
b00000 dati1 Modulo B
b00000 dati2 Modulo C
Testata (header) del modulo oggetto rilocabile 1.3.9
La Fase di Link (Cont.)
●
Risultato dopo la fase di link (file eseguibile):
testata (header)
del file eseguibile
000000 00b000 call 00bd00
prog0 call 0e6000
prog1 00e000 prog2 b00000 dati0 bc0000 dati1 be0000 dati2 1.3.10
Gcc
●
Compilatore gcc di GNU/Linux: integra tutte le fasi:
–
Preprocessore di linguaggio C o C++:
#include <stdio.h>
#define BUFSIZE 2048
–
Compilazione, con produzione di codice assembler (da file.c a file.s)
–
Assemblaggio, con produzione di codice oggetto rilocabile (da file.s a file.o)
–
Link, con produzione di file eseguibile (da più file.o, file.a (librerie statiche) e/o file.so (librerie dinamiche) a file).
–
N.B. ­ il compilatore gcc permette di inserire frasi in assembler all'interno di codice in C, mediante la direttiva asm( )
●
Estremamente utile nella scrittura del codice del Kernel, e dei device driver di periferiche.
1.3.11
Librerie
●
Uso delle funzioni di libreria: è essenziale, per non "reinventare la ruota"
●
Ogni linguaggio ha un ampio corredo di librerie di base
●
Fase di link: due possibilità
–
–
Librerie statiche
●
Codice inserito nel file eseguibile
●
L'eseguibile è autosufficiente
●
Grosso spreco di spazio (memoria secondaria e primaria).
Librerie dinamiche
●
●
Il linker inserisce nell'eseguibile soltanto il nome delle funzioni richieste e gli indirizzi del codice dove compaiono le chiamate
Al run­time avviene il caricamento in memoria (una volta sola per tutto il sistema) dei moduli dinamici necessari, e viene effettuato 1.3.12
dinamicamente il collegamento tra il programma e dette funzioni
Librerie (Cont.)
●
Esempio "flagrante" per lo spazio utilizzato:
$ cat prova.c
/* programma prova.c */
int main(void) {
printf("ciao ciao...\n");
return 0;
}
$ gcc ­o prova.dyn prova.c
$ gcc ­static ­o prova.sta prova.c
$ ls ­l prova.dyn prova.sta ­rwxr­xr­x 1 luca ax 13769 Nov 30 17:59 prova.dyn ­rwxr­xr­x 1 luca ax 1629324 Nov 30 18:00 prova.sta 1.3.13
Librerie (Cont.)
$ size prova.dyn prova.sta
text data bss dec hex filename 1063 236 24 1323 52b prova.dyn 351129 8068 3876 363073 58a41 prova.sta
$
●
Dimensione del file eseguibile (occupazione in memoria secondaria):
–
●
13 KB (dinamico) ­­ 1.6 MB (statico)
Dimensione del programma in memoria (occupazione in memoria primaria):
–
1.3 KB (dinamico) ­­ 363 KB (statico)
1.3.14
Librerie (Cont.)
●
Librerie in Unix/Linux:
–
Ubicate di solito in /lib o /usr/lib
–
Estensione .a (librerie statiche), .so (librerie dinamiche)
–
Nomi del tipo libxxx.a , libxxx.so
●
Esempi: –
/usr/lib/libc.a
–
/usr/lib/libm.so
1.3.15
Editor di Testo e ambienti IDE
●
La fase di editing è la prima nel ciclo di sviluppo del software
●
Esistono editor per tutti i gusti:
●
●
–
Line­oriented (ed(1))
–
Full­screen (vi(1), vim(1), emacs(1))
–
Grafici
–
Syntax­driven (guidati dalla sintassi)
Ambienti IDE (Interactive Development Environment): integrano tutte le componenti del ciclo di sviluppo del software.
Alternativa agli IDE: utility Make
–
Nata in ambiente Unix; poi ripresa in molti altri ambienti
–
Permette di automatizzare, a livello di riga di comando, tutte le fasi di compilazione­link­run, limitando il ciclo alle sole operazioni strettamente 1.3.16
Supporto all'Esecuzione
●
Il S.O. offre diversi tipi di supporto nella fase di esecuzione/test/messa a punto di un programma:
–
Controllo del codice di uscita (exit code)
●
–
In Unix/Linux: viene trasmesso al processo padre
Controllo della situazione in caso di eventi anomali
●
●
●
Istruzione illegale (istruzione privilegiata, o inesistente, o con indirizzo erroneo di un operando)
Indirizzo illegale (accesso ad un'area inesistente o non allocata al processo)
Insufficienti privilegi (accesso ad un'area o comunque a una risorsa protetta, senza i privilegi necessari)
●
Overflow numerico in un'operazione aritmetica
●
Effetto: trap ­­ il Kernel interviene ­­ il processo viene abortito.
1.3.17
Supporto all'Esecuzione (Cont.)
–
Caricatore/linker dinamico al run­time, per l'uso delle librerie dinamiche
–
–
Obiettivo: ritardare al massimo il momento del link
Supporto (nel Kernel) per programmi di tipo debugger
●
●
●
Sono spesso di tipo simbolico: permettono di lavorare con i veri nomi di variabili, funzioni etc.
Unix/Linux: esiste una chiamata di sistema specifica, ptrace(2), che permette ad un processo di lanciarne un altro e recuperare il controllo dopo ogni istruzione (funzionamento passo passo, o step­by­step).
v. gdb(1)
1.3.18
Ciclo di Sviluppo del Software
●
Il ciclo classico:
–
Edit ­ compile +link ­ load, run ­ test&debug ­ edit ...
Utente al
terminale
Programma
sorgente
Editing
Modulo
oggetto
Compilazione
Altri
moduli
oggetto
File
eseguibile
Link
Caricamento
Programma
caricato in
memoria
(RAM)
Esecuzione
(RAM)
Librerie
dinamiche
1.3.19
Risultato
Salvataggio e Ripristino dei Dati
●
●
●
●
È uno dei compiti più importanti di un amministratore di sistema (oltre a quello di abilitazione degli utenti).
Salvataggio dati (backup): copiare dati su supporto amovibile
–
Su disco / nastro / floppy / CD­ROM etc.
–
Backup completo o incrementale
–
Backup abbinato con utility di compressione dati
–
Backup distinto per volumi (file­system) o per raggruppamenti funzionali.
Ripristino dati (restore): recuperare i dati salvati, nel caso di perdita di quelli originali
Unix/Linux: diversi programmi
–
dd(1) ­­ disco a disco
–
tar(1), cpio(1) ­­ directory­tree a file, nastro, floppy disk (anche multivolume)
1.3.20
Salvataggio e Ripristino dei Dati (Cont.)
●
tar ­ Tape ARchiver
–
–
–
–
tar ­cf archive­file file­or­dir ...
●
­c = create archive
●
­f = prox. arg. è il file di archivio:

/dev/fd0
(backup to floppy)

/dev/mt0
(backup to magnetic tape unit)

/backups/archive.tar(backup to archive file)

­
(backup to stdout)
●
file­or­dir: tutti gli argomenti rimanenti sono file da salvare; per ogni directory, l'arborescenza sottostante è salvata per intero
tar ­xf archive­file
●
­x = extract from archive

­
(extract from stdin)
●
tutti i pathname relativi nell'archivio sono estratti a partire dalla cartella attiva
tar ­tf archive­file
●
­t = list table of files in archive
altre opzioni:
●
­v
be verbose (on create/extract/table)
1.3.21
●
­z
l'archivio è o deve essere compresso con gzip(1)
Salvataggio e Ripristino dei Dati (Cont.)
●
cpio ­ CoPy In/Out
–
–
–
–
–
●
cpio ­o <file­list >archive­file
●
create archive
cpio ­i <archive­file
●
extract from archive
cpio ­p <file­list
●
copy (pass) files, creando copie a partire dalla cartella attiva
altre opzioni:
●
­v
be verbose
●
­c
use portable format (ASCII­only)
●
­d
create directories as needed
●
­B
use 5120­byte blocks for read/write
●
­m
restore modification time
esempio:
find . ­newer LastBackupFile | cpio ­oB >/dev/fd0 # incremental backup
dd ­ Data Dump (convert and copy files)
– dd if=ifile of=ofile bs=size count=numrec
– Utile per I/O ottimizzato da/verso "raw devices"
– Esempi:
1.3.22
Amministrazione Sistema
●
Vari programmi disponibili in un S.O.
–
Abilitazione e identificazione degli utenti
●
–
–
Login, passwd; adduser(1), etc.; /etc/passwd, /etc/shadow, /etc/group, etc.
Conteggio e addebito di risorse utilizzate (resource accounting and billing)
●
Tempo CPU, spazio disco, etc.
●
Unix System V: utilities come sar(8), etc.
●
Linux, Solaris etc.: meccanismo dei quota (v. quotaed(8), quotaon(8))
Controllo di accesso a risorse, condivisione tra gruppi di utenti
●
Unix/Linux: meccanismo UID, GID
1.3.23