080IN - SISTEMI OPERATIVI 2020

Topic outline

• 

  General

  • Annunci Forum
  • Libri consigliati Page
  • Esercitazioni di programmazione in C Page
  • Programma del corso Page
  • come operare in Linux Debian ed Eclipse - brevi video tutorial Page
  • Gruppo TEAMS da usare per le lezioni Page
  • articoli interessanti/utili Page
• 

  lezione 1/3/2021

  presentazione corso, programma, modalità di esame
  

  introduzione ai sistemi operativi

  installazione di una macchina virtuale per le esercitazioni

  "hello world" in linguaggio C

  • Informazioni sul corso File PDF document
  • info su VM per esercitazioni Page
  • Introduzione File PDF document
• 

  lezione 5/3

  [seguono gli argomenti che tratteremo a partire dalla lezione 5/3 ed in quelle successive]

  
  

  da Kerrisk (cap. 2), pag. 21-42
  

  introduzione ai concetti fondamentali del sistema operativo Linux: 

  il kernel, i compiti principali del kernel; modalità kernel e modalità user;

  punto di vista dei processi; punto di vista del kernel

  la shell; utenti e gruppi, user ID, group ID, home directory, login shell, superuser;

  Single Directory Hierarchy, radice del file system, tipi di files (file regolari, directories);
  

  directories e links, nomi di files (filename), pathname, pathname assoluto e relativo, cartella di lavoro corrente;
  

  proprietario dei file, permessi dei file (read, write, execute su file regolari; read, write, execute su directory);

  universalità di I/O; system call open(), read(), write(), close(); descrittori di file; 

  programmi, processi, organizzazione della memoria di processo (text, data, heap, stack), creazione di un processo, esecuzione di un programma;

  system call fork(), execve();

  process id, parent process id, terminazione di un processo (da shell: echo $?)
  

  system call _exit(), wait(); valore di stato di terminazione;
  

  credenziali di processo (real user ID, real group ID, effective user ID, effective group ID);
  

  processi privilegiati/non privilegiati;
  

  processo init; variabili di ambiente;

  memory mappings (file mapping, anonymous mapping);

  librerie statiche e condivise;

  interprocess communication e sincronizzazione tra processi:

  signals, pipes, semaphores, shared memory;

  segnali: control-C; comando kill da shell; ps -ef per trovare il pid di processo;

  threads;

  date and time: Epoch;  process time (CPU time); system CPU time, user CPU time;

  comandi top, htop;

  file system /proc : /proc/<pid>/cmdline , /proc/<pid>/fd; /proc/cpuinfo;
  

  
  

  altri comandi da shell: git pull , cd , ls , tree , sudo , sudo apt update , sudo apt upgrade , echo, id, man, pwd
  

  
  

  esempi:

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/000hello-world

  
  

  
  

  • Kernel tasks File PDF document
  • modalità utente e modalità kernel, spazio utente e spazio kernel File PDF document
• 

  lezione 8/3

  da Kernigan&Ritchie (cap. 2), pag. 36
  

  tipi dati del linguaggo C: char, int, float, double

  qualificatori dei tipi dati: short, long, unsigned, signed

  costanti (Kernigan&Ritchie pag. 37): interi, interi lunghi, carattere; base 10, base 16

  dichiarazione di variabile

  printf: %d %c %f %s %x (Kernigan&Ritchie pag. 154)

  operatore sizeof

  ciclo for, while

  direttiva #include

  limits.h: costanti CHAR_MIN, CHAR_MAX

  esempio: conversione da gradi Fahrenheit a gradi Celsius  (Kernigan&Ritchie pag. 8-9)

  stringhe di caratteri, tipo dati char *

  carattore terminatore di stringa di caratteri

  accesso ai caratteri di una stringa di caratteri con []

  "percorrere" una stringa fino al carattere terminatore di stringa

  lunghezza di una stringa di caratteri (my_strlen)

  dichiarazione e definizione di funzione

  
  

  l'esempio di programmazione C sviluppato nella lezione è tratto da questi esempi:

  
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/000hello-world
  

  
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/001fahr_to_celsius_debug
  

  
  

  tipi dati del linguaggio C (Kernigan&Ritchie pag. 9, pag. 36)
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/002data-types
  

  
  

  printf per scrivere su stdout: char, int, unsigned int, long, unsigned long, float, double
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/002printf

  
  

  • Fasi del compilatore gcc File PDF document
  • file C lezione 8/3 Text file
