|
Data
|
Argomento
|
Tipo
|
N Ore
|
Riferimento
|
|
Lun. 25/02/2019
|
Spiegazione dell'orario e dell'organizzazione delle lezioni/esercitazioni. Illustrazione del sito: oltre all'applicazione per gli esami, il registro on-line delle lezioni e la sezione delle slide (comunicazione della password di lettura). Introduzione al corso: programma, modalità di esame (con date fino a Settembre 2019) e testi consigliati (Slide Programma); necessità di registrazione per gestione liste prove in itinere ed 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 Time-sharing (scheduling a quanti di tempo). Sistema Operativo come gestore delle risorse; punti di vista esterno ed interno nello studio di un S.O. (Lucidi Introduzione sui SO, 1-7).
|
L
|
2
|
|
|
Mer. 27/02/2019
|
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). 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, 10-12). Introdotto i due tipi di interazione fra processi in ambito di programmazione concorrente: interazione indiretta o competizione e interazione diretta o cooperazione (Lucidi Introduzione sui SO, 13). Problema del deadlock (Lucidi Introduzione sui SO, 14-15).
Gestore dei dispositivi di I/O: in particolare, gestione degli interrupt (Lucidi Introduzione sui SO, 16).
Gestore della memoria centrale: in particolare gestione della allocazione con tecnica della paginazione (TDP, traduzione indirizzi logici in fisici e cache delle pagine) (Lucidi Introduzione sui SO, 16-18).
|
L
|
2
|
|
|
Ven. 01/03/2019
|
Prima ora: Gestore della memoria centrale: Memoria virtuale, in particolare gestione basata su segmentazione paginata (Lucidi Introduzione sui SO, 16-19). Saltato per ora Gestione della memoria secondaria velocemente (Lucidi Introduzione sui SO, 20).
Gestione interfaccia utente: interfacce grafiche e testuali (Lucidi Introduzione sui SO, 21).
File System - Definizione di file, funzioni tipiche del gestore, tipi di file. Punto di vista dell'utente con illustrazione veloce dei principali comandi. Concetto di descrittore di file e di directory (derivazione da telephone directory). Strutturazione delle directory: Directory ad albero (nome assoluto, relativo alla directory corrente e relativo semplice) e a grafo (concetto di Link) (Lucidi File System, 1-7).
Ultime tre ore: 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. 3). Struttura del File System di UNIX: direttori tipici (Luc. 4). 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. 5 e 6).
Comando id per vedere UID e GID. Comando pwd per visualizzare directory corrente (all'inizio è la HOME directory: comando echo $HOME). Processore comandi come processo e generatore di processi: in genere, un processo associato all'esecuzione di ogni comando (eccezioni: comando exit e cd) (Luc. 7); 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 (manual): mostrato il comando man ps. Ripreso comando ps: mostrato ps -l (long) 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. 8).
Accennato alla opzione -x per le shell. Dimostrazione della multi-utenza: collegamento anche con un secondo account (sonod) e mostrato di nuovo comando id e comando who (anche versione w).
Ripreso organizzazione del File System e nomi di file assoluti, relativi al direttorio corrente e relativi semplici (Luc. 9). Nomi di file 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. 9). Mostrato simulazione della gerarchia del lucido 9 (comando ls -R, cioè ricorsione). Approfondimento su ls: varie opzioni (Luc. 10); esempi di ls -F e ls -r.
|
L
|
4
|
|
|
Lun. 04/03/2019
|
Shell - Ripreso approfondimento su ls: ls -t e ls -l e spiegato nel dettaglio importanza di ls -d (sempre Luc. 10).
Metacaratteri principali trattati dalla shell (* e ?) (sempre Luc. 9): spiegato concetto di pattern matching ed esempi di uso; mostrato effetto dell'uso di * e ? utilizzando sh -x.
Protezione dei file (Luc. 11): 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. 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. 12).
Concetto di link (hardware) per i file (comando ln, Luc. 13): comando ln. Spiegato come si realizza in UNIX il concetto di link: struttura direttori (Luc. 14) con i-number e i-node: mostrato uso di opzione -i di ls. Differenze con il comando cp per copiare file.
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.
Comando per spostare i file o semplicemente rinominarli (comando mv): spiegazione in base ai 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.
|
L
|
2
|
|
|
Mer. 06/03/2019
|
Shell - 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 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 creare link in gerarchie residenti su dispositivi fisici diversi.
Ripreso sintassi generale comandi (Luc. 16): 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. 17) per i file eseguibili (SUID e SGID): 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). Esempio di uso di SUID con programma che visualizza un file leggibile solo dal proprietario con accesso di un utente che non è il proprietario.
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). 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, e sia come alternativa al comando cp. Altri esempi di filtri (di nuovo Luc. 18): comando/filtro more.
Ridirezione dello standard error (Luc. 21) con esempi: in particolare uso di /dev/null. (per ora lucido 22 saltato)
|
L
|
2
|
|
|
Ven. 08/03/2019
|
Esercitazione in Laboratorio (S1) -
|
E
|
3
|
|
|
Lun. 11/03/2019
|
Shell - Spiegato che per questioni legate ad anticipare argomenti che verranno affrontati nella prossima esercitazione in laboratorio, per ora lasciamo indietro alcune cose e passiamo ad introdurre la programmazione in shell (Luc. 28): in particolare, introdotto convenzione nei nomi dei file comandi (.sh) e spiegato necessità di introdurre lo shabang (#!/bin/sh). Spiegato concetto di variabile di shell (Luc. 29): valore come stringa, sintassi assegnamento e sintassi per riferire il valore. Concetto di ambiente di shell (Luc. 30): 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. 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. 32 e 33). Mostrati gli ulteriori metacaratteri [ ] (ancora Luc. 33) con vari esempi (Luc. 34).
Ripreso concetto di variabile (Luc. 35): altro esempio semplice di file comandi con le variabili di ambiente PATH, HOME e direttorio corrente. Esempio di variabili shell con necessità sia di valutazione di comandi (uso di backquote ``) che del comando expr. Inibizione delle sostituzioni attuate dallo shell (Luc. 36): esempi vari e necessità di eval.
|
L
|
2
|
|
|
Mer. 13/03/2019
|
Shell - Passaggio di parametri nei file comandi (Luc. 37): $1, $2, $3, etc; spiegato significato di $0; spiegato comandi shift. Introdotto quindi altre pseudo-variabili predefinite (Luc. 37): $*, $#, $?, $$: mostrato esempio di file comandi (file provaPar) e suo funzionamento con 4 parametri e spiegato il funzionamento del comando shift. 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. 38). La struttura di controllo if per realizzare l'alternativa semplice (Luc. 39): primi esempi semplici (file if1.sh e if2.sh). Introdotto il comando test (Luc. 40): altri esempi di if (file if4.sh e if5.sh, DIRCTL.sh e DIRCTL1.sh). Lasciato da guardare agli studenti la differenza di test -eq e di test =. Altri esempi di if anche con il comando read (Luc. 41, file LeggiEMostra.sh): uso di ridirezione per i file comandi e necessità di ridirezione su /dev/tty.
La struttura di controllo case per realizzare l'alternativa multipla (Luc. 42): 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).
|
L
|
2
|
|
|
Ven. 15/03/2019
|
Esercitazione in Laboratorio (S2) -
|
E
|
3
|
|
|
Lun. 18/03/2019
|
Shell - Ripreso vari esempi di controllo sul numero di parametri con il case: esempi per il controllo lasco del primo tipo (file nroPar1,sh) e per il controllo lasco del secondo tipo (file append.sh).
Struttura di controllo per i cicli enumerativi: for (Luc. 43); diversi esempi (file for1.sh, for1-conConteggio.sh, for1Bis.sh, for2.sh, crea.sh e for4bis.sh); Strutture di controllo per i cicli non enumerativi (accenno e lasciato da guardare agli studenti): while e until (Luc. 44) 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 ricorsione 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. Illustrato il primo file comandi (Luc. 45 e 46, file Beginc.sh).
|
L
|
2
|
|
|
Mer. 20/03/2019
|
Shell - Ripreso esempio della lezione scorsa (Luc. 45, file Beginc.sh), discorso di settaggio variabile PATH ed esempi di invocazioni sbagliate/corrette. Spiegato rapidamente sintassi che consente il piping di comandi per usarla per paginare (| more) e cercare una particolare stringa (| grep stringa) nell'output prodotto dal file comandi. Mostrato secondo file comandi, quello ricorsivo, nella versione con ricerca breath-first (Luc. 46, file Cercafile.sh): mostrato alla lavagna passo-passo quello che succede nelle varie attivazioni ricorsive su una semplice gerarchia. 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.
Precisazione sul more usato come comando. Ripreso discorso sui comandi-filtro (di nuovo Luc. 18) con altri esempi di comandi-filtro: 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.
|
L
|
2
|
|
|
Ven. 22/03/2019
|
Esercitazione in Laboratorio (S3) -
|
E
|
3
|
|
|
Lun. 25/03/2019
|
Shell - Illustrato che all'esame si può anche usare la bash, ma che bisogna seguire le avvertenze riportate in un documento caricato sul sito. Indicato quali esercizi verranno mostrati la volta prossima.
Esercizio che conta tutti i file (NON Directory) presenti in una gerarchia svolto in vari modi: mostrato in modo approfondito la versione (ver1) con file temporaneo globale che raccoglie tutti i nomi assoluti dei file contati e stampa il loro nome assoluto e il contenuto nel file comandi principale. Lasciato come esercizio di guardare le altre versioni: versione con variabile globale e valore di ritorno (ver2), versione con variabile locale e valore di ritorno (ver3) e versione con uso di scrittura e lettura in un file temporaneo globale del valore del conteggio (ver4).
Ripreso Luc. 18 per completare i comandi filtri: wc (con opzioni -c, -w, -l e differenze fra filtro e comando), head e tail.
Ripreso Piping: composizione di comandi/filtro (Luc. 23, 24). Realizzazione mediante più processi e canali di comunicazione. Esempi con uso anche del filtro tee ed esempio che mostra la presenza di un processo per ogni comando in piping.
Esecuzione di comandi in background (Luc. 25, 26): problema di ridirezione standard output e standard error (consigliata) e dello standard input (necessaria almeno in Bourne shell!). Uso del comando kill. Altri comandi lasciati da guardare agli studenti: date, diff e find (Luc. 27).
Ripreso velocemente discorso sui comandi interni o built-in (Luc. 47).
|
L
|
2
|
|
|
Mer. 27/03/2019
|
Shell - Soluzione della prova in itinere di tre anni fa (15 Aprile 2016, 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 prova in itinere di quattro anni fa (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 prova in itinere dell'11 Aprile 2014 (necessità di più file temporanei): spiegato alla lavagna requisiti del problema, mostrato file fasi.sh e FCR.sh e funzionamento su due gerarchie di prova.
|
L
|
2
|
|
|
Ven. 29/03/2019
|
Esercitazione in Laboratorio (S4) -
|
E
|
3
|
|
|
Lun. 01/04/2019
|
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). Struttura del File System fisico (Luc. Unix Tabelle 3): concetto di MOUNT. File system logico (Luc. Unix Tabelle 4): rispiegato necessità di link software per traversare file system fisici diversi! Rivisto informazioni nell'I-NODE (Luc. Unix Tabelle 5) e spiegato significato dei 13 indirizzi (Luc. Unix Tabelle 6). Spiegato necessità di primitiva sync (Luc. Unix Tabelle 7).
|
L
|
2
|
|
|
Mer. 03/04/2019
|
File C - Fatto vedere comando DF per vedere i file system fisici montati (con anche opzione -i per vedere gli i-node occupati e liberi) e caratteristiche dei dispositivi /dev/xxx usati come file system fisici. 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. 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; 2) ripetuta dello stesso file per calcolare la dimensione della TFA di ogni processo. 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. Esempi di read e write: a) copia di file con parametri e controlli (Luc. 11-13) con spiegazione di BUFSIZ (Luc. C/UNIX 16) (fatto vedere programma che ne stampa il valore); b) copia di file con PERM diversi e spiegazione su influenza di umask che può avere effetto sui diritti specificati all'atto della creazione. Altri esempi di read e write: c) copia con ridirezione ( Luc. C/UNIX 15); d) implementazione di un 'clone' di cat.
|
L
|
2
|
|
|
Ven. 05/04/2019
|
Prima Prova in Itinere sulla Bourne Shell UNIX: 6 turni nei due laboratori LINFA e INFOMEC (3 mega-turni da 50 studenti)!
|
E
|
5
|
|
|
Lun. 08/04/2019
|
File C - Precisato che i controlli sui diritti di accesso vengono effettuati su UID e GID effettivi del processo che esegue un certo programma: si riveda osservazione inserita nel codice dell'esercizio provaopen.c della volta scorsa (Luc. C/UNIX 17).
Implementazione della ridirezione in ingresso e in uscita (Luc. C/UNIX 19): simulazione in C della ridirezione in ingresso e in uscita e versione con stampa degli fd usati in input e in output su /dev/tty. Operazione non sequenziali: lseek (Luc. C/UNIX 20). Primo esempio di append su un file (Luc. C/UNIX 22, 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). Approfondimenti su open (Luc. C/UNIX 7): esempio con vari casi. Lasciato da guardare agli studenti la seconda versione di append su file. Tabelle per l'accesso ai file (Luc. Unix Tabelle 8-10): implementazione nel Kernel di Linux. Spiegato significato della sincronicità e della atomicità delle operazioni primitive, in particolare read e write su file (Luc. C/UNIX 23).
|
L
|
2
|
|
|
Mer. 10/04/2019
|
Processi UNIX (nota bene fatti tutti gli esempi sul sistema al termine delle spiegazioni): 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 in generale di un file (Luc. Processi 16-17) e condivisione I/O pointer file aperti da padre prima della fork (Luc. Processi 14-15). Presentato primitive getpid, getppid, getuid, geteuid, getgid e getegid (Luc. Processi 19). Spiegazione del valore di ritorno della fork (Luc. Processi 12).
Primo esempio semplice: due versioni, la seconda con primitive getpid, getuid e getgid. Mostrato, in entrambi, i casi il problema di 'mescolamento' delle stringhe scritte su standard output a causa dell'I/O Pointer condiviso. Secondo esempio semplice con differenziazione del codice dopo la fork usando il valore di ritorno (avendo controllato anche che la fork abbia avuto successo).
Primitiva wait in generale (Luc. Processi 20). Spiegato significato della wait e valore ritornato dalla wait in caso di errore: 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).
|
L
|
2
|
|
|
Ven. 12/04/2019
|
Esercitazione in Laboratorio (C1) -
|
E
|
3
|
|
|
Lun. 15/04/2019
|
Processi UNIX - Ripreso primitiva wait e spiegato terminazione normale (in particolare con exit) e terminazione involontaria (Luc. Processi 20-22). Spiegato significato dell'effetto collaterale operato dalla wait 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).
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). Altro esempio di uso di wait con recupero valore di exit: con mascheramento a mano e con uso di macro (quest'ultima lasciata da guardare agli studenti). 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 (mostrato solo il risultato e il codice lasciato da guardare agli studenti).
Ripreso schema del funzionamento della SHELL per generare un processo figlio per eseguire un comando non interno e parlato della condivisione di codice. 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 e un esempio sbagliato; richiesta di esecuzione di un programma eseguibile definito dall'utente. Esempio di attivazione dello stesso programma (in ricorsione). Completato famiglia di primitive exec: execve e execle (Luc. Processi 31). Esempi di uso di fork ed exec (Luc. Processi 32): mylsConFork, myGrepConFork e myopen; l'ultimo esempio in particolare evidenzia l'uso di un file precedentemente aperto utilizzando il concetto di ridirezione dello standard input da parte di un programma eseguito tramite exec.
|
L
|
2
|
|
|
Mer. 17/04/2019
|
Processi UNIX - Ripreso primitiva exec in particolare con fork e presentato situazione dei processi padre e figlio prima e dopo l'invocazione della primitiva exec (Luc. Processi 33).
Spiegato due dei 3 bit speciali presenti nell'I-NODE di un file (Luc. Shell 17) validi solo per i file eseguibili (SUID e SGID): 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). Esempio tramite fork e poi exec del comportamento del SUID (un esempio e un contro-esempio). 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 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. Calcolo della lunghezza di una pipe (Luc. Pipe 5). Processi che possono comunicare tramite una pipe: necessità di relazione di parentela (Luc. Pipe 6).
|
L
|
2
|
|
|
Ven. 03/05/2019
|
Esercitazione in Laboratorio (C2) -
|
E
|
3
|
|
|
Lun. 06/05/2019
|
Processi UNIX - 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-9). PIPE - Problemi (Luc. Pipe 10-11): a) pipe senza scrittore (lasciato da verificare caso scorretto nel caso di mancanza di chiusura dei lati giusti della pipe); b) caso pipe senza lettore con invio del segnale SIGPIPE. Esempio di possibile implementazione del PIPING dei comandi (Luc. Pipe 12-14): primitiva DUP; fatto vedere un primo esempio di funzionamento.
|
L
|
2
|
|
|
Mer. 08/05/2019
|
Processi UNIX - Ripreso esempio di possibile implementazione del PIPING dei comandi (Luc. Pipe 12-14): fatto vedere un secondo esempio di funzionamento in cui si evidenziano le relazione di parentela fra i processi creati e mostrato che queste relazioni di parentela sono quelle della Bourne Shell (usato jsh come esempio di implementazione della Bourne Shell).
Letto il testo della seconda prova in itinere del 5 Giugno 2015 e analizzate dettagliatamente le specifiche: mostrato codice e funzionamento.
Letto 'in parallelo' le specifiche dei testi della parte C dell'esame del 12 Febbraio 2016 e della seconda prova in itinere del 26 Maggio 2017: analizzate dettagliatamente le specifiche, ma non fatto in tempo a mostrato codice e funzionamento.
|
L
|
2
|
|
|
Ven. 10/05/2019
|
Esercitazione in Laboratorio (C3) -
|
E
|
3
|
|
|
Lun. 13/05/2019
|
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 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. 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.
|
L
|
2
|
|
|
Mer. 15/05/2019
|
Processi UNIX - Primitiva KILL (Luc. Segnali 10) e PAUSE (Luc. Segnali 11): esempio (Luc. Segnali 12-13). Primitiva ALARM (Luc. Segnali 11): Esempio di pause e alarm (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 e Lab. e relativa soluzione della sola parte C del 15 Luglio 2015: padre deve creare un file con nome specificato e un numero di figli pari ai file passati; i figli leggono un carattere per volta dal file SOLO dopo l'indicazione del padre e lo inviano al padre che lo scrivi sul file creato; appena il figlio associato al file più corto termina, il padre deve uccidere forzatamente gli altri figli.
|
L
|
2
|
|
|
Ven. 17/05/2019
|
Esercitazione in Laboratorio (C4) -
|
E
|
3
|
|
|
Lun. 20/05/2019
|
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).
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 la specifica del testo della parte C dell'esame del 12 Luglio 2017.
|
L
|
2
|
|
|
Mer. 22/05/2019
|
Processi UNIX - Solo esercizi di esame in preparazione della II prova in itinere:
- Parte C dell'esame del 12 Luglio 2017: 2N parametri, nomi assoluti di file intercalati da numeri interi (strettamente positivi) che rappresentano la lunghezza in linee; padre genera N processi figli; ogni figlio genera un nipote; i nipoti sono associati agli N file, devono generare un numero random (r) compreso fra 1 e la lunghezza in linee e poi devono passare al figlio le prime r linee usando il comando head -r; ogni figlio deve ricevere tutte le linee e per ogni linea ricevuta deve mandare al padre una struttura con 3 campi; il padre deve ricevere tali strutture in un ordine bene preciso: prima la prima struttura dal primo figlio, poi la prima struttura dal secondo figlio e così via fino a che tutti i figli non hanno terminato di inviare.
- ripreso poi i testi degli esami del 12 Febbraio 2016 e 26 Maggio 2017 ed illustrato le cose in comune (gestione pipeline, necessità di salvare i pid dei figli da parte del padre) e le cose differenti (un array dinamico con dimensione via via crescente oppure solo una struttura passata nella pipeline).
|
L
|
2
|
|
|
Ven. 24/05/2019
|
Esercitazione in Laboratorio (C5) -
|
E
|
3
|
|
|
Lun. 27/05/2019
|
LEZIONE NON TENUTA A CAUSA DELLA SOSPENZIONE DELLE LEZIONI PER ELEZIONI!
|
L
|
2
|
|
|
Mer. 29/05/2019
|
Processi UNIX - Solo esercizi di esame in preparazione della II prova in itinere:
1) parte C dell'esame dell'11 Luglio 2018;
2) seconda prova in itinere dell'8 Giugno 2011.
|
L
|
2
|
|
|
Ven. 31/05/2019
|
Seconda Prova in Itinere sul Linguaggio C per UNIX: 3 turni nei due laboratori LINFA e INFOMEC (1 mega turno da 51 studenti e poi un turno da 33).
|
E
|
4
|
|
|
Lun. 03/06/2019
|
Processi UNIX - Solo esercizi di esame:
1) prova in itinere del 31 Maggio 2019; spiegazione delle differenze fra i vari testi e di conseguenza delle soluzioni.
2) esame del 12 Settembre 2018; prima parte shell e poi velocemente parte C.
|
L
|
2
|
|
|
Mer. 05/06/2019
|
NON TENUTA DATO CHE ARRIVATI GIA' A 82 ORE (DELLE 81 DA FARE)!
|
L
|
2
|
|
|
Ven. 07/06/2019
|
NON TENUTA DATO CHE ARRIVATI GIA' A 82 ORE (DELLE 81 DA FARE)!
|
E
|
5
|
|