|
Data
|
Argomento
|
Tipo
|
N Ore
|
Riferimento
|
|
Ven. 27/02/2015
|
Prime due ore: Introduzione al corso: programma, modalità di esame e testi consigliati (Lucidi Programma); necessità di registrazione per gestione liste prove in itinere ed esami. Illustrazione del sito: oltre l'applicazione per gli esami, il registro on-line delle lezioni e la sezione dei Lucidi (comunicazione della password di lettura). Registrazione nell'applicazione che servirà per l'iscrizione agli esami.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 Real-Time (processi con priorità) e dei Sistemi Operativi Time-sharing (scheduling a quanti di tempo). Sistema Operativo come gestore delle risorse: possibile individuazione di diversi livelli del Sistema Operativo o macchine virtuali. (Lucidi Introduzione sui SO, 1-10)
Ultime due ore: Sistema Operativo come gestore delle risorse: in particolare: primo livello di un sistema Operativo: Nucleo/Kernel. Ripreso concetto di processo: 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. Accennato a gestore I/0. Gestore della Memoria con riferimento alla Memoria Virtuale. Interfaccia utente: il Processore Comandi. Punti di vista: utente e quindi esterno o del Sistema Operativo e quindi interno. (Lucidi Introduzione sui SO, 11-18) File System - Organizzazione logica: file, necessità descrittore di file e direttori. Strutturazione dei direttori: direttori ad albero (nome assoluto, relativo al direttorio corrente e relativo semplice) e a grafo (concetto di Link). (Lucidi File System, 1-7)
|
L
|
4
|
|
|
Lun. 02/03/2015
|
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 sistem) C; Unix come sistema operativo multigrammato (e multiprocesso) e multiutente (Luc. 1); necessità di login e logout (Luc. 2). 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). 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 eseguito diverso da una shell (Luc. 3 e 4). Mostrato risultato del comando pwd all'accesso (home directory) e poi comando cd per cambiare directory. 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 anche con opzione -f (full) per sottolineare il concetto di processo padre e processo figlio e il comando id per UID e GID. Mostrato l'invocazione della stessa shell (con condivisione di codice) e di diverse shell (luc. 26): accennato alle opzioni -x e -v per la Bourne Shell.
|
L
|
2
|
|
|
Mer. 04/03/2015
|
Shell -Concetto di opzioni dei comandi, con possibilità di combinarle assieme. Ripreso comando ps: mostrato opzioni ps con opzione -l (long) e mostrato anche opzioni -a (all) o l'equivalente -e per fare vedere tutti i processi attivi nel sistema. Collegamento anche con un secondo account (sonod) e mostrato di nuovo comando id e comando who (anche versione w). Concetto di terminale (virtuale). Mostrato il comando man.
Nomi di file assoluti, relativi al direttorio corrente e relativi semplici (Luc. 6): mostrato simulazione della gerarchia del lucido (comando ls -R). Nomi che iniziano con il carattere punto, molto lunghi e con più caratteri punto. Spiegato \".\" e \"..\" e il suo effetto sull'albero che diventa un grafo e mostrato esempi di uso: in particolare, ls -a, ls -A, cd .. o cd ../.. (sempre Luc. 6). Approfondimento su ls: varie opzioni (Luc. 16). Metacaratteri principali trattati dalla shell (* e ?) (sempre Luc. 6): mostrato con opzione -x della shell (usando jsh che implementa la Bourne shell) il funzionamento di * e ?. Protezione dei file (Luc. 8): diritti di accesso (r, w e x) per user, group e other. Concetto di superutente (root) e spiegato come avvengono i controlli (concetto di UID/GID reali e UID/GID effettivi). Fatto vedere accesso allo stesso file da parte di due utenti diversi, ma appartenenti allo stesso gruppo. Il comando chmod, versione simbolica ed ottale: effetto diverso sull'accesso ad un file. Significato dei diritti di accesso per i direttori. Comandi chown e chgrp solo per il SUPERUTENTE (Luc. 15).
|
L
|
2
|
|
|
Ven. 06/03/2015
|
Prime due ore: Shell - Concetto di link (hardware) per i file (comando ln, Luc. 10) e differenze con il comando cp per copiare file; cancellazione file (comando rm). 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. Comando rm (importanza della opzione -i, interactive): cancellazione di un link e se numero di link uguale a zero anche del contenuto del file. Comando mv: spiegazione sulla base dei comandi ln e rm. 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. Concetto di link software per file e direttori: comando ln -s. 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 (concetto di PATH e valore della corrispondente variabile d'ambiente). Il comando which per cercare dove è un comando. 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).
Ultime due ore: 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). Primi esempi di ridirezione in uscita e in append usando il comando pwd e ls. 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 ^D) sia come alternativa al comando cp. Ridirezione in uscita per creare file vuoto (ridirezione a vuoto). Altri esempi di filtri (di nuovo Luc. 18): more, sort, grep, rev, head, tail, wc (con opzioni -c, -w, -l). Ridirezione nulla. Ridirezione dello standard error (Luc. 22) con esempi e uso di /dev/null.
Nell'ultima mezz'ora, presentazione del meccanismo per creare un direttorio sul desktop il cui contenuto che viene automaticamente salvato sul server LICA (lica02.lab.unimo.it) e che deve essere usato durante gli esami.
|
L
|
4
|
|
|
Lun. 09/03/2015
|
Shell - Ripreso concetto di ridirezione perché dimenticata di mostrare esempio di programma in C che si comporta come filtro facendo uso dei concetti di standard input e standard output e quindi leggendo con scanf e scrivendo con printf un carattere alla volta. Ripreso comando sort e mostrato funzionamento avendo settato la variabile di ambiente LC_ALL=C: ordinamento secondo la codifica ASCI; opzioni -f per ordinamento ignorando maiuscole/minuscole e -r per ordinamento inverso. Ripreso comando grep con uso, ad esempio, di pattern '^a' per cercare tutte le linee che iniziano con il carattere 'a', di pattern 'a$' per cercare tutte le linee che terminano con il carattere 'a' e di pattern '\.$' per cercare tutte le linee che terminano con il carattere '.'.
Piping: composizione di comandi/filtro (Luc. 23, 24). Realizzazione mediante piu\' processi e canali di comunicazione. Esempi che mostrano la presenza di un processo per ogni comando in piping: uso anche del filtro tee. 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, diff e find (Luc. 17). 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 (esempio relativo). Spiegato velocemente la possibilità di scrivere un file comandi (script) con un editor e quindi impostargli diritto di esecuzione.
|
L
|
2
|
|
|
Mer. 11/03/2015
|
Shell - Sostituzioni attuate dallo shell (Luc. 29). Mostrati gli ulteriori metacaratteri [ ] (Luc. 30) con vari esempi (Luc. 31). File comandi in BOURNE-SHELL (Luc. 33): primo esempio 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): $*, $#, $?, $$.
|
L
|
2
|
|
|
Ven. 13/03/2015
|
Esercitazione in Laboratorio (S1, Nicola Bicocchi) - Guida all'installazione ambiente di lavoro. In particolare, Ubuntu 14.04 64bit su Oracle 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.
Cenno all'Open Source, licenza d'uso GPL e Free Software Foundation, progetto GNU.
|
E
|
4
|
|
|
Lun. 16/03/2015
|
Shell - Spiegato comando shift (Luc. 35) e ripreso le altre pseudo-variabili: $$ e soprattutto $? (concetto di return code dei comandi, Luc. 37): mostrato esempi di valore di ritorno di successo (valore zero) ed insuccesso (diverso da zero) e mostrato esempi di file comandi (file provaPar e file DIR). La struttura di controllo if per realizzare l'alternativa semplice (Luc. 39): primi esempi semplici (file if1 e if2). Introdotto il comando test (Luc. 38): altri esempi di if (file if3, DIRCTL e DIRCTL1). Altri esempi di if anche con il comando read (Luc. 36, file LeggiEMostra): uso di ridirezione per i file comandi e necessità di ridirezione su /dev/tty (Luc. 43, file LeggiEMostra1). La struttura di controllo case per realizzare l'alternativa multipla (Luc. 40): primo esempio di uso che esegue controllo sul numero dei parametri (file nroPar) e quindi altri esempi di uso (file readCase e append).
|
L
|
2
|
|
|
Mer. 18/03/2015
|
Lezioni sospese: LEZIONE NON TENUTA A CAUSA DI MOREJOBS (ex Ingegneri@MO)!
|
L
|
2
|
|
|
Ven. 20/03/2015
|
Esercitazione in Laboratorio (S2, Nicola Bicocchi) - Uso della shell. Ridirezione; comandi cat e grep; link e link simbolici; variabili d'ambiente; quoting di variabili; creazione ed uso di directory.
|
E
|
4
|
|
|
Lun. 23/03/2015
|
Shell - Strutture di controllo per i cicli: 1) for (Luc. 41) con diversi esempi (file for1, for1Bis, for2, for3, for4 e crea); 2) while e until (Luc. 42) con un esempio ciascuno (file ce e ceUtente). Uscite anomale per i cicli: exit che termina il processo e specifiche per i cicli break e continue. Altri due esempi: file mostra e file lista (con uso di opzione -n per il comando echo). Ripreso concetto di creazione di un processo di sotto-shell e copia dell'ambiente di shell da padre a figlio (Luc. 46). Ripreso comando export (Luc. 46) per inserimento delle variabili di shell nell'ambiente: con esempio mediante lo shell jsh. Eccezione di non creazione sotto-shell per i comandi interni o built-in: elenco parziale (Luc. 47) 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 con vari controlli sui parametri e uno ricorsivo (ma non spiegato ancora cosa vuol dire). Illustrato il primo file comandi (Luc. 45, file Beginc.sh) e tutti i controlli con esempi di invocazioni sbagliate/corrette.
|
L
|
2
|
|
|
Mer. 25/03/2015
|
Shell - Settaggio della variabile PATH e chiamata al secondo file comandi (file Cercadir.sh): mostrato il risultato nel caso di non settare la variabile PATH (e quindi non esportare la modifica). 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. Mostrato anche risultato della seconda versione (con ricerca deep-first). Mostrato esercizio che conta tutti i file presenti in una gerarchia svolto in vari modi: mostrato per prima la versione con file temporaneo globale che raccoglie tutti i nomi assoluti dei file contati (ver2 e file contaA.sh e contaB.sh): ipotizzato anche varie possibilità una volta che si abbia traccia dei file che globalmente soddisfano una specifica. Completato l'analisi delle altre versioni:, versione con variabile globale e valore di ritorno (ver1 e file contaA.sh e contaB.sh), versione con versione con variabile locale e valore di ritorno (ver4 e file contaA.sh e contaB.sh) e versione con uso di scrittura e lettura in un file temporaneo globale del valore del conteggio (ver3 e file contaA.sh e contaB.sh). Soluzione della parte Shell di un testo di esame (9 Febbraio 2015) con lettura attenta del testo e considerazioni sulla soluzione durante la lettura.
|
L
|
2
|
|
|
Ven. 27/03/2015
|
Esercitazione in Laboratorio (S3, Nicola Bicocchi) - Ricerca ricorsiva; controllo degli argomenti: nome assoluto, relativo, semplice, argomento numerico, controllo argomento con singolo carattere; conteggio ricorsivo di file; determinazione della massima profondità di una gerarchia.
|
E
|
4
|
|
|
Lun. 30/03/2015
|
Shell - Soluzione della parte Shell di un testo di esame (18 Giugno 2014, nella sezione Testi Prove Scritte) con correzione di due imprecisioni (controllo X non nullo nel file comandi iniziale e definizione esplicita variabile nel file comandi ricorsivo). Soluzione della prova in itinere dell'anno scorso (11 Aprile 2014, nella sezione Testi Prove Scritte). Soluzione della prova in itinere di tre anni fa (13 Aprile 2012, nella sezione Testi Prove Scritte) e quindi soluzione su due file comandi: prima versione con uso di file temporaneo usato come variabile globale (ver1 e file fasi1e2.sh e FRC.sh) e velocemente la seconda versione con uso di variabile locale e valore di ritorno con exit (ver2 e file fasi1e2.sh e FRC.sh).
|
L
|
2
|
|
|
Mer. 01/04/2015
|
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 e primitive. 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): Tabella dei file aperti (TFA) per ogni processo ===> file descriptor (o handle) come indice della TFA. Operazioni su file: creat, open, close. 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.
|
L
|
2
|
|
|
Mer. 08/04/2015
|
File C - Spiegato uso del man anche per le primitive (in particolare sezione 2, man -s 2 <primitiva>). 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). Struttura del File System fisico (Luc. Unix Tabelle 3):. File system logico (Luc. Unix Tabelle 4 e 7): concetto di MOUNT e primitiva SYNC. Fatto rivedere struttura di I-node e speigato metodo di allocazione dei file di UNIX (Luc. Unix Tabelle 5 e 6). Discorso generale sui metodi di accesso (Luc. File System 12-13): sequenziale (concetto di file pointer) e diretto; concetto di End-Of-File. Ripreso concetto di File pointer in C/UNIX e altre operazioni sui file in UNIX/LINUX (Luc. C/UNIX 8-10): read e write. Concetto di BUFSIZ (Luc. C/UNIX 16): lasciato come esercizio da stamparne stampa il valore. Esempi: a) copia di file (con parametri e controlli, 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); b) copia con ridirezione (Luc. C/UNIX 15).
|
L
|
2
|
|
|
Ven. 10/04/2015
|
Esercitazione in Laboratorio (S4, Nicola Bicocchi) - Preparazione alla prova in itinere. Svolgimento prove del passato.
|
E
|
4
|
|
|
Lun. 13/04/2015
|
File C - Collegato a discorso di File System Logico come mount di File System fisici: comando DF (con anche opzione –i). Implementazione della ridirezione in ingresso e in uscita (Luc. C/UNIX 19): Simulazione in C della ridirezione in ingresso e in uscita con stampe su standard error (programma ridir-conperror.c sul sito). Implementazione di un 'clone' di cat (programma mycat.c sul sito). Tabelle per l'accesso ai file (Luc. Unix Tabelle 8-10): implementazione nel Kernel di Linux. Operazione non sequenziali: lseek (Luc. C/UNIX 20). Primo esempio di append su un file (Luc. C/UNIX 22, esercizio del Luc. 21 saltato) e altro esempio di lseek (modifica di tutte le occorrenze di un carattere in un file-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. Seconda versione di append su file (file append1.c sul sito).
|
L
|
2
|
|
|
Mer. 15/04/2015
|
File C - Primitive LINK e UNLINK (Luc. C/UNIX 24): esempio di versione semplificata del comando MV. Primitive ACCESS (con precisazione che il controllo viene fatto rispetto all'UID reale, Lucido C/UNIX 17), STAT e FSTAT (Luc. C/UNIX 25-27): esempi relativi. 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 anche in Linux (Luc. Processi 2-3). 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 dato che il codice non si modifica (codice puro cioè rientrante). Descrittore di processo in LINUX (Luc. Processi 8). Stati di un processo in UNIX (Luc. Processi 9) con confronti stati di un processo in generale.
|
L
|
2
|
|
|
Ven. 17/04/2015
|
Prima prova in itinere: parte Bourne Shell (4 turni e uso dei laboratori Linfa e Infomec).
|
E
|
4
|
|
|
Mer. 22/04/2015
|
Processi UNIX - Ripetuto brevemente quanto detto nell'ultima lezione, prima dell'interruzione. Iniziato a presentare la primitiva fork() alla lavagna, in particolare usata dalla 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). Primo esempio semplice: due versioni (la seconda con primitive getpid, getuid e getgid, Luc. Processi 19). Uso del valore di ritorno della fork (Luc. Processi 12): secondo esempio semplice. Osservazioni su fork (Luc. Processi 13) in particolare relativamente ad ambiente locale. 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). Primitive wait/exit in generale (Luc. Processi 20-22). Primi 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).
|
L
|
2
|
|
|
Ven. 24/04/2015
|
Esercitazione in Laboratorio (C1, Nicola Bicocchi) - Uso del compilatore gcc; libC e file header; uso di man per le funzioni della libC; la funzione main; prototipi di funzioni; ripasso sulla sintassi del C; tipi di variabili; Stampa formattata con printf (interi, caratteri e stringhe); gli argomenti della linea di comando e gli argomenti della funzione main (argc, argv); parsing di opzioni e argomenti; primitive di accesso ai file open(), read() e write().
|
E
|
4
|
|
|
Lun. 27/04/2015
|
Processi UNIX - Ripreso primitiva wait: esempio di uso senza recupero del valore di exit e esempio in due versioni di recupero valore di exit (prima, Luc. Processi 23, con operatori bit-a-bit e seconda, fatta vedere velocemente, con uso di macro). Processi ZOMBIE (Luc. Processi 25) ed ereditati da INIT (Luc. Processi 26): due esempi relativi. Parlato anche dei processi zombie ereditati da init.
Famiglia di primitive EXEC: execv, execl, execvp e execlp; effetti exec (Luc. Processi 27-28). Esempi semplici di uso (Luc. Processi 29-30). Completato famiglia di primitive exec: execve e execle (Luc. Processi 31).
Esempio di uso di fork ed exec (Luc. Processi 32-33): considerazione su ottimizzazione della primitiva fork in Linux
con copy-on-write.
|
L
|
2
|
|
|
Mer. 29/04/2015
|
Processi UNIX - Connessione con comportamento della SHELL: in particolare, implementazione ridirezione e quindi file aperti prima di exec (due esempi, il secondo anche con ridirezioni avanzate) e comportamento del SUID (un esempio). 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 primitiva di gestione degli errori perror (Luc. Processi 37). Presentato problema Produttore(i)/Consumatore(i) 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).
|
L
|
2
|
|
|
Lun. 04/05/2015
|
Processi UNIX - Calcolo della lunghezza di una pipe (Luc. Pipe 5). Processi che possono comunicare tramite una pipe: necessità di relazione di parentela (Luc. Pipe 6). Esempio Produttore (padre) e Consumatore (figlio) usando una pipe (Luc. Pipe 7): necessità di chiusura dei lati non necessari (Luc. Pipe 8). PIPE - Problemi: pipe senza scrittore (Luc. Pipe 12) e pipe senza lettore (Luc. Pipe 13). Esempio di possibile implementazione del PIPING dei comandi (Luc. Pipe 10-11): primitiva DUP (Luc. Pipe 9).
|
L
|
2
|
|
|
Mer. 06/05/2015
|
Processi UNIX - Esercizio di esame di Sistemi Operativi VOD e relativa soluzione della sola parte C: 19 Febbraio 2001. Presentato limiti delle Pipe e necessita\' delle Named Pipe: FIFO (Luc. Pipe 17). Esempio: processo server RECFIFO e processi client SENDFIFO (Luc. Pipe 18-20). Suggerito di svolgere la soluzione dei seguenti esercizi di esame: 11 Marzo 2008, 19 Dicembre 2001 e 2 Aprile 2004.
|
L
|
2
|
|
|
Ven. 08/05/2015
|
Esercitazione in Laboratorio (C2, Nicola Bicocchi) - Funzioni per l'accesso ai file read(), write(), open(). Cenni di programmazione concorrente, fork(), e problematiche legate a file descriptor condivisi.
|
E
|
4
|
|
|
Lun. 11/05/2015
|
Processi e loro comunicazione in UNIX - Esercizi di esame di Sistemi Operativi della sola parte C: Soluzione dell'esame dell'11 Marzo 2008 con uso di exec di grep. Esame del 19 Dicembre 2001: presentato il testo e illustrato in generale le due versioni, quella con 1 pipe (spiegando in dettaglio la struttura dati) e quella con N pipe mostrata velocemente. Soluzione dell'esercizio dell'esame del 2 Aprile 2004 con uso di pipe che collegano figli e padre in una catena di processi.
|
L
|
2
|
|
|
Mer. 13/05/2015
|
Processi UNIX - 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 file .h nel server Linux. 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 possibilita\' di ignorare un segnale. Differenze di gestione fra versione BSD e System V (Luc. Segnali 6). Comportamento in seguito a fork ed exec (Luc. Segnali 7). Esempio di uso del segnale corrispondente al CTRL-C: comportamento in BSD (Luc. Segnali 8) con prova di funzionamento.
|
L
|
2
|
|
|
Ven. 15/05/2015
|
Esercitazione in Laboratorio (C3, Nicola Bicocchi) - Concorrenza dei processi; condivisione di file; le funzioni wait() e pipe(); i file descriptor associati ad una pipe; comportamento bloccante; casi d'uso della funzione pipe().
|
E
|
4
|
|
|
Lun. 18/05/2015
|
Processi UNIX - Spiegato solo a parole comportamento in System V (Luc. Segnali 9) per l'esempio della volta scorsa. Primitiva KILL (Luc. Segnali 10) e PAUSE (Luc. Segnali 11): esempio (Luc. Segnali 12-13). Altre primitive: ALARM (Luc. Segnali 11) con relativo 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: versione con segnali (necessità di array di pid) e versione con pipe.
|
L
|
2
|
|
|
Mer. 20/05/2015
|
Processi e loro comunicazione in UNIX - Esercizi di esame di Sistemi Operativi della sola parte C: Soluzione dell’esame del 5 Giugno 2013, Soluzione dell’esame del 9 Giugno 2014 e Soluzione della Seconda Prova in Itinere del 4 Giugno 2010.
|
L
|
2
|
|
|
Ven. 22/05/2015
|
Esercitazione in Laboratorio (C4, Nicola Bicocchi) - Esercizi avanzati di comunicazione fra processi attraverso la primitiva pipe().
|
E
|
4
|
|
|
Lun. 25/05/2015
|
Processi e loro comunicazione in UNIX - Esercizi di esame di Sistemi Operativi della sola parte C: Soluzioni dell'esame del 16 Luglio 2010 (due soluzioni: una con uso di segnali e una con solo uso di pipe) e soluzione dell'esame del 19 Giugno 2010.
|
L
|
2
|
|
|
Mer. 27/05/2015
|
Processi e loro comunicazione in UNIX - Esercizi di esame di Sistemi Operativi completi: Soluzione dell'esame del 20 Giugno 2012 e soluzione dell'esame del 19 Giugno 2013.
|
L
|
2
|
|
|
Ven. 29/05/2015
|
Esercitazione in Laboratorio (C5, Nicola Bicocchi) - Preparazione alla prova in itinere. Compiti svolti.
|
E
|
4
|
|
|
Lun. 01/06/2015
|
NON TENUTA PER PONTE DECISO DALL'AMMINISTRAZIONE CENTRALE!
|
L
|
2
|
|
|
Mer. 03/06/2015
|
Esercitazione in Aula (C6, Nicola Bicocchi) - Ripasso su segnali e pipe in vista della seconda prova in itinere di Venerdì.
|
L
|
2
|
|
|
Ven. 05/06/2015
|
Seconda prova in itinere: parte in C: due turni.
|
E
|
4
|
|