• 

  lezione 12/3

  system calls (Kerrisk cap. 3 pag. 43-46)

  funzioni di libreria (library function) (Kerrisk pag. 46)

  esempi da shell: find, gedit, pico
  

  C Standard Library, GNU C Library (Kerrisk pag. 47)

  errno, perror, strerror; gestione degli errori restituiti dalle chiamate di sistema (Kerrisk pag. 48-49)

  system call: getpid(), getppid(); sleep()
  

  linguaggio C: puntatori, array (Kernighan&Ritchie pag. 93-94)

  vettori (array) di caratteri; inizializzazione di vettori

  parametri di funzioni e puntatori (Kernighan&Ritchie pag. 95-96)

  variabili globali, varabili locali

  direttiva #define

  operatore & (indirizzo di), operatore * (indirezione)

  sizeof() applicato a vettori

  introduzione alle system call open, read, write, close (Kerrisk cap. 4, pag. 69-70)

  
  

  https://repl.it/@MarcoTessarotto/loop-over-array
  

  
  

  
  

  • campo d'azione (scope) File PDF document
  • file C lezione 12/3 Text file
  • esempi comandi shell Page
• 

  lezione 15/3

  argomenti di funzione passati "per valore" (by value); puntatori; array (Kernighan&Ritchie, pag. 27)

  vettore di char inizializzato con stringa di caratteri
  

  puntatore a char inizializzato con stringa costante di caratteri

  funzione getchar()
  

  End of File (EOF)
  

  leggere tutti i caratteri da stdin con getchar() fino a EOF

  funzione putchar() (Kernighan&Ritchie, pag. 15-21)
  

  sizeof() applicato ad array di dimensione nota a tempo di compilazione

  percorrere con un puntatore un vettore di char contenente una stringa di caratteri
  

  copiare un file con getchar() e putchar()

  leggere un numero intero da stdin con scanf()
  

  system call open()
  

  file descriptor
  

  modalità di accesso: O_RDONLY, O_WRONLY, O_RDWR

  opzioni O_CREAT, O_TRUNC, O_APPEND, O_EXCL
  

  system call read()
  

  shell: redirezione di stdin, stdout da/su files
  

  • file C lezione 15/3 Text file
• 

  lezione 19/3

  svolgimento in classe dell'esercizio https://github.com/marcotessarotto/exOpSys/tree/opsys2021/003.3calc-iter
  

  valore restituito da scanf()

  uso della system call read() in getchar()

  uso della system call write() in putchar()

  applicazione di copia file; redirezione di stdin e stdout tramite la shell

  system call getcwd() per ottenere la cartella di lavoro corrente del processo

  aprire in sola lettura un file con system call open()
  

  leggere in memoria tutti i contenuti di un file con system call read()

  chiudere il file con system call close()

  funzioni della C standard library malloc(), realloc(), free()

  vedere anche https://github.com/marcotessarotto/exOpSys/blob/opsys2021/004.1arrays-operations/arrays-operations.c

  lettura di file in un vettore a dimensione fissa: https://github.com/marcotessarotto/exOpSys/blob/opsys2021/004.2.1read-file-to-static-array/004.2.1read-file-to-static-array.c
  

  
  

  • esercizio per casa (da svolgere se possibile prima della lezione del 19/3) File Text file
  • file C lezione 19/3 Text file
• 

  lezione 22/3

  lunghezza di stringa di caratteri con strlen()

  confronto di stringhe con strcmp()

  duplicare una stringa con strdup()

  allocare una stringa di caratteri con malloc()

  copiare una strinca con strcpy()

  esercizio: funzione che concatena due array

  copia di array con memcpy()

  inizializzare un array con memset()

  lettura di tutti i contenuti di un file nella memoria heap: https://github.com/marcotessarotto/exOpSys/blob/opsys2021/004.2.2read-file-to-heap/004.2.2read-file-to-heap.c

  esempio con puntatori, aritmetica di puntatori: https://replit.com/@MarcoTessarotto/puntatori-esempi

  relazione tra puntatori ed array: vedere anche Kernighan&Ritchie pag. 97-101

  esempio con flags: https://repl.it/@MarcoTessarotto/flags-example

  
  

  • file C lezione 22/3 Text file
