Diario delle Lezioni
A.A. 2021/2022

Sistemi Operativi e Lab.
Ingegneria Informatica - Laurea Triennale


Data
Argomento
Tipo
N Ore
Riferimento
Lun. 28/02/2022
Spiegazione dell'orario e dell'organizzazione delle lezioni/esercitazioni. Illustrazione del sito: 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 2022); necessità di registrazione all'applicazione per gli esami per gestione liste prove in itinere ed esami; testi consigliati (Slide Programma).
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. Gestore dei processi (Nucleo/Kernel). Ripreso concetto di processo, spiegato processi utente e processi di sistema, funzioni tipiche di un kernel (in particolare scheduling) (Slide Introduzione sui SO, 1-8).
L
2
Lun. 28/02/2022
GENERALITÀ - 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 (Slide Introduzione sui SO, 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 (Slide 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 (Slide Introduzione sui SO, 13).
Problema del deadlock (Slide Introduzione sui SO, 14-15).
Gestore dei dispositivi di I/O: in particolare, gestione degli interrupt (Slide 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). Memoria virtuale, in particolare gestione basata su segmentazione paginata (Slide Introduzione sui SO, 16-19). Saltato per ora Gestione della memoria secondaria (Slide Introduzione sui SO, 20).
Gestione interfaccia utente: interfacce grafiche e testuali (Slide 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) (Slide File System, 1-7).
UNIX - Introduzione: storia e connessione con Linguaggio di Programmazione (di sistema) C; Unix come sistema operativo multigrammato (e multiprocesso) e multiutente (Slide UNIX-Shell 1).
Fase di autenticazione: necessità di login e logout (Slide UNIX-Shell 2): concetto di terminale (nelle lezioni se ne userà uno virtuale).
File in UNIX: file come stream di byte e come astrazione unificante per file ordinari, directory e file speciali come i dispositivi (contenuti in /dev) (Slide UNIX-Shell 3). Struttura del File System di UNIX: directory tipiche (Slide UNIX-Shell 4).
Spiegazione della fase di autenticazione: file /etc/passwd con suo formato (comando cat per visualizzare un file di testo) e file /etc/shadow (Slide UNIX-Shell 5).
L
4
Mer. 02/03/2022
Shell - Uso di PC collegato ad un server Linux. Nel seguito fra parentesi si indicano le slide su "UNIX e la Shell" cui il registro fa riferimento.
Mostrato sul server Linux la fase di autenticazione; le directory tipiche della directory radice (/). Mostrato file /etc/passwd in due modi e quindi mostrato risultato del comando cd per cambiare directory e del comando pwd per visualizzare la directory corrente (all'inizio è la HOME directory: comando echo $HOME). Mostrato che non è possibile visualizzare il file /etc/shadow (Slide 6): precisazione sull'utente 'root' e spiegazione sudoers. Comando id per vedere UID e GID.
Dimostrazione della multi-utenza: collegamento anche con un secondo account (sonod) e mostrato di nuovo comando id e comando who (anche versione w).
Esempio di utente che ha un comando 'strano' inserito nel file /etc/passwd invece che una shell (Slide 6): prova di collegamento di questo utente.
Spiegazione funziomanento della shell come processore comandi con in genere creazione di un processo figlio (sotto-shell) che esegue il comando (Slide 7): verifica con uno del comando ps con varie opzioni (-f, -l e -e): introdotto anche il comando man (manual).
Possibilità di 'lanciare' quindi usare diverse shell (Slide 8): verifica dei rispettivi processi con comando ps.
L
2
Lun. 07/03/2022
Shell - Ripreso organizzazione del File System e nomi di file assoluti, relativi alla directory corrente e relativi semplici (Slide 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 Slide 9). Mostrato simulazione della gerarchia della Slide 9 (comando ls -R, cioè ricorsione). Approfondimento su ls: varie opzioni (Slide 10); 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 Slide 9): spiegato concetto di pattern matching ed esempi di uso; mostrato effetto dell'uso di * e ? utilizzando sh -x.
Protezione dei file (Slide 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 le directory. Comandi chown e chgrp solo per il SUPERUTENTE (Slide 12).
Concetto di link (hardware) per i file (comando ln, Slide 13): comando ln. Spiegato come si realizza in UNIX il concetto di link: struttura directory (Slide 14) con i-number e i-node: mostrato uso di opzione -i di ls. Differenze con il comando cp per copiare file.
Mostrato contenuto dell'i-node (Slide 15) in particolare numero di link. 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 le directory e comando mkdir.
L
2
Lun. 07/03/2022
Esercitazione in Laboratorio (S1) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì7Marzo2022.pdf.
E
4
Mer. 09/03/2022
Shell - Comando per spostare i file o semplicemente rinominarli (comando mv): spiegazione in base ai comandi ln e rm (slide 13). Comando rmdir (solo con directory vuota) e opzione -r di rm per cancellazione ricorsiva e quindi anche di directory (slide 16).
Concetto di link software per file e directory (comando ln -s) e differenza rispetto al link hardware: in particolare,
mostrato comportamenti diversi in caso di cancellazione file (dangling reference) e link; necessità di uso per le directory e per creare link in gerarchie residenti su dispositivi fisici diversi (slide 15).
Riassunto comandi visti finora (Slide 16): spiegato il significato del nome catenate per il comando cat. Introdotto anche il comando more con le differenze con cat in particolare se usato con più nomi di file.
Generalizzazione del concetto di file (Slide. 8 del File System). Concetto di filtro e di standard input, standard output e standard error: associazioni di default e loro modifica con RIDIREZIONE (Slide. 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 Slide 18). Uso come filtri in particolare per ridirezione in ingresso oltre che in uscita: in particolare il filtro cat usato come semplice editor; concetto di EOF da tastiera (^D) e differenza dall'abort di un comando con ^C; cat usato come alternativa al comando cp. Altri esempi di filtri (di nuovo Slide 18): comando/filtro more. Precisazione sul comando more usato come comando in presenza di file eseguibili! Altri esempi di filtri (di nuovo Slide 18): 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].
L
2
Lun. 14/03/2022
Shell - Ripreso discorso sulla ridirezione. Altri esempi di filtri (di nuovo Slide 18): 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 \), wc (con opzioni -c, -w, -l e differenze fra filtro e comando), head, tail, rev.
Chiarimento su numeri impliciti della ridirezione dello standard input e dello standard output. Ridirezione dello standard error (Slide 21) con esempi: in particolare, uso di /dev/null. (Slide 22 per ora saltato).
Piping: composizione di comandi/filtro (Slide 23, 24). Realizzazione mediante più processi e canali di comunicazione. Esempi semplici con uso anche del filtro tee ed esempio che mostra la presenza di un processo per ogni comando in piping.
Esecuzione di comandi in background (Slide 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: date, diff (con anche valore di ritorno) e find (Slide 27).
L
2
Lun. 14/03/2022
Esercitazione in Laboratorio (S2) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì14Marzo2022.pdf.
E
4
Mer. 16/03/2022
Shell - Introduzione alla programmazione in shell (Slide 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 (Slide 29): valore come stringa, sintassi assegnamento e sintassi per riferire il valore. Concetto di ambiente di shell (Slide 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 directory 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 (Slide 32 e 33). Mostrati gli ulteriori metacaratteri [ ] (ancora Slide 33) con vari esempi (Slide 34).
Ripreso concetto di variabile (Slide 35): altro esempio semplice di file comandi con le variabili di ambiente PATH, HOME e directory corrente. Esempio di variabili shell con necessità sia di valutazione di comandi (uso di backquote ``) che del comando expr.
L
2
Lun. 21/03/2022
Shell - Inibizione delle sostituzioni attuate dallo shell (Slide 36): esempi vari e necessità di eval.
Passaggio di parametri nei file comandi (Slide 37): $1, $2, $3, etc; spiegato significato di $0; spiegato comandi shift e set.
Introdotto quindi altre pseudo-variabili predefinite (Slide 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 (Slide 38).
La struttura di controllo if per realizzare l'alternativa semplice (Slide 39): primi esempi semplici (file if1.sh, if2.sh e if3.sh). Introdotto il comando test (Slide 40): altri esempi di if (if4.sh, if5.sh e DIRCTL.sh). Spiegato la differenza di test -eq e di test =. Altri esempi di if anche con il comando read (Slide 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 (Slide 42): primo esempio di uso che consente maggiore flessibilità nella interazione con l'utente (file readCase.sh).
Struttura di controllo per i cicli enumerativi: for (Slide 43); diversi esempi (file for1.sh, for1-conConteggio.sh e crea.sh). Altri esempi di liste usabili nei for.
L
2
Lun. 21/03/2022
Shell - Ripreso struttura di controllo for con altri esempi di 'liste' (file for4.sh e for4Bis.sh) (Slide 43).
Strutture di controllo per i cicli non enumerativi: while e until (Slide 44): un esempio ciasccuno (file ce.sh e ceUtente.sh).
[IN REALTA' LA DURATA E' STATA MEZZ'ORA]
L
1
Lun. 21/03/2022
Esercitazione in Laboratorio (S3) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì21Marzo2022.pdf.
[In realtà durato 3,5 ore]
E
3
Mer. 23/03/2022
Shell - PROBLEMI DI ACCESSO AL SERVER USATO PER LE PROVE E QUINDI FATTO SOLO PARTE DI TEORIA!
Discorso generale di come strutturare le soluzioni (presentazione powerpoint): due file comandi, uno iniziale e uno ricorsivo 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. Primo esempio di ricerca di un file in una gerarchia con due file comandi: illustrato il primo file comandi (Slide 45, file Beginc.sh) e tutti i controlli. Esempi di invocazioni sbagliate/corrette lasciate da guardare agli studenti.
Mostrato secondo file comandi, quello ricorsivo, nella versione con ricerca breath-first (Slide 46): mostrato tramite una presentazione powerpoint passo-passo quello che succede nelle varie attivazioni ricorsive su una semplice gerarchia. Lasciato da guardarer agli studenti cosa succede nel caso di non settare la variabile PATH (e non esportare la modifica).
Presentato esercizio che conta tutti i file presenti in una gerarchia: 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 di ambiente e valore di ritorno (ver2), versione con variabile di shell e valore di ritorno (ver3) e versione con uso di scrittura e lettura in un file temporaneo globale del valore del conteggio (ver4).
L
2
Lun. 28/03/2022
Shell - Svolta la parte SHELL di 3 esercizi di esame:
1) Soluzione della parte in Shell del 18 Gennaio 2017 (presenza di nome relativo semplice di directory): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e una gerarchia di prova; mostrato file 18Gen17.sh e FCR.sh e funzionamento sulla gerarchia di prova.
2) Soluzione della parte in Shell del 17 Gennaio 2018 (presenza di numeri > 0 e singolo carattere); discusso sul fatto che in questo testo si deve svolgere tutto il problema nel file comandi ricorsivo): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e una gerarchia di prova; mostrato file FCP.sh e FCR.sh e funzionamento sulla gerarchia di prova.
3) Soluzione della prima prova in itinere del 7 Aprile 2017 (presenza di nome relativo semplice di file, con conteggio globale dei file sorted creati): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e due gerarchie di prova; mostrato file FCP.sh e FCR.sh e funzionamento sulle due gerarchie di prova.
L
2
Lun. 28/03/2022
Presentazione a cura del Prof. Federico Ricci dello sportello di Accoglienza e Ascolto.
Esercitazione in Laboratorio (S4) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì28Marzo2022.pdf.
E
4
Mer. 30/03/2022
Shell - ULTIMA LEZIONE SULLA SHELL.
Svolta la parte SHELL di 3 esercizi di esame:
1) Soluzione della prima prova in itinere dell'11 Aprile 2014 (necessità di tanti file temporanei): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e due gerarchie di prova; mostrato file fasi.sh e FCR.sh e funzionamento sulle due gerarchie di prova.
2) Soluzione della prima prova in itinere del 13 Aprile 2012 (due fase A/B e conteggio livelli delle gerarchie): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e una gerarchia di prova con 4 livelli; mostrato ver1 della soluzione e quindi file fasi1e2.sh e FCR.sh e funzionamento sulla gerarchia di prova.
3) Soluzione della prima prova in itinere dell'15 Aprile 2016 (ricerca di directory foglia con ulteriore vincolo sui file): spiegato tramite una presentazione powerpoint il testo, i requisiti del problema, una invocazione di prova e tre gerarchie di prova; mostrato file fasi.sh e FCR.sh e funzionamento sulle tre gerarchie di prova.
Mostrato una presentazione powerpoint in cui sono riportate le caratteristiche generali dei testi delle parti SHELL dei testi di esame con la classificazione degli esercizi visti finora e di quelli che verranno proposti alla prossima esercitazione.
L
2
Lun. 04/04/2022
Visione di insieme punti di vista esterno: shell e linguaggio C; accenno a punto di vista interno.
Il linguaggio C come linguaggio di sistema (Slide C/UNIX 1-3): caratteristiche di basso livello ed interazione con il sistema operativo UNIX. Spazio di indirizzamento di un processo: 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 (Slide File System 9-11): creazione/cancellazione e lettura/scrittura; ottimizzazione: apertura/chiusura. Visione di basso livello dei file per UNIX/LINUX (Slide 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 (Slide C/UNIX 7). Relazioni fra TFA dei singoli processi e tabelle di sistema (Slide Unix Tabelle 1-2): Tabella dei file aperti e Tabella degli I-NODE attivi (per ora spiegato solo la necessità di quest'ultima). Introdotto struttura del File System fisico (Slide Unix Tabelle 3): concetto di MOUNT. Spiegato necessità della primitiva sync (Slide Unix Tabelle 7). File system logico (Slide Unix Tabelle 4): rispiegato necessità di link software per traversare file system fisici diversi! Rivisto informazioni nell'I-NODE (Slide Unix Tabelle 5) e spiegato significato dei 13 indirizzi (Slide Unix Tabelle 6).
L
2
Lun. 04/04/2022
Esercitazione in Laboratorio (S5) - ULTIMA ESERCITAZIONE SULLA SHELL- Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì4Aprile2022.pdf.
E
4
Mer. 06/04/2022
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>): primitiva open/creat e close. 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 (Slide File System 12-13): metodo di accesso sequenziale (concetto di file pointer o I/O pointer). Ripreso concetto di File pointer in C/UNIX e introdotto le operazioni di basso livello sui file in UNIX/LINUX (Slide C/UNIX 9-11): read e write. Esempi di read e write: a) copia di file con parametri e controlli (Slide 15) con spiegazione di BUFSIZ (Slide C/UNIX 17) (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; c) copia con ridirezione (Slide C/UNIX 16); d) Implementazione di un 'clone' di cat.
L
2
Mer. 20/04/2022
File C - Rimarcato che la molteplicità di caratteri da leggere con una read dipende dalla specifica del problema (Slide C/UNIX 18). Sottolineato che i controlli che avvengono all'apertura/creazione di un file sono basati su Effective UID ed Effective GID del processo che richiede l'operazione (che possono essere diversi dal Real UID e Real GID) (Slide C/UNIX 18).
Implementazione della ridirezione in ingresso e in uscita (Slide C/UNIX 19): spiegazione con l'aiuto di un disegno di come avviene tale implementazione nella Bourne shell. 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 (Slide C/UNIX 20). Primo esempio di append su un file (Slide C/UNIX 22, esercizio della Slide 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 (Slide C/UNIX 8): esempio con vari casi.
Tabelle per l'accesso ai file (Slide Unix Tabelle 8-10): implementazione nel Kernel di Linux.
Spiegato significato della atomicità delle operazioni primitive, in particolare read e write su file (Slide C/UNIX 23).
L
2
Mer. 27/04/2022
Processi UNIX: modello ad ambiente locale e sue eccezioni relativamente a file system (Slide Processi 1). Tipi di processi, scheduling, memoria virtuale, swapping e modi di esecuzione dei processi (Slide Processi 2) anche in Linux (Slide Processi 3). Immagine di un processo: parte utente e di kernel e Tabelle di sistema: Process Table e Text Table (Slide Processi 4-7): spiegato descrittore di processo (anche in Linux Slide Processi 8) e condivisione del codice. Stati di un processo in UNIX (Slide Processi 9) con confronti stati di un processo in Sistemi Operativi multiprocesso generali.
Primitive per la gestione dei processi: creazione ===> fork e sui effetti (Slide Processi 10-11): transizione di stato da idle a ready per il processo figlio. Ripreso schema del funzionamento della SHELL per generare un processo figlio per eseguire un comando non interno e parlato della condivisione di codice. Mostrato applicazione .jar scaricabile dal sito per verificare il funzionamento di alcune primitive e in particolare della fork(). Condivisione di file e I/O pointer per file aperti da padre prima della fork (Slide Processi 14-15) e condivisione in generale di un file (Slide Processi 16-17).
Primo esempio semplice (padre che genera un processo figlio, programma unodue.c) con presentazione in powerpoint dei descrittori dei processi e degli spazi di indirizzamento dei processi padre e figlio e ipotesi di funzionamento. Illustrato primitive getpid, getppid, getuid, geteuid, getgid e getegid (Slide Processi 19): ulteriore esempio (unodueConPID-UID-GID.c). Mostrato, in entrambi gli esempi visti, il problema di 'mescolamento' delle stringhe scritte su standard output a causa dell'I/O Pointer condiviso. Spiegazione del valore di ritorno della fork (Slide Processi 12): altro esempio semplice con differenziazione del codice dopo la fork usando il valore di ritorno (avendo controllato anche che la fork abbia avuto successo, programma unoEdue.c).
L
2
Lun. 02/05/2022
Processi UNIX - Osservazioni su fork (S. Processi 13). Primitiva wait in generale (S. Processi 20). Lasciato da guardare agli studenti esempi di fork e wait con errore: due casi (padre senza nessun figlio e uso di una wait e padre con un figlio e uso di due wait). Esempio senza errori di uso di fork e wait, ma senza uso del valore ritornato dal figlio con la exit (transizioni di stato per processo padre da running a sleeping per effetto della primitiva wait e quindi transizione di stato da sleeping a ready al termine del processo figlio). Possibili terminazioni di un processo: anormale e normale, in particolare con la exit (S. Processi 22) Spiegato significato del valore ritornato dalla wait come effetto collaterale sul parametro intero di cui deve essere passato l'indirizzo e spiegato le operazioni di mascheramento sui byte di tale intero e schema di invocazione della wait (S. Processi 23) e uso di presentazione in powerpoint. Altro esempio di uso di wait con recupero valore di exit: con mascheramento a mano (di nuovo con uso della stessa presentazione in powerpoint) e con uso di macro (i cui dettagli lasciati da guardare agli studenti). Spiegato vincolo che il valore che può essere ritornato con la exit al padre debba essere positivo e minore o uguale a 255: lasciato da guardare agli studenti esempio che illustra tale vincolo.
Rispiegato funzionamento shell nel caso di esecuzione di un comando non interno in foregroud (fork+wait) e in background (solo fork); ancora uso della stessa presentazione in powerpoint: parlato della condivisione di codice e necessità della esecuzione di un nuovo programma. Famiglia di primitive EXEC: execv, execl, execvp e execlp; effetti exec (S. Processi 27-28). Esempi semplici di uso (S. Processi 29-30): richiesta di esecuzione di ls con due esempi corretti (myls1.c e myls2.c) e un esempio sbagliato (mylsErrato.c); richiesta di esecuzione di un programma eseguibile definito dall'utente (callecho.c e myecho.c). Lasciato da guardare agli studenti esempio di attivazione dello stesso programma (in ricorsione): prova.c. Esempi di uso di fork ed exec (S. Processi 32): mylsConFork.c e myGrepConFork.c. Connessione con comportamento della SHELL: in particolare, implementazione ridirezione e quindi file aperti prima di exec: myopen.c e leggi.c.
L
2
Lun. 02/05/2022
Esercitazione in Laboratorio (C1) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì2Maggio.pdf.
E
4
Mer. 04/05/2022
Processi UNIX - Ripreso famiglia di primitive EXEC: osservazioni con anche execve e execle (S. Processi 31). Riguardo all'ultimo esempio della volta scorsa (S. Processi 32) presentato situazione dei processi padre e figlio prima e dopo l'invocazione della primitiva exec (S. Processi 33): spiegazione su ottimizzazione di Linux (S. Processi 18).
Completato discorso sui 2 bit speciali che sono presenti nell'I-NODE di un file solo nel caso che sia eseguibile (S. 17 - SHELL); in particolare, comportamento del SUID anche grazie ad una con presentazione in powerpoint: il comando passwd e il file shadow e due programmi scritti in C con un esempio e un contro-esempio.
Esempio di un programma che simula in modo molto semplice un processore dei comandi (S. Processi 36): uso della variabile errno e della primitiva di gestione degli errori perror (S. Processi 37). Primitive viste finora (S. Processi 38).
Interazione fra processi in UNIX (S. Pipe 1). Presentato in generale problema produttori-consumatori per passare informazioni (dati) da un processo all'altro. Comunicazione mediante PIPE (S. Pipe 2): comunicazione fra processi: in particolare, introdotto i termini di Produttore-Consumatore, Sender-Receiver, Mittente-Destinatario e Client-Server (declinati al singolare o al plurale). Creazione pipe e omogeneità con i file (S. Pipe 3-4). Calcolo della lunghezza di una pipe (S. Pipe 5).
L
2
Lun. 09/05/2022
PIPE - Uniformità con i file e differenze sostanziali (Slide Pipe 5). Processi che possono comunicare tramite una pipe: necessità di relazione di parentela (Slide Pipe 6). Esempio Produttore (figlio) e Consumatore (padre) usando una pipe (Slide Pipe 7): necessità di chiusura dei lati non necessari (Slide Pipe 8-9). Dettagli su tabella interna associata ad ogni pipe (Slide Pipe 10). Problemi (Slide Pipe 11-12): a) pipe senza scrittore; b) caso pipe senza lettore con invio del segnale SIGPIPE
Esame del 5 Giugno 2015 (seconda prova in Itinere, quindi solo parte C): processo nipote che esegue tail -1 su file associato e figlio connesso in pipe che ricava lunghezza linea e la comunica al padre: presentato preliminarmente una versione ridotta del testo, che esclude la presenza dei processi nipoti e analizzate dettagliatamente le specifiche: mostrato codice e funzionamento.
L
2
Lun. 09/05/2022
Esercitazione in Laboratorio (C2) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì9Maggio.pdf.
E
4
Mer. 11/05/2022
Processi UNIX - Primitiva DUP (Slide Pipe 13): esempio di possibile implementazione del PIPING dei comandi (Slide Pipe 14-15). Verifica su jsh (che è una shell che a livello implementativo è simile alla BOURNE Shell) del legame di parentela fra processi coinvolti e chi esegue cosa. Ripreso il testo completo della seconda prova in itinere del 5 Giugno 2015 e analizzate dettagliatamente le ulteriori specifiche: mostrato codice e funzionamento.
Esame dell'11 Luglio 2018 (solo parte C): figli comunicano posizione del carattere da cercare al padre e attesa dell'OK o meno dal padre ai figli se riportare delle informazioni su standard output. Iniziato analisi dettagliata delle specifiche e individuato alcuni elementi importanti della soluzione: due array di pipe e array finito.
L
2
Lun. 16/05/2022
Processi UNIX - Ripreso esercizio 11 Luglio 2018 (solo parte C): analizzato dettagliatamente le specifiche e individuato alcuni elementi importanti della soluzione: due array di pipe e array finito. Inoltre, schema di comunicazione fra figli e padre. Mostrato soluzione e mostrato funzionamento in particolare per i due file mostrati nella presentazione powerpoint.
Sincronizzazione in UNIX mediante SEGNALI: definizione dei segnali (Slide Segnali 1) e loro trattamento (Slide Segnali 2). Elenco (parziale) segnali (Slide Segnali 3). Primi esempi di segnali semplici (Slide Segnali 4) con programma loop: SIGINT (CTRL-C), SIGTERM e SIGKILL. Infine, ultimo esempio di segnali semplici (ancora Slide Segnali 4) con programma illegal: SIGILL.
L
2
Lun. 16/05/2022
Esercitazione in Laboratorio (C3) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì16Maggio.pdf.
E
4
Mer. 18/05/2022
SEGNALI - Primitiva SIGNAL (Slide Segnali 5): definizione di un HANDLER, default e possibilità di ignorare un segnale. Osservazione sui segnali (Slide Segnali 6) e in particolare: a) comportamento in seguito a fork ed exec (Slide Segnali 7); b) differenze di gestione fra versione BSD e System V (Slide Segnali 6) con esempio di uso del segnale corrispondente al CTRL-C: comportamento in BSD (Slide Segnali 8) con prova di funzionamento e spiegato solo a parole comportamento in System V (Slide Segnali 9). Primitiva KILL (Slide Segnali 10) e PAUSE (Slide Segnali 11). Primo esempio semplice di uso di KILL e PAUSE (oltre che di SIGNAL) (Slide Segnali 12-13). Primitiva ALARM (Slide Segnali 11): Esempio di pause e alarm (Slide Segnali 14-15). Ripreso esempio calcolo lunghezza pipe (Slide Pipe 16): trattamento mediante SIGALRM. Ripreso esempio di pipe senza lettore (Slide Pipe 14-15): trattamento segnale SIGPIPE.
L
2
Lun. 23/05/2022
Processi UNIX - SOLO ESERCIZI:
1) Parte C dell'esame 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 scrive sul file creato; appena il figlio associato al file più corto termina, il padre deve uccidere forzatamente gli altri figli; mostrata soluzione della sola parte C e funzionamento in particolare con due file specifici.
2) Seconda prova in itinere del 26 Maggio 2017: analizzato lo schema di comunicazione a pipeline, in particolare il numero di pipe che servono (N, e cioè quanti i processi figli) e il fatto che nella soluzione ogni figlio Pi legge dalla pipe i-1 e scrive sulla pipe i; al padre arriva una singola struttura (con 3 campi); necessità che il padre salvi in un array creato dinamicamente i pid dei figli per quello che deve stampare una volta ricevuta la struttura dall'ultimo figlio.
L
2
Lun. 23/05/2022
Esercitazione in Laboratorio (C4) - Usato il LINFA allargato con l'aiuto di Stefano Carretti: si veda il documento EsercitazioneLunedì23Maggio.pdf.
E
4
Mer. 25/05/2022
Processi UNIX - Ripreso slide stati di un processo UNIX (Slide Processi 9): spiegazione dettagliata dello stato ZOMBIE e della sua necessità. Processi ZOMBIE (Slide Processi 25) ed ereditati da INIT (Slide Processi 26): due esempi relativi. Parlato anche dei processi zombie ereditati da init.
Inizializzazione del sistema UNIX e comportamento della shell (Slide Processi 34-35): verifica sia sul sistema usato normalmente che su un sistema con installata una versione meno recente di Linux.
Presentato 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 ai figli le prime r linee usando il comando head "-r" (-r inteso come la stringa corrispondente); 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. Mostrato soluzione e prova di funzionamento.
L
2
Lun. 30/05/2022
Processi UNIX - Solo Esercizi:
- Parte C dell'esame del 12 Febbraio 2016: N + 1 parametri, N file e un singolo carattere alfabetico minuscolo (Cx); padre genera N processi figli; ogni figlio è associato ad un file; comunicazione in pipeline dal primo figlio all'ultimo e poi al padre; i figli devono passare in avanti un array dinamico di strutture; al padre deve arrivare un array di N strutture i cui campi vanno stampati insieme a Cx e al pid dei figli corrispondenti.
Mostrato soluzione e prova di funzionamento.
- Parte C dell'esame dell'11 Febbraio 2011: N + 1 parametri, un intero positivo e dispari (H) e N file; padre genera 2 * N processi figli; i figli devono essere considerati a coppie: figlio Pi e figlio Pi+N; ogni coppia è associata allo stesso file; comunicazione dal secondo figlio della coppia al primo figlio della coppia; il primo figlio della coppia deve creare un file con nome ottenuto dal concatenamento del nome del suo file e della stringa ".mescolato" e deve leggere a blocchi di grandezza H dalla prima metà del file, mentre il secondo figlio della coppia deve leggere dalla seconda metà del file; il primo figlio scrive sul file creato i blocchi in modo mescolato.
Mostrato soluzione e prova di funzionamento.
L
2
Lun. 30/05/2022
Esercitazione in Laboratorio (C5) - Usato il LINFA allargato con l'aiuto di Silvia Cascianelli: si veda il documento EsercitazioneLunedì30Maggio.pdf.
E
4
Mer. 01/06/2022
Processi UNIX - Parte C dell'esame del 17 Febbraio 2021: Q parametri, Q file; padre genera Q processi figli; ogni figlio è associato ad un file; tutti i file hanno lunghezza in linee uguale; comunicazione a ring dal primo figlio all'ultimo e poi di nuovo al primo, con il padre che fa l'innesco; i figli devono cercare in ogni linea i caratteri numerici e quando hanno l'OK devono scrivere su standard output alcune informazioni insieme con la linea stessa.
Mostrato soluzione e prova di funzionamento.
Mostrato schemi di comunicazione parte C con classificazione dei vari esercizi visti a lezione e proposti ad esercitazione.
L
2

Legenda:
E= Esercitazione
L= Lezione