|
Data
|
Argomento
|
Tipo
|
N Ore
|
Riferimento
|
|
Ven. 26/02/2016
|
Prime due ore: Spiegazione dell'orario e dell'organizzazione delle lezioni/esercitazione. Introduzione al corso: programma, modalità di esame (con date fino a Settembre) 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).
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-7).
Ultime due ore: Sistema Operativo come gestore delle risorse (Lucidi Introduzione sui SO, 8): spiegato velocemente Gestore I/0, Gestore della Memoria con riferimento alla Memoria Virtuale, Gestore della Memoria Secondaria (che verrà approfondito alla fine della lezione) e Interfaccia utente: il Processore Comandi (Lucidi Introduzione sui SO, 16-18). Spiegato con maggiore dettaglio 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 (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. 29/02/2016
|
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). 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).
Fase di autenticazione: necessità di login e logout (Luc. 2): concetto di terminale (virtuale). 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. Concetto di opzioni dei comandi, con possibilità di combinarle assieme. Ripreso comando ps: mostrato comando ps con opzione -e per fare vedere tutti i processi attivi nel sistema e quindi ps -ef. Mostrato l'invocazione della stessa shell e di diverse shell (luc. 26): accennato alla opzioni -x per la Bourne Shell.
|
L
|
2
|
|
|
Mer. 02/03/2016
|
Shell - Rifatto vedere comando ps anche con l'opzione -l (in particolare con anche -f e quindi pf -fl) che fa vedere lo stato dei processi: S (sleeping) e R (running). 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). 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 controll:atto 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).
|
L
|
2
|
|
|
Ven. 04/03/2016
|
Prime due ore: Shell - Iniziato precisando che i diritti di un file possono, chiaramente, essere cambiati solo dal proprietario del file e dal super-utente. 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. Comando per spostare i file o semplicemente rinominarli (comando mv): spiegazione in base ai comando 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.
Ultime due ore: Shell - 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). 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 ^C) 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 (opzioni -r, reverse e -f, insensibile a maiuscole/minuscole) e grep (opzione -n per vedere il numero d'ordine della linea nel file, 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 \).
|
L
|
4
|
|
|
Lun. 07/03/2016
|
Shell - Altri esempi di filtri (di nuovo Luc. 18): rev, head, tail, wc (con opzioni -c, -w, -l). Ridirezione dello standard error (Luc. 22) con esempi e uso di /dev/null.
Piping: composizione di comandi/filtro (Luc. 23, 24). Realizzazione mediante più 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). Mostrato che una modifica di una variabile di ambiente effettuata da un sotto-shell ha effetto solo in quel processo e non anche nel processo padre. Spiegato velocemente la possibilità di scrivere un file comandi (script) con un editor e quindi impostargli diritto di esecuzione.
|
L
|
2
|
|
|
Mer. 09/03/2016
|
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): $*, $#, $?, $$: mostrato esempio di file comandi (file provaPar) e suo funzionamento con 0 e 4 parametri, per quest'ultimo spiegato il funzionamento del comando shift.
|
L
|
2
|
|
|
Ven. 11/03/2016
|
Esercitazione in Laboratorio (S1, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - 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
|
5
|
|
|
Lun. 14/03/2016
|
Shell - Introdotto convenzione nei nomi dei file comandi (.sh) e spiegato necessità di introdurre lo shbang (#!/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): mostrato esempi di comandi con valore di ritorno di successo (valore zero) e insuccesso (diverso da zero).
La struttura di controllo if per realizzare l'alternativa semplice (Luc. 39): primi esempi semplici (file if1.sh e if2.sh/if2bis.sh). Introdotto il comando test (Luc. 38): altri esempi di if (file if3.sh, if4.sh e if5.sh, DIRCTL.sh e DIRCTL1.sh). Spiegato la differenza di test -eq e di test =. Altri esempi di if anche con il comando read (Luc. 36, file LeggiEMostra.sh): uso di ridirezione per i file comandi e necessità di ridirezione su /dev/tty (Luc. 43, file LeggiEMostra1.sh). 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).
|
L
|
2
|
|
|
Mer. 16/03/2016
|
Shell - Ripreso la struttura di controllo case per realizzare l'alternativa multipla: 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).
Strutture di controllo per i cicli: 1) for (Luc. 41) con 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); 2) while e until (Luc. 42) con un esempio ciascuno (file ce.sh e ceUtente.sh). Uscite anomale per i cicli: exit che termina il processo e uscite specifiche per i cicli (break e continue). Altro esempio: file LeggiEMostra2.sh (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. 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).
|
L
|
2
|
|
|
Ven. 18/03/2016
|
Esercitazione in Laboratorio (S2, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - Uso della shell. Ridirezione; comando cat; link e link simbolici; variabili d'ambiente; quoting di variabili; creazione ed uso di directory; semplici shell script.
|
E
|
5
|
|
|
Lun. 21/03/2016
|
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. Discusso sul settaggio della variabile di ambiente PATH (e suo export) e chiamata al secondo file comandi (file Cercadir.sh): mostrato il risultato nel caso di non settare la variabile PATH (e 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 (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. Completato l'analisi delle altre versioni:, versione con variabile globale e valore di ritorno (ver2 e file contaA.sh e contaB.sh), versione con 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. 23/03/2016
|
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. Soluzione della parte Shell di un testo di esame (9 Febbraio 2015): spiegato alla lavagna requisiti del problema (in particolare azioni da fare al termine dell'intera esplorazione ricorsiva), mostrato file 9Feb15.sh e FCR.sh e funzionamento su una gerarchia di prova. Soluzione della parte Shell di un testo di esame (18 Giugno 2014, nella sezione Testi Prove Scritte): spiegato alla lavagna requisiti del problema (in particolare azioni da fare nel file comandi ricorsivo), mostrato file 18Giu14.sh e FCR.sh e funzionamento su una gerarchia di prova.
|
L
|
2
|
|
|
Mer. 30/03/2016
|
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, codice e 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
|
|
|
Ven. 01/04/2016
|
Esercitazione in Laboratorio (S3, Nicola Bicocchi) - due turni (8,30-11 e 11-13,30) - 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; soluzione compiti svolti.
|
E
|
4
|
|
|
Lun. 04/04/2016
|
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 spiegato metodo di allocazione dei file di UNIX (Luc. Unix Tabelle 5 e 6). Collegato a discorso di File System Logico come mount di File System fisici: comando DF (con anche opzione –i). 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); b) copia con ridirezione (file copiarid.c sul sito e Luc. C/UNIX 15).
|
L
|
2
|
|
|
Mer. 06/04/2016
|
File C - 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). Seconda versione di append su file (file append1.c sul sito). Tabelle per l'accesso ai file (Luc. Unix Tabelle 8-10): implementazione nel Kernel di Linux.
|
L
|
2
|
|
|
Ven. 08/04/2016
|
Esercitazione in Laboratorio (S4, Nicola Bicocchi) - Preparazione alla prova in itinere. Svolgimento prove del passato.
|
E
|
4
|
|
|
Lun. 11/04/2016
|
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. Iniziato a parlare della primitiva fork, mostrando il primo esempio semplice.
|
L
|
2
|
|
|
Mer. 13/04/2016
|
Processi UNIX - Ripreso presentazione della 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): transizione di stato da idle a ready per il processo figlio. Primo esempio semplice: due versioni (la seconda con primitive getpid, getuid e getgid, 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. 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). Uso del valore di ritorno della fork (Luc. Processi 12): secondo esempio semplice. Osservazioni su fork dette solo a parole (dimenticata di mostrare Luc. Processi 13). 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). 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) e dopo introdotto esempio con uso del valore ritornato dal figlio e mascheramento a mano dei byte non importanti.
|
L
|
2
|
|
|
Ven. 15/04/2016
|
Prima prova in itinere: parte Bourne Shell (4 turni e uso dei laboratori Linfa e Infomec).
|
E
|
3
|
|
|
Mer. 20/04/2016
|
Processi UNIX - Ripreso primitiva wait (Luc. Processi 21): rispiegato operazioni di mascheramento dei valori sull'intero il cui indirizzo viene passato nella wait (Luc. Processi 23). Altro esempio di uso di wait con recupero valore di exit e uso di macro. Mostrato esempio che illustra il vincolo che il valore che può essere ritornato con la exti al padre debba essere minore o uguale a 255. 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).
|
L
|
2
|
|
|
Ven. 22/04/2016
|
Esercitazione in Laboratorio (C1, Nicola Bicocchi) - Introduzione all'uso del compilatore gcc; Hello world in c; Libreria C 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 e argv; Parsing di opzioni e argomenti; Implementazione del comando head di Unix introducendo le primitive di accesso ai file open(), read() e write().
|
E
|
4
|
|
|
Mer. 27/04/2016
|
Processi UNIX - Ripreso ultimo esempio della volta scorsa (mylsConFork) 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 (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 variabile errno e della primitiva di gestione degli errori perror (Luc. Processi 37). Presentato in generale problema della sincronizzazione e comunicazione fra processi (introdotto i termini di Produttore(i)/Consumatore(i) e Sender/Receiver) 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
|
|
|
Ven. 29/04/2016
|
Esercitazione in Laboratorio (C2, Nicola Bicocchi) - Sincronizzazione fra processi operata dalla wait(); concorrenza dei processi; condivisione di file; la funzione pipe(); i file descriptor associati ad una pipe; comportamento bloccante; casi d'uso della pipe: singola pipe fra figli e padre, una pipe per ogni figlio verso il padre.
|
E
|
4
|
|
|
Lun. 02/05/2016
|
Processi UNIX - Verifica dell'utilizzo della Tabella dei File aperti del singolo processo per l'interazione con le pipe. 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 (figlio) e Consumatore (padre) 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. 04/05/2016
|
Processi UNIX - Ripreso esempio di pipe senza scrittore e mancanza dei lati corretti nei due processi per fare vedere da un altro terminale che in effetti il processo padre rimane bloccato sulla pipe e il figlio è terminato ed è in stato zombie.
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).
Esercizio di esame di Sistemi Operativi VOD del 19 Febbraio 2001: letto testo, analizzate in dettaglio le specifiche e mostrato soluzione della sola parte C. 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
|
|
|
Ven. 06/05/2016
|
Esercitazione in Laboratorio (C3, Nicola Bicocchi) - Esercizi avanzati di comunicazione fra processi attraverso la primitiva pipe().
|
E
|
4
|
|
|
Lun. 09/05/2016
|
Processi UNIX - Ripreso testo della sola parte C dell'esame del 18 Giugno 2014: discusso su quante pipe servono e 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 possibilita' di ignorare un segnale. Esempio di uso del segnale corrispondente al CTRL-C: comportamento in BSD (Luc. Segnali 8) con prova di funzionamento.
|
L
|
2
|
|
|
Mer. 11/05/2016
|
Processi UNIX - 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) 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 lasciato da guardare versione con pipe. Suggerito di svolgere la parte C dell'esame del 15 Luglio 2015.
|
L
|
2
|
|
|
Lun. 16/05/2016
|
(POSTICIPATA)-Esercitazione in Laboratorio (C4, Nicola Bicocchi) - Esercizi avanzati di comunicazione fra processi attraverso le primitive fork(), pipe(), exec(). Svolgimento prove di esame.
|
E
|
3
|
|
|
Lun. 16/05/2016
|
Processi UNIX - Comunicato dove reperire l'elenco delle soluzioni d'esame pronte e che può essere richiesto siano svolte nelle prossime lezioni (fino al termine, 1/6/2016). Ripreso testo sola parte C dell'esame di Sistemi Operativi VOD del 10 Gennaio 2001: mostrato versione con pipe. Esercizi di esame più recenti: parte C dell'esame del 16 Luglio 2015: uso di pipe per comunicazione, ma uso anche del segnale SIGKILL da parte del padre per uccidere tutti i figli meno uno. 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 testo dell'esame del 4 Giugno 2010 (seconda prova in Itinere, quindi solo parte C).
|
L
|
2
|
|
|
Mer. 18/05/2016
|
Processi UNIX - Ripreso testo della seconda prova in itinere di Sistemi Operativi del 4 Giugno 2010 (processi figli distinti in processo MASTER, che svolge il ruolo di solito riservato al padre, e processi SLAVE): mostrato e discusso soluzione. Parte C dell'esame del 16 Luglio 2014 (primo esempio di comunicazione in pipeline dal primo figlio all'ultimo e poi al padre di un array di caratteri per ogni linea dei file associati ai figli).
|
L
|
2
|
|
|
Ven. 20/05/2016
|
Esercitazione in Laboratorio (C5, Nicola Bicocchi) - Esercizi avanzati di comunicazione fra processi attraverso le primitive fork(),
pipe(), exec(). Svolgimento prove di esame.
|
E
|
4
|
|
|
Lun. 23/05/2016
|
Processi UNIX - Ripreso testo dell'esame del 29 Giugno 2013 (un altro esempio di comunicazione in pipeline, però dall'ultimo figlio al primo e poi al padre di una serie di strutture pid-numero, una per ogni carattere dei file associati ai figli): discusso e mostrato soluzione. Parte C dell'esame del 9 Giugno 2014 (altro esempio di processo nipote che esegue wc -l su file associato e figlio connesso in pipe che ricava numero di linee e lo comunica al padre): discusso e mostrato soluzione. Esame del 20 Giugno 2012 anche parte shell oltre che parte C (N processi figli associati ognuno ad una linea del file e altri due processi figli, Psotto e Psopra che ricevono la linea letta dai figli e la scrivono ognuno su uno specifico file): discusso e mostrato soluzione sia della parte shell che della parte C.
|
L
|
2
|
|
|
Mer. 25/05/2016
|
Processi UNIX - Parte C dell'esame del 18 Giugno 2010 (un altro esempio di uso di processi nipoti che però devono gestire metà file passati come parametri scrivendo su specifici file) discusso e mostrato soluzione. Parte C dell'esame del 16 Luglio 2010 (un altro esempio di comunicazione in pipeline, di una serie di strutture pid-numero, una per ogni linea dei file associati ai figli e il padre deve dire al processo che ha trovato la linea più lunga di scriverla sullo standard output): discusso e mostrato due soluzioni, una in cui il padre manda il segnale SIGUSR1 al processo che deve stampare la linea e il segnale SIGUSR2 agli altri, e una in cui il padre per mezzo di una serie di altre N pipe manda l'indice del processo che deve stampare. Esame del 12 Febbraio 2016 anche parte shell oltre che parte C (altro esempio di pipeline dove l'informazione passata cresce fino a che al padre arriva un array di strutture): discusso, ma non fatto in tempo a mostrare la soluzione.
|
L
|
2
|
|
|
Ven. 27/05/2016
|
Esercitazione in Laboratorio (C6, Nicola Bicocchi) - Esercizi avanzati di comunicazione fra processi attraverso le primitive fork(), pipe(), exec(). Svolgimento prove di esame.
|
E
|
4
|
|
|
Lun. 30/05/2016
|
Processi UNIX - Ripreso testo della Parte C dell'esame del 12 Febbraio 2016 anche parte shell oltre che parte C (altro esempio di pipeline dove l'informazione passata cresce fino a che al padre arriva un array di strutture): discusso di nuovo e mostrata la soluzione. Letto i testi (parte shell e parte C) degli esami del 22 Gennaio 2016 e del 9 Febbraio 2015 e fatto scegliere agli studenti quale soluzione mostrare: scelto quello del 9 Febbraio 2015. Sia parte shell che parte C (ulteriore esempio di processo nipote che esegue head -Xi su file associato e figlio connesso in pipe che ricava l'ultima linea inviata dal nipote e la comunica al padre): discusso e mostrato soluzione.
|
L
|
2
|
|
|
Mer. 01/06/2016
|
NON TENUTA DATO CHE ARRIVATA GIA' A 56 ORE (DELLE 54 DA FARE)!
|
L
|
2
|
|