|
Data
|
Argomento
|
Tipo
|
N Ore
|
Riferimento
|
|
Lun. 27/02/2017
|
Spiegazione dell'orario e dell'organizzazione delle lezioni/esercitazione. Introduzione al corso: programma, modalità di esame (con date fino a Settembre 2017) e testi consigliati (Lucidi Programma); necessità di registrazione per gestione liste prove in itinere ed esami. Illustrazione del sito: oltre all'applicazione per gli esami, il registro on-line delle lezioni e la sezione dei Lucidi (comunicazione della password di lettura).
Generalità su cosa è un Sistema Operativo e, soprattutto, su cosa fa un Sistema Operativo. Definizione di Multiprogrammazione e di Sistema Operativo Multiprogrammato: introduzione al concetto di processo (entità attiva che esegue un programma, entità passiva) e ai vari 'tipi' di processi (I-O bound e CPU bound). Definizione di Multiprocesso e di Multiutenza. Brevemente il caso dei Sistemi Operativi Time-sharing (scheduling a quanti di tempo). Sistema Operativo come gestore delle risorse (Lucidi Introduzione sui SO, 1-7). Iniziato spiegazione Gestore dei processi (Nucleo/Kernel). Ripreso concetto di processo, spiegato processi utente e processi di sistema, funzioni tipiche di un kernel (in particolare scheduling). Stati di un processo (esecuzione, sospeso e pronto) e transizioni di stato, descrittore di processo (code dei processi pronti e code di sospensione) e cambio di contesto. (Lucidi Introduzione sui SO, 8-9).
|
L
|
2
|
|
|
Mer. 01/03/2017
|
Ripreso spiegazione del primo livello di un sistema Operativo: Nucleo/Kernel in particolare stati di un processo (esecuzione, sospeso e pronto) e transizioni di stato, descrittore di processo (code dei processi pronti e code di sospensione) e cambio di contesto. Algoritmi di scheduling non preemptive e preemptive; esempi di algoritmi di scheduling: algoritmo round-robin basato su quanti di tempo (preemptive con uso di un timer); algoritmo di scheduling a priorità statica basato su più code, una per ogni livello di priorità algoritmo a priorità dinamica con uso di quanti di tempo differenti e meccanismi di penalizzazione/promozione con priorità che quindi cala o cresce sulla base del consumo del quanto di tempo. Introdotto i due tipi di interazione fra processi in ambito di programmazione concorrente: interazione indiretta o competizione e interazione diretta o cooperazione. Problema del deadlock. Gestore dei dispositivi di I/O: in particolare, gestione degli interrupt. Gestore della memoria centrale: in particolare gestione della allocazione con tecnica della paginazione (TDP, traduzione indirizzi logici in fisici e cache delle pagine). Memoria virtuale: in particolare gestione basata su segmentazione paginata. Gestione della memoria secondaria velocemente (vedi fine lezione). Gestione interfaccia utente: interfacce grafiche e testuali (Lucidi Introduzione sui SO, 10-21). File System - Definizione di file, funzioni tipiche del gestore, tipi di file (Lucidi File System, 1-2).
|
L
|
2
|
|
|
Ven. 03/03/2017
|
Prime due ore: Ripreso File System - Punto di vista dell'utente con illustrazione veloce dei principali comandi. Concetto di descrittore di file e di directory (derivazione da telephone directory). Strutturazione dei direttori: direttori ad albero (nome assoluto, relativo al direttorio corrente e relativo semplice) e a grafo (concetto di Link) (Lucidi File System, 3-7).
Uso di PC collegato in rete e videoproiettore. Nel seguito fra parentesi si indicano i lucidi della sezione "Lucidi su UNIX e il Bourne Shell" cui il registro fa riferimento.
Introduzione a UNIX: storia e connessione con Linguaggio di Programmazione (di sistema) C; Unix come sistema operativo multigrammato (e multiprocesso) e multiutente (Luc. 1). Fase di autenticazione: necessità di login e logout (Luc. 2): concetto di terminale (virtuale). File system: file come stream di byte e come astrazione unificante per file ordinari, direttori e file speciali come i dispositivi (contenuti in /dev) (Luc. 5). Struttura del File System di UNIX: direttori tipici (Luc. 7). Mostrato risultato del comando cd per cambiare directory e mostrato risultato del comando pwd. Spiegazione della fase di autenticazione: file /etc/passwd con suo formato (comando cat per visualizzare un file di testo) e file /etc/shadow, esempio di comando inserito nel file /etc/passwd diverso da una shell (Luc. 3 e 4).
Ultime due ore: Shell - Comando id per vedere UID e GID. Processore comandi come processo e generatore di processi: in genere, un processo associato all'esecuzione di ogni comando (eccezioni: comando exit e cd) (Luc. 13); mostrato il comando ps e poi ps con opzione -f (full) per sottolineare il concetto di processo padre e processo figlio. Concetto di opzioni dei comandi, con possibilità di combinarle assieme e comando man. Ripreso comando ps: mostrato ps -fl per vedere lo stato dei processi: S (sleeping) e R (running); comando ps con opzione -e per fare vedere tutti i processi attivi nel sistema e quindi anche ps -ef (processo init e processo kswap). Mostrato l'invocazione della stessa shell e di diverse shell (luc. 26): accennato alla opzioni -x per la Bourne Shell. Dimostrazione della multi-utenza: collegamento anche con un secondo account (sonod) e mostrato di nuovo comando id e comando who (anche versione w). Mostrato il comando man, ad esempio man who e man ps.
Ripreso organizzazione del File System e nomi di file assoluti, relativi al direttorio corrente e relativi semplici (Luc. 6). Nomi molto lunghi e con più caratteri punto: introdotto comando ls (list).
Caso particolare di nomi che iniziano con il carattere punto: uso di opzione -A per visualizzare questi nomi "nascosti". Spiegato perchè di questa scelta, introducendo i due elementi sempre presenti in ogni directory: "." e ".." e il suo effetto sull'albero che diventa un grafo e mostrato esempi di uso: in particolare, ls -a, cd .. o cd ../.. (sempre Luc. 6).
|
L
|
4
|
|
|
Lun. 06/03/2017
|
Shell - Mostrato simulazione della gerarchia del lucido 6 (comando ls -R, cioè ricorsione). Approfondimento su ls: varie opzioni (Luc. 16); esempi di ls -r, ls -t, ls -F e ls -l e spiegato nel dettaglio importanza di ls -d.
Metacaratteri principali trattati dalla shell (* e ?) (sempre Luc. 6): spiegato concetto di pattern matching ed esempi di uso; mostrato effetto con opzione -x della shell (usando jsh che implementa la Bourne shell) dell'uso di * e ?.
Protezione dei file (Luc. 8): diritti di accesso (r, w e x) per user, group e other e uso di ls -l (long). Concetto di superutente (root) e spiegato come avvengono i controlli: fatto vedere diritti di /etc/passwd e di /etc/shadow e fatto vedere accesso allo stesso file da parte di due utenti diversi, ma appartenenti allo stesso gruppo. (Luc. 15) Il comando chmod, versione simbolica ed ottale: mostrato esempio di uso sull'accesso ad un file. Significato dei diritti di accesso per i direttori. Comandi chown e chgrp solo per il SUPERUTENTE (Luc. 15).
Concetto di link (hardware) per i file (comando ln, Luc. 10) e differenze con il comando cp per copiare file. Spiegato come si realizza in UNIX il concetto di link: struttura direttori (Luc. 11) con i-number e i-node (Luc.12): mostrato uso di opzione -i di ls. Cancellazione file (comando rm e importanza della opzione -i, interactive): cancellazione di un link e se numero di link uguale a zero anche del contenuto del file.
Mostrato funzionamento dei link hardware per i direttori e comando mkdir. Comando rmdir (solo con direttorio vuoto) e opzione -r di rm per cancellazione ricorsiva e quindi anche di direttori.
|
L
|
2
|
|
|
Mer. 08/03/2017
|
Shell - Comando per spostare i file o semplicemente rinominarli (comando mv): spiegazione in base ai comandi ln e rm.
Concetto di link software per file e direttori (comando ln -s) e differenza rispetto al link hardware: necessità di uso per i direttori e per collegare gerarchie residenti su dispositivi fisici diversi.
Ripreso sintassi generale comandi (Luc. 14): in particolare, comandi multipli sulla stessa riga separati dal simbolo di punto-e-virgola (;); ricordato il significato del nome catenate per il comando cat.
Due dei 3 bit speciali (Luc. 9) per i file eseguibili (SUID e SGID): esempio di uso di SUID con programma che visualizza un file leggibile solo dal proprietario con accesso di un utente che non è il proprietario. Il comando which per cercare dove è un comando, ad esempio passwd. Il comando passwd come esempio di uso in UNIX di SUID per leggere/scrivere nel file /etc/shadow su cui ha l'accesso in scrittura e lettura solo l'utente root (super-utente).
Generalizzazione del concetto di file (Luc. 8 del File System). Concetto di filtro e di standard input, standard output e standard error: associazioni di default e loro modifica con RIDIREZIONE (Luc. 18, 19). Ripreso schema di esecuzione di un comando con un processo figlio con trattamento della ridirezione (Luc. 20). Ridirezione in uscita per creare file vuoto (ridirezione a vuoto). Primi esempi di ridirezione in uscita e in append usando il comando pwd e ls.
|
L
|
2
|
|
|
Ven. 10/03/2017
|
Esercitazione in Laboratorio (S1, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Guida all'installazione ambiente di lavoro (Ubuntu 16.04 32bit su VirtualBox). Editor di testo: vi, vim, vimtutor. Uso della shell: console grafica e testuale; esercizi a riga di comando: ls, cp, mv; esempi di nomi assoluti e relativi; directory corrente e comando cd; permessi di accesso ai file; modifica dei permessi con chmod e chown; man e la documentazione in linea.
|
E
|
6
|
|
|
Lun. 13/03/2017
|
Shell - Ripreso concetto di filtro e di standard input, standard output e standard error e possibilità di RIDIREZIONE (Luc. 18, 19 e 20). Comandi che possono essere usati sia come comandi normali che come filtri (di nuovo Luc. 18). Uso come filtri in particolare per ridirezione in ingresso (oltre che in uscita): in particolare il filtro cat usato sia come semplice editor, concetto di EOF da tastiera, ^D e differenza dall'abort di un comando con ^C, e sia come alternativa al comando cp. Altri esempi di filtri (di nuovo Luc. 18): more, sort [opzioni -r, reverse, -f, insensibile a maiuscole/minuscole, -c/-C, check se ordinato (spiegato valore di successo e di insuccesso con echo $?), -u, unique cioè ordinamento con eliminazione dei doppi], grep (opzioni -n per vedere il numero d'ordine della linea nel file, -i per cercare il pattern maiuscolo o minuscolo, -v per invertire la ricerca e sintassi particolari come '^c' per cercare le linee che iniziano per c, 'a$' per cercare le linee che terminano per a, e infine '\.$' per cercare le linee che terminano con il carattere punto (necessità di usare il meta-carattere di escape \), rev, head, tail, wc (con opzioni -c, -w, -l e differenze fra comando e filtro). Ridirezione dello standard error (Luc. 22) con esempi.
Piping: composizione di comandi/filtro (Luc. 23, 24). Realizzazione mediante più processi e canali di comunicazione. Esempi semplici con uso anche del filtro tee ed esempio che mostra la presenza di un processo per ogni comando in piping.
|
L
|
2
|
|
|
Mer. 15/03/2017
|
Shell - Ripreso ridirezione per spiegare ridirezione dello standard error (e volendo anche dello standard output) su /dev/null. Esecuzione di comandi in background (Luc. 25): problema di ridirezione standard output (consigliata) e dello standard input (necessaria almeno in Bourne shell!). Uso del comando kill. Altri comandi: date e diff (Luc. 17, comando find lasciato da guardare da soli). Concetto di ambiente di shell (Luc. 27): il processo SHELL generato per l'esecuzione di ogni comando riceve per copia l'ambiente dello shell padre (con ad esempio, PATH, HOME e direttorio corrente): comando env per visualizzare l'ambiente. Spiegato concetto di variabile di shell (Luc. 28): valore come stringa, sintassi assegnamento e sintassi per riferire il valore (Luc. 28). Differenza fra variabili di ambiente e variabili di shell: il comando export per passare una variabile di shell nell'ambiente ed esempio relativo (di fatto primo esempio di file comandi cioè di script e quindi spiegato come scriverlo con un editor e quindi impostargli il diritto di esecuzione). Mostrato che una modifica di una variabile di ambiente effettuata da un sotto-shell (con un altro file comandi) ha effetto solo per quel processo e non anche nel processo padre. Sostituzioni attuate dallo shell (Luc. 29). Mostrati gli ulteriori metacaratteri [ ] (Luc. 30) con vari esempi (Luc. 31).
|
L
|
2
|
|
|
Ven. 17/03/2017
|
Esercitazione in Laboratorio (S2, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Struttura shell script: variabili $# e $n e costrutti true, false, test e case. Manipolazione file system: comandi mkdir, rm.
|
E
|
6
|
|
|
Lun. 20/03/2017
|
Shell - File comandi in BOURNE-SHELL (Luc. 33): altro esempio semplice di file comandi con le variabili di ambiente PATH, HOME e direttorio corrente (file provacomandi). Ripreso concetto di variabile shell (Luc. 34): esempio di variabili shell con necessità sia di valutazione di comandi (uso di backquote ``) che del comando expr (file provaVar). Inibizione delle sostituzioni attuate dallo shell (Luc. 32): esempi vari e necessità di eval (file provaSost). Passaggio di parametri nei file comandi (Luc. 35) e altre pseudo-variabili predefinite (Luc. 36): $*, $#, $?, $$: mostrato esempio di file comandi (file provaPar) e suo funzionamento con 0 e 4 parametri, per quest'ultimo spiegato il funzionamento del comando shift. Introdotto convenzione nei nomi dei file comandi (.sh) e spiegato necessità di introdurre lo shabang (#!/bin/sh). Mostrato un esempio di file comandi (file DIR.sh) con uso della pseudo-variabile/parametro $0 e varie invocazioni. Ripreso concetto di return code dei comandi (Luc. 37). La struttura di controllo if per realizzare l'alternativa semplice (Luc. 39): primi esempi semplici (file if1.sh e if2bis.sh). Introdotto il comando test (Luc. 38): altri esempi di if (file if4.sh e if5.sh, DIRCTL.sh e DIRCTL1.sh). Spiegato la differenza di test -eq e di test =.
|
L
|
2
|
|
|
Mer. 22/03/2017
|
Shell - Altri esempi di if anche con il comando read (Luc. 36, file LeggiEMostra1.sh): uso di ridirezione per i file comandi e necessità di ridirezione su /dev/tty (Luc. 43).
La struttura di controllo case per realizzare l'alternativa multipla (Luc. 40): primo esempio di uso che consente maggiore flessibilità nella interazione con l'utente (file readCase.sh). Vari esempi di controllo sul numero di parametri con il case: esempio per il controllo stretto sul numero di parametri (file nroPar.sh), controllo lasco del primo tipo (file nroPar1,sh), controllo lasco del secondo tipo (file DIRCTL2.sh e file append.sh).
Struttura di controllo per i cicli enumerativi: for (Luc. 41); diversi esempi (file for1.sh, for1Bis.sh, for3.sh, for2.sh e crea.sh); mostrato anche esempio di uso interattivo del for (l'esempio si trova nel file for4.sh); altro esempio: file LeggiEMostra2.sh (con uso di opzione -n per il comando echo). Strutture di controllo per i cicli non enumerativi (accenno e lasciato da guardare agli studenti): while e until (Luc. 42) con un esempio ciascuno (file ce.sh e ceUtente.sh). Primo esempio di ricerca di un file in una gerarchia con due file comandi con discorso generale iniziale di come strutturare le soluzioni: due file comandi, uno iniziale e uno ricorsivo, non fatto vedere ancora nessun esempio, ma spiegato la necessità della ridirezione dato che la struttura gerarchica del file system è una struttura dati ricorsiva e spiegato la necessità del file iniziale per controlli, preparazione dell'ambiente (settaggio della variabile di ambiente PATH e suo export) e invocazione del file ricorsivo.
|
L
|
2
|
|
|
Ven. 24/03/2017
|
Esercitazione in Laboratorio (S3, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Svolgimento esercizi avanzati shell (ricerche ricorsive).
|
E
|
6
|
|
|
Lun. 27/03/2017
|
Shell - Ripreso discorso generale su soluzione dei problemi di ricerca ricorsiva in una gerarchia del File System. Illustrato il primo file comandi (Luc. 45, file Beginc.sh) e tutti i controlli con esempi di invocazioni sbagliate/corrette. Ripreso discorso sul settaggio della variabile di ambiente PATH (e suo export) e chiamata al secondo file comandi (file Cercadir.sh). Mostrato il risultato della esecuzione nella prima versione (con ricerca breath-first). Mostrato secondo file comandi, quello ricorsivo, nella versione con ricerca breath-first (Luc. 46 e file Cercadir.sh): mostrato alla lavagna passo-passo quello che succede nelle varie attivazioni ricorsive. Lasciato come esercizio di: 1) verificare cosa succede nel caso di non settare la variabile PATH (e non esportare la modifica); 2) verificare cosa succede nel caso di ricerca depth-first. Mostrato esercizio che conta tutti i file presenti in una gerarchia svolto in vari modi: mostrato in modo approfondito la versione con file temporaneo globale che raccoglie tutti i nomi assoluti dei file contati (ver1 e file contaA.sh e contaB.sh): ipotizzato anche varie possibilità una volta che si abbia traccia dei file che globalmente soddisfano una specifica. Velocemente commentato le altre versioni: versione con variabile globale e valore di ritorno (ver2 e file contaA.sh e contaB.sh), versione con variabile locale e valore di ritorno (ver3 e file contaA.sh e contaB.sh) e versione con uso di scrittura e lettura in un file temporaneo globale del valore del conteggio (ver4 e file contaA.sh e contaB.sh).
|
L
|
2
|
|
|
Mer. 29/03/2017
|
Shell - Soluzione della prova in itinere dell'anno scorso (17 Aprile 2015, nella sezione Testi Prove Scritte): spiegato alla lavagna requisiti del problema, mostrato file fasi.sh e FCR.sh e funzionamento su due gerarchie di prova. Mostrato testo dello scorso appello (quello del 15 Febbraio 2017): discusso sul fatto che in questo testo si deve svolgere tutto il problema nel file comandi ricorsivo e lasciato da guardare agli studenti la soluzione. Soluzione della prova in itinere del 13 Aprile 2012: spiegato alla lavagna requisiti del problema e mostrato due possibili soluzioni e loro funzionamento su una gerarchia di prova. Mostrato i testi di altre due prove in itinere (quella dello scorso anno e quella 11 Aprile 2014): discusso delle particolarità di questi testi e suggerito come risolverli e lasciato da guardare agli studenti le soluzioni.
|
L
|
2
|
|
|
Ven. 31/03/2017
|
Esercitazione in Laboratorio (S4, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Svolgimento esercizi avanzati shell (ricerche ricorsive). Introduzione alle librerie Bash e all'utilizzo di funzioni. [NOTA BENE: si ricorda agli studenti che l'esame per la parte in shell va svolto esclusivamente in BOURNE SHELL.]
|
E
|
6
|
|
|
Lun. 03/04/2017
|
Il linguaggio C come linguaggio di sistema (Luc. C/UNIX 1-3): caratteristiche di basso livello ed interazione con il sistema operativo UNIX. Modello di programma: introdotto area dati, area codice e area Kernel: per quest'ultima, spiegato argc, argv e envp (con parallelismo con i concetti della shell), introdotto tabella dei file aperti. Spiegato cosa sono le primitive. Presentato in generale le operazioni di sistema (PRIMITIVE) per accedere ai file (Luc. File System 9-11): creazione/cancellazione e lettura/scrittura; ottimizzazione: apertura/chiusura. Visione di basso livello dei file per UNIX/LINUX (Luc. C/UNIX 4-6) e operazioni su file: creat, open, close. Tabella dei file aperti (TFA) per ogni processo ===> file descriptor (o handle) come indice della TFA. File descriptor per standard input, output ed error. Note su close e open/creat (Luc. C/UNIX 18). Relazioni fra TFA dei singoli processi e tabelle di sistema (Luc. Unix Tabelle 1-2): Tabella dei file aperti e Tabella degli I-NODE attivi (per ora spiegato solo la necessità di quest'ultima).
|
L
|
2
|
|
|
Mer. 05/04/2017
|
File C - Spiegato uso del man anche per le primitive (in particolare sezione 2, man -s 2 <primitiva>). Rispiegato tabella dei file aperti del singolo processo e tabella dei file aperti di sistema e tabella dei file/I-Node attivi di sistema. Fatto rivedere struttura di una directory e di un I-node e spiegato metodo di allocazione dei file di UNIX (Luc. Unix Tabelle 5 e 6). File system logico (Luc. Unix Tabelle 4 e 7) e struttura del File System fisico (Luc. Unix Tabelle 3): concetto di MOUNT. Comando DF per vedere i file system fisici montati (con anche opzione -i per vedere gli i-node occupati e liberi). Primitiva SYNC. Esempi di apertura: 1) di un file con stampa del file descriptor ritornato dalla open con verifica anche di rassegnazione dello stesso fd in seguito ad una close (programma provaopen.c sul sito); 2) ripetuta dello stesso file per calcolare la dimensione della TFA di ogni processo (programma proveopen.c sul sito). Discorso generale sui metodi di accesso (Luc. File System 12-13): metodo di accesso sequenziale (concetto di file pointer) e diretto. Ripreso concetto di File pointer in C/UNIX e introdotto le operazioni di basso livello sui file in UNIX/LINUX (Luc. C/UNIX 8-10): read e write. Concetto di BUFSIZ (Luc. C/UNIX 16): fatto vedere programma che ne stampa il valore (programma provaBUFSIZ.c sul sito). Esempi di read e write: a) copia di file con parametri e controlli (file copia.c sul sito e Luc. C/UNIX 14, saltati Luc. 11-13) con spiegazione su influenza di umask che può avere effetto sui diritti specificati all'atto della creazione (file copia-new.c sul sito).
|
L
|
2
|
|
|
Ven. 07/04/2017
|
Prima prova in itinere: parte Bourne Shell (4 turni e uso dei laboratori Linfa e Infomec).
|
E
|
6
|
|
|
Mer. 19/04/2017
|
File C - Altri esempi di read e write: b) copia con ridirezione (file copiarid.c sul sito e Luc. C/UNIX 15). Implementazione di un 'clone' di cat (programma mycat.c sul sito). Implementazione della ridirezione in ingresso e in uscita (Luc. C/UNIX 19): simulazione in C della ridirezione in ingresso e in uscita (programma ridir.c sul sito) e versione con stampa degli fd usati in input e in output su /dev/tty(programma ridir-constampasudev.c sul sito). Operazione non sequenziali: lseek (Luc. C/UNIX 20). Primo esempio di append su un file (Luc. C/UNIX 22, programma append.c sul sito, esercizio del Luc. 21 saltato): implementazione della ridirezione in uscita in append (cioè >>). Altro esempio di lseek: sostituzione di tutte le occorrenze di un carattere in un file con il carattere spazio (Esercizio d'esame di Fondamenti di Informatica II del 22 Settembre 1999 sul sito). Approfondimenti su open (Luc. C/UNIX 7): esempio con vari casi (programma proveopenavanzate.c sul sito). Lasciato da guardare agli studenti la seconda versione di append su file (file append1.c sul sito).
|
L
|
2
|
|
|
Ven. 21/04/2017
|
Esercitazione in Laboratorio (C1, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Ripasso fondamenti linguaggio C. Funzioni read(), write(), open() e differenze rispetto a fread(), fwrite(), fopen(). Utilizzo di una semplice libreria. Introduzione alla compilazione con gcc e make.
|
E
|
6
|
|
|
Lun. 24/04/2017
|
NON TENUTA A CAUSA DEL PONTE DECISO DALL'AMMINISTRAZIONE CENTRALE!
|
L
|
2
|
|
|
Mer. 26/04/2017
|
File C - Spiegato significato della sincronicità e della atomicità delle operazioni primitive, in particolare read e write su file (Luc. C/UNIX 23).
Processi UNIX: modello ad ambiente locale e sue eccezioni relativamente a file system (Luc. Processi 1). Tipi di processi, scheduling, memoria virtuale, swapping e modi di esecuzione dei processi (Luc. Processi 2). Immagine di un processo: parte utente e di kernel (Luc. Processi 4-5). Tabelle di sistema: Process Table e Text Table (Luc. Processi 4 e 6-7): spiegato condivisione del codice. Stati di un processo in UNIX (Luc. Processi 9) con confronti stati di un processo in Sistemi Operativi multiprocesso generali. Ripreso schema del funzionamento della SHELL per generare un processo figlio per eseguire un comando non interno e parlato della condivisione di codice. Primitive per la gestione dei processi: creazione ===> fork e sui effetti (Luc. Processi 10-11): transizione di stato da idle a ready per il processo figlio. Condivisione I/O pointer file aperti da padre prima della fork (Luc. Processi 14-15) e condivisione in generale di un file (Luc. Processi 16-17). Primo esempio semplice: due versioni (file unodue.c), la seconda con primitive getpid, getuid e getgid (file unodueConPID-UID-GID.c sul sito) (Luc. Processi 19). Mostrato, in entrambi, i casi il problema di 'mescolamento' delle stringhe scritte su standard output a causa dell'I/O Pointer condiviso. Uso del valore di ritorno della fork (Luc. Processi 12): secondo esempio semplice (file unoEdue.c sul sito). Osservazioni su fork (Luc. Processi 13). Primitive wait/exit in generale (Luc. Processi 20-22). Lasciato da guardare agli studenti esempi di fork e wait con errore: due casi (padre senza nessun figlio e uso di una wait e padre con un figlio e uso di due wait). Esempio senza errori di uso di fork e wait, ma senza uso del valore ritornato dal figlio con la exit (transizioni di stato per processo padre da running a sleeping per effetto della primitiva wait e quindi transizione di stato da sleeping a ready al termine del processo figlio).
|
L
|
2
|
|
|
Ven. 28/04/2017
|
Esercitazione in Laboratorio (C2, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Le funzioni fork() e wait() per generare e sincronizzare processi paralleli. Utilizzo condiviso di file descriptors.
|
E
|
6
|
|
|
Mer. 03/05/2017
|
Processi UNIX - Ripreso primitiva wait ed exit (Luc. Processi 21, 22): spiegato significato del valore ritornato dalla wait come effetto collaterale sul parametro intero di cui deve essere passato l'indirizzo e spiegato le operazioni di mascheramento sui byte di tale intero e schema di invocazione della wait (Luc. Processi 23). Altro esempio di uso di wait con recupero valore di exit: con mascheramento a mano (file status2.c sul sito) e con uso di macro (file status1.c sul sito). Mostrato esempio che illustra il vincolo che il valore che può essere ritornato con la exit al padre debba essere positivo e minore o uguale a 255 (file provaValoriWait.c sul sito).
Famiglia di primitive EXEC: execv, execl, execvp e execlp; effetti exec (Luc. Processi 27-28). Esempi semplici di uso (Luc. Processi 29-30): richiesta di esecuzione di ls con due esempi corretti (file myls1.c, myls2.c sul sito) e un esempio sbagliato (file mylsErrato.c sul sito); richiesta di esecuzione di un programma eseguibile definito dall'utente (file callecho.c e myecho.c sul sito). Lasciato come esercizio esempio di attivazione dello stesso programma (ricorsione, file prova.c sul sito). Completato famiglia di primitive exec: execve e execle (Luc. Processi 31). Esempio di uso di fork ed exec (Luc. Processi 32, file mylsConFork.c sul sito) e presentato situazione dei processi padre e figlio prima e dopo l'invocazione della primtiva exec (Luc. Processi 33). Connessione con comportamento della SHELL: in particolare, implementazione ridirezione e quindi file aperti prima di exec (file myopen.c sul sito) e comportamento del SUID (un esempio, file suid.c sul sito, e un contro-esempio).
|
L
|
2
|
|
|
Gio. 04/05/2017
|
LEZIONE DI RECUPERO - Processi UNIX - Presentato in generale problema della sincronizzazione e comunicazione fra processi: in particolare, introdotto i termini di Produttore)/Consumatore, Sender/Receiver, Mittente/Destinatario e Client/Server (declinati al singolare o al plurale) per passare informazioni (dati) da un processo all'altro. Interazione fra processi in UNIX (Luc. Pipe 1). Comunicazione mediante PIPE (Luc. Pipe 2): creazione pipe e omogeneità con i file (Luc. Pipe 3-4). Lasciato come esercizio di verificare l'utilizzo della Tabella dei File aperti del singolo processo per l'interazione con le pipe (file prova.c sul sito). Calcolo della lunghezza di una pipe (Luc. Pipe 5 e file lungpipe1.c sul sito). Processi che possono comunicare tramite una pipe: necessità di relazione di parentela (Luc. Pipe 6). Esempio Produttore (figlio) e Consumatore (padre) usando una pipe (Luc. Pipe 7 e file pipe-new.c sul sito): necessità di chiusura dei lati non necessari (Luc. Pipe 8). PIPE - Problemi (Luc. Pipe 13): a) pipe senza scrittore (Luc. Pipe 12) con due esempi, uno corretto (file pipe-newSenzascrittore.c sul sito) e uno scorretto (file pipe-newSenzascrittore1.c sul sito); b) pipe senza lettore (file pipe-newSenzalettore.c sul sito).
|
L
|
2
|
|
|
Ven. 05/05/2017
|
Esercitazione in Laboratorio (C3, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Comunicazione fra processi utilizzando la system call pipe(). Costruzione di diverse topologie di comunicazione e di gerarchie di processi, attraverso la configurazione dei lati di una pipe. Introduzione ad una scrittura sintetica del makefile.
|
E
|
6
|
|
|
Lun. 08/05/2017
|
Processi UNIX - Esempio di possibile implementazione del PIPING dei comandi (Luc. Pipe 10-11): primitiva DUP (Luc. Pipe 9) (file shellpipe.c sul sito).
Esame del 5 Giugno 2015 (seconda prova in Itinere, quindi solo parte C): primo esempio di processo nipote che esegue tail -1 su file associato e figlio connesso in pipe che ricava lunghezza linea e la comunica al padre.
Letto il testo della sola parte C dell'esame del 18 Giugno 2014: analizzate dettagliatamente le specifiche e suggerito di svolgere la soluzione.
|
L
|
2
|
|
|
Mer. 10/05/2017
|
Processi UNIX - Ripreso testo della sola parte C dell'esame del 18 Giugno 2014: padre deve creare X file, uno per ogni linea degli N file; ogni figlio, per ogni linea, deve inviare al padre la lunghezza della linea e quindi la linea stessa; il padre, usando la prima informazione inviata dal figlio, deve ricevere ogni linea e quindi la deve scrivere sul file giusto. Discusso su variabili in generale, quante pipe servono e quale è il protocollo di comunicazione; quindi mostrato soluzione e funzionamento.
Sincronizzazione in UNIX mediante SEGNALI: definizione di segnale (Luc. Segnali 1) e suo trattamento (Luc. Segnali 2). Elenco (parziale) segnali (Luc. Segnali 3), anche su man -s 7 signal. Primi esempi di segnali semplici (Luc. Segnali 4): SIGINT (CTRL-C), SIGILL, SIGTERM e SIGKILL. Primitiva SIGNAL (Luc. Segnali 5): definizione di un HANDLER, default e possibilità di ignorare un segnale.
|
L
|
2
|
|
|
Ven. 12/05/2017
|
Esercitazione in Laboratorio (C4, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Esercizi di riepilogo (prove d'esame svolte).
|
E
|
6
|
|
|
Lun. 15/05/2017
|
Processi UNIX - Esempio di uso del segnale corrispondente al CTRL-C: comportamento in BSD (Luc. Segnali 8) con prova di funzionamento. Osservazione sui segnali e in particolare: a) comportamento in seguito a fork ed exec (Luc. Segnali 7); b) differenze di gestione fra versione BSD e System V (Luc. Segnali 6) e spiegato solo a parole comportamento in System V. Primitiva KILL (Luc. Segnali 10) e PAUSE (Luc. Segnali 11): esempio (Luc. Segnali 12-13). Altre primitive: ALARM (Luc. Segnali 11) (lasciato da guardare l'esempio Luc. Segnali 14-15). Ripreso esempio calcolo lunghezza pipe (Luc. Pipe 16): trattamento mediante SIGALRM. Ripreso esempio di pipe senza lettore (Luc. Pipe 14-15): trattamento segnale SIGPIPE. Esercizio di esame di Sistemi Operativi VOD e relativa soluzione della sola parte C del 10 Gennaio 2001: padre deve creare un file con nome specificato e un numero di figli pari al numero passato come parametro più 1; i figli elaborano la propria porzione di 512 caratteri e la devono scrivere sul file creato dal padre che si deve occupare della loro sincronizzazione. Mostrato versione con segnali (necessità di array di pid) e lasciato da guardare versione con pipe.
|
L
|
2
|
|
|
Mer. 17/05/2017
|
Processi UNIX - Ripreso velocemente due lucidi (Luc. Segnali 14-15) con un esempio di ALARM, dimenticati volta scorsa (lasciato da guardare nel dettaglio agli studenti). Esercizi di esame: 1) parte C dell'esame del 15 Luglio 2015: uso di pipe per sincronizzazione padre-figli e per comunicazione figli-padre, ma uso anche del segnale SIGKILL da parte del padre per uccidere tutti i figli meno uno; 2) parte C dell'esame del 13 Luglio 2016: uso di pipe per comunicazione padre-figli, nella prima fase, e per comunicazione figli-padre nella seconda fase.
|
L
|
2
|
|
|
Ven. 19/05/2017
|
Esercitazione in Laboratorio (C4, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Sincronizzazione fra processi utilizzando i segnali. System calls signal(), alarm(), sleep(), pause(), utilizzo avanzato di wait(). Ripasso puntatori a funzione.
|
E
|
6
|
|
|
Lun. 22/05/2017
|
Processi UNIX - Esame del 9 Settembre 2016, mostrata soluzione della sola parte C: padre deve creare 26 processi figli che comunicano in pipeline (dal primo figlio fino al padre) passando un array di 26 elementi dopo aver cercato, tutti nello stesso file, le lettere minuscole dell'alfabeto inglese. Esame del 19 Giugno 2013, mostrata soluzione della sola parte C: sempre comunicazione a pipeline, ma dall'ultimo figlio via via al padre passando una struct per ogni carattere numerico letto dal proprio file.
|
L
|
2
|
|
|
Mer. 24/05/2017
|
Processi UNIX - Esame del 4 Giugno 2010 (seconda prova in Itinere, quindi solo parte C): N file come parametri, padre deve creare N + 1 processi figli di cui il primo è il MASTER e gli altri sono gli SLAVE, gli SLAVE leggono il proprio file una linea per volta e la comunicano al MASTER solo se è verificata una certa condizione. Citato il testo dell'esame 20 Giugno 2012 dove oltre i normali processi figli dovevano essere creati i processi Psotto e Psopra. Esame del 9 Febbraio 2015, mostrata soluzione della sola parte C: 2N parametri, N file (Fi) intervallati da N numeri interi positivi (Xi), i processi figli generano ognuno un processo nipote che deve esequire una exec del comando head con lo scopo di mandare le prime Xi linee del file Fi al figlio, il figlio a sua volta deve mandare l'ultima linea ricevuta al padre. Citato il testo dell'esame del 9 Giugno 2014 per sottolineare che in quel caso la ridirezione dello standard input prima della exec di wc è indispensabile.
|
L
|
2
|
|
|
Ven. 26/05/2017
|
Seconda prova in itinere: parte C (2 turni e uso del solo laboratorio Linfa).
|
E
|
6
|
|
|
Lun. 29/05/2017
|
Processi UNIX - Ripreso lucido stati di un processo UNIX (Luc. Processi 9): introduzione allo stato ZOMBIE e alla sua necessità. Processi ZOMBIE (Luc. Processi 25) ed ereditati da INIT (Luc. Processi 26): due esempi relativi. Parlato anche dei processi zombie ereditati da init.
Inizializzazione del sistema UNIX e comportamento della shell (Luc. Processi 34-35).
Esempio di un programma che simula in modo molto semplice un processore dei comandi (Luc. Processi 36): uso della variabile errno e della primitiva di gestione degli errori perror (Luc. Processi 37).
Esame del 17 Luglio 2013; letto prima testo della sola parte C: padre deve inviare a tutti i figli via via i singoli caratteri letti da standard input fino all'end-of-file da tastiera e i figli devono calcolare le occorrenze di tali caratteri nel proprio file e inviare al padre tale conteggio; mostrata soluzione. Quindi, su richiesta degli studenti, letto testo della parte Shell e mostrato relativa soluzione.
|
L
|
2
|
|
|
Mer. 31/05/2017
|
Processi UNIX - Presentato limiti delle Pipe e necessità delle Named Pipe: FIFO (Luc. Pipe 17). Esempio: processo server RECFIFO e processi client SENDFIFO (Luc. Pipe 18-20).
Letto due testi di esami della sola parte C: esame del 18 Giugno 2010 ed esame del 22 Gennaio 2016 e fatto decidere agli studenti presenti quale vedere come soluzione. Scelto il secondo dei due: padre che genera N/2 processi figli, ogni figlio è associato ai primi N/2 file, ogni figlio genera un nipote, i nipoti sono associati agli altri N/2 file, ogni figlio deve cercare la prima occorrenza di un carattere maiuscolo e passarla al nipote, poi figlio e nipote cercano le occorrenze del carattere, il nipote deve mandare tale informazione al figlio che poi deve confezionare una struttura con il carattere cercato, il massimo delle occorrenze trovate, se le ha calcolate il figlio o il nipote e il pid di tale processo. Letto anche testo della parte Shell e mostrato relativa soluzione. Discusso brevemente sulla soluzione dell'altro compito l'allocazione della memoria per il nome del file che devono creare i processi nipoti e la scelta di far partire da 1 l'indice di generazione dei processi figli.
|
L
|
2
|
|
|
Lun. 05/06/2017
|
Correzione seconda prova in itinere per un primo gruppo di studenti.
|
L
|
2
|
|
|
Mer. 07/06/2017
|
Correzione seconda prova in itinere per un secondo gruppo di studenti.
|
L
|
2
|
|