• 

  lezione 26/3

  linguaggio C: struct (Kernighan&Ritchie pag. 127-129), typedef (Kernighan&Ritchie pag. 146), enum (Kernighan&Ritchie pag. 39)

  https://replit.com/@MarcoTessarotto/struct-access
  

  
  

  creare un file (Kerrisk pag. 72)
  

  scrivere in un file (Kerrisk pag. 80)
  

  esempio: https://github.com/marcotessarotto/exOpSys/blob/090cd374bc633a79c06e65ae2aca123e2f6a62b5/005.8writefile/writefile.c#L40

  
  

  impostare la dimensione di un file con system call ftruncate()

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/007.01ftruncate/007.01ftruncate.c
  

  
  

  ottenere la dimensione di un file

  https://replit.com/@MarcoTessarotto/get-file-size#main.c
  

  
  

  system call fork(), wait() (Kerrisk pag. 513)

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/005.5fork-wait/fork-wait.c
  

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/005.9execve/execve.c

  
  

  parametri passati a riga di comando:

  https://replit.com/@MarcoTessarotto/command-line-parameters
  

  
  

  • Linux Kernel system calls Page
  • Files PDF document
  • file C lezione 26/3 Text file
• 

  lezione 29/3

  cambiare l'offset di un file aperto  (Kerrisk pag. 81)
  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/007.02lseek/007.02lseek.c

  system call dup()

  fork(): condivisione dei file descriptor tra processo padre e processo figlio; offset dei file aperti condivisi (Kerrisk pag. 517-518)
  

  caso d'uso: incremento di un contatore immagazzinato in un file; incremento concorrente del contatore da parte di più processi (Kerrisk pag. 1117-1118)

  system call flock() per regolare l'accesso concorrente ad un intero file da parte di più processi
  

  
  esempio: programmi concorrenti che incrementano un contatore contenuto in un file comune, senza e con l'uso di flock()

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/053flock/053flock.c

  
  

  esercizi per preparazione della prima provetta:

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi_per_prima_provetta.txt
  

  • file C lezione 29/3 Text file
• 

  lezione 9/4

  come è organizzata la memoria di una variabile di tipo int:  https://replit.com/@MarcoTessarotto/little-endian

  
  

  scrivere un array di int in un file, in formato "binario"

  leggere un array di int da un file, in formato "binario"
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.4read-write-array-binary-format

  
  

  scrivere un array di int in un file, in formato "testo"

  leggere un array di int da un file, in formato "testo"

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.5read-write-array-text-format
  

  
  

  copiare un file

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.3copy-file

  
  

  cercare una sottostringa all'interno di una stringa; cercare tutte le occorrenze di una sottostringa all'interno di una stringa
  

  https://replit.com/@MarcoTessarotto/find-substring

  
  

  'load average' (carico medio di sistema)

  https://replit.com/@MarcoTessarotto/get-load-average

  
  

  leggere/scrivere un singolo char con system call read()/write()

  https://replit.com/@MarcoTessarotto/read-write-char
  

  
  

  numero floating point: limitare il numero di cifre dopo la virgola

  https://replit.com/@MarcoTessarotto/printf-double
  

  
  

  esempio base fork() e wait()

  https://replit.com/@MarcoTessarotto/fork-wait
  

  
  

  esercizi per prima provetta:

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi_per_prima_provetta.txt
  

  https://github.com/marcotessarotto/esercizio-C-2020-03-30/blob/master/specifiche.txt
  

  https://github.com/marcotessarotto/esercizio-C-2020-04-02/blob/master/specifiche.txt

  https://github.com/marcotessarotto/esercizio-C-2020-04-03/blob/master/specifiche.txt

  https://github.com/marcotessarotto/esercizio-C-2020-04-04/blob/master/specifiche.txt

  https://github.com/marcotessarotto/esercizio-C-2020-04-05/blob/master/specifiche.txt
  

  https://github.com/marcotessarotto/esercizio-C-2020-04-06/blob/master/specifiche.txt
  

  https://github.com/marcotessarotto/esercizio-C-2020-04-07/blob/master/specifiche.txt

  
  

  
  

  • esempio - sessione di tutoring File Text file
• 

  lezione 12/4

  provettina di test su moodle2 (15 minuti)

  esercitazioni in vista della provetta

  
  

  soluzione esercizio #4

  https://replit.com/@MarcoTessarotto/esercizio4

  
  

  soluzione dell'esercizio esercizio-C-2020-04-07
  

  https://github.com/marcotessarotto/esercizio-C-2020-04-07/blob/master/src/esercizio-C-2020-04-07.c

  
  

  esempio su come leggere un file di testo, linea per linea, con system call read() e lseek()

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.8read-lines-lseek
  

  
  

  • "prova di quiz" su moodle2

    quiz di prova per fare "pratica" con moodle2
    
• 

  provetta 16/4

  esempi UTILI per la prima provetta:

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.8read-lines-lseek
  

  
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/006.4string-tokenize

  https://replit.com/@MarcoTessarotto/array-di-stringhe

  
  

  ci vediamo in TEAMS alle 15:00;

  la provetta su moodle2 inizia automaticamente alle 15:05 e finisce alle 18:05

  
  

  • prima provetta 2021 Quiz
• 

  lezione 19/4

  elencare le variabile di environment: https://github.com/marcotessarotto/exOpSys/tree/opsys2021/016printenvvars

  comando da shell: env

  eseguire un programma con system call execve: https://github.com/marcotessarotto/exOpSys/tree/opsys2021/005.9execve

  esempio https://github.com/marcotessarotto/exOpSys/tree/opsys2021/005.9.1execve-args

  pipes (Kerrisk, pag. 889-892)

  esempio: https://replit.com/@MarcoTessarotto/wcclone

  
  

  
  

  • file C lezione 19/4 Text file
• 

  lezione 23/4

  esempi con pipes: https://replit.com/@MarcoTessarotto/sample-pipes

  
  

  esempio con pipe utilizzata come tecnica di sincronizzazione tra processi:

  https://replit.com/@MarcoTessarotto/pipes-process-synchronization

  
  

  esempio con pipe non bloccante:

  https://replit.com/@MarcoTessarotto/pipe-nonblocking

  
  

  esercizio per casa:

  https://github.com/marcotessarotto/esercizio-C-20210422-fork-pipe-flock

  ulteriori esercizi sono pubblicati qui: 

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi02.txt
  

  
  

  char (pdf allegato)

  https://replit.com/@MarcoTessarotto/unicode-sample

  
  

  pipes (pdf allegato)

  (esempi riportati sopra)

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/018simple_pipes
  

  
  

  signals (Kerrisk pag. 387) (pdf allegato)

  
  

  
  

  • char - Unicode File PDF document
  • process scheduling File PDF document
  • process virtual memory File PDF document
  • pipes File PDF document
• 

  lezione 26/4

  segnali; segnali standard, programma kill; signal mask, disposizione dei segnali, core dump, signal handler
  

  SIGINT, SIGKILL, SIGSTOP, SIGCONT, SIGUSR1, SIGUSR2, SIGFPE, SIGPIPE, SIGCHLD, SIGSEGV

  esempio https://replit.com/@MarcoTessarotto/enum-signals
  

  esempio https://replit.com/@MarcoTessarotto/signal-tests

  system call signal, pause

  cryptographic hash functions- cenni, verifica dell'integrità di messaggi e file, programma sha256sum, libreria OpenSSL
  

  esempio https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.6sha256
  

  esempio https://github.com/marcotessarotto/exOpSys/tree/opsys2021/004.2.7sha256-fork
  

  
  

  • funzione hash crittografica File PDF document
  • signals File PDF document
  • esercizio C 26/4 File Text file
• 

  lezione 30/4

  monitoraggio di eventi relativi a file (Kerrisk, cap 19, pag. 375-385)
  

  system call inotify_init, inotify_add_watch, inotify_rm_watch
  

  struct inotify_event
  

  
  

  Memory mappings (Kerrisk cap 49, pag. 1017-1027)

  file mapping, anonymous mapping

  private mapping, shared mapping

  tipologie di mapping: private file mapping, private anonymous mapping, shared file mapping, shared anonymous mapping

  system call mmap
  

  PROT_NONE, PROT_READ, PROT_WRITE, PROT_EXEC

  MAP_PRIVATE, MAP_SHARED

  vincoli di allineamento per offset

  system call munmap

  file mappings: private file mapping, shared file mappings (pag. 1024-1027)
  

  
  

  • file C lezione 30/4 - inotify Text file
  • file C lezione 30/4 - mmap Text file
• 

  lezione 3/5

  Pthreads (Kerrisk, cap 29 pag 617-627)

  pthread_create, pthread_join, pthread_exit
  

  thread id

  passaggio di parametri alla creazione di un nuovo thread

  restituzione di risultati da parte di un thread

  
  

  • file C lezione 3/5 Text file
• 

  lezione 7/5

  system call alarm

  esempio https://github.com/marcotessarotto/exOpSys/tree/opsys2021/055alarm

  threads e signals (Kerrisk cap. 33 pag. 681-689), pthread_kill, thread implementation models (M:1, 1:1, M:N), threads e execve, threads e fork
  

  thread synchronization (Kerrisk. cap 30 pag 631-636)

  proteggere l'accesso a variabili condivise con mutex

  mutex allocato staticamente

  lock e unlock di mutex (pthread_mutex_lock, pthread_mutex_unlock)

  posix semaphores (Kerrisk cap. 53 pag. 1089-1097)
  

  
  

  Little book of semaphores: cap 3 Basic synchronization patterns, pag. 11-15

  
  

  esempio 1: utilizzo di system call alarm

  esempio 2: inviare un segnale ad un pthread

  esempio 3: pthread mutex

  esempio 4: named semaphore

  esempio 5: uso di un semaforo per segnalazione tra processi
  

  • risultati prima provetta File PDF document
  • lezione C 7/5 parte 1 File Text file
  • lezione C 7/5 parte 2 File Text file
  • lezione C 7/5 parte 3 File Text file
  • lezione C 7/5 parte 4 File Text file
  • lezione C 7/5 parte 5 File Text file
• 

  lezione 10/5

  ripetizione named semaphores
  

  unnamed semaphores (Kerrisk cap. 53, pag. 1099-1103)

  funzioni sem_init(), sem_destroy()
  

  semafori POSIX vs Pthreads mutex (Kerrisk pag. 1104)

  sviluppo in aula dell'esempio 006.3signals4ipc (vedere slide per le specifiche)
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/006.3signals4ipc

  sviluppo alternativo dell'esempio 006.3signals4ipc usando pipes e threads
  

  
  

  
  

  • Understanding Linux Process States File PDF document
  • esempio IPC File PDF document
  • lezione C 10/5 parte 1 File Text file
  • lezione C 10/5 parte 2 File Text file
  • lezione C 10/5 parte 3 File Text file
• 

  lezione 14/5

  esercizi per la seconda provetta, li trovate qui:

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi02.txt
  

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi03.txt
  

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi04.txt
  

  
  

  esempio:
  

  il processo padre crea N processi figli e ne monitora il loro stato di esecuzione fino a quando diventano tutti zombie

  https://replit.com/@MarcoTessarotto/fork-monitor-process-status

  
  

  • esercizi per seconda provetta File Text file
  • materiale File PDF document
  • esercizio C04 File Text file
• 

  lezione 17/5

  
  

  nota per soluzione esercizio B03:

  ogni processo ha:
  process ID : PID
  parent process ID: PPID
  ogni processo fa parte di una "sessione", identificata da "session ID"
  ogni processo fa parte di una "gruppo di processi", identificata da "process group ID"
  
  quando la shell rileva Ctrl-C, manda SIGINT a tutti i processi della "sessione".
  per evitare questo (cioè per evitare che il processo figlio riceva Ctrl-C), occorre "staccare" il processo figlio dalla sessione del processo padre.
  

  Il "distacco" avviene creando una nuova sessione per il processo figlio, con la system call setsid.
  
  

  
  

  • crea file con array int Text file
  • quicksort.c File Text file
  • quicksort.h File Text file
  • prova.dat File application/octet-stream
  • esercizio D01 - versione A File Text file
  • esercizio D02 File Text file
  • esercizio B03 File Text file
• 

  lezione 21/5

  esercitazioni
  

  • esercizio B04 File Text file
  • esercizio B05 File Text file
  • esercizio B06 File Text file
  • esercizio B07 File Text file
  • esercizio B11 File Text file
  • esercizio D06 File Text file
  • esempio C 21/5 File Text file
  • esercizio C02 File Text file
  • esercizio C03 File Text file
• 

  lezione 24/5

  semaforo con nome, usato da threads di uno stesso processo
  

  https://github.com/marcotessarotto/exOpSys/tree/opsys2021/031.3named_sem_thread
  

  
  

  esercitazioni:

  esercizi D07, D08, D09, D10, D11, D12, D13

  https://github.com/marcotessarotto/exOpSys/blob/opsys2021/docs/esercizi04.txt

  
  

  • esercizio D07 File Text file
  • esercizio D08 File Text file
  • esercizio D09 File Text file
  • esercizio D10 File Text file
  • esercizio D11 File Text file
  • esercizio D12 File Text file
  • esercizio D13 File Text file
• 

  provetta 28/5

  la soluzione dell'esercizio di programmazione in C  va comunque "postata" nella provetta su moodle2 (se non viene inviata, la provetta non verrà valutata).

  una volta conclusa la provetta, averete tempo fino a tutto il 2 giugno per inviare via email la correzione minimale alla vostra soluzione.

  
  

  i partecipanti alla provetta si devono collegare in TEAMS alle ore 15:00

  io sarò in presenza in aula; la provetta si può effettuare da remoto o in presenza. (nell'aula ci sono poche prese di corrente, però).
  

  la provetta su moodle2 inizia automaticamente alle 15:05 e finisce alle 18:05

  
  

  i risultati della seconda provetta verranno pubblicati qui entro il giorno 4 giugno (giorno più, giorno meno).

  
  

  • seconda provetta Quiz
  • RISULTATI PROVETTE File PDF document