080IN - SISTEMI OPERATIVI 2020

Section outline

• Select section General

  Collapse Expand

  General

  Collapse all Expand all

  • Select activity Annunci

    

    Annunci Forum
  • Select activity Libri consigliati

    

    Libri consigliati Page
  • Select activity Esercitazioni di programmazione in C

    

    Esercitazioni di programmazione in C Page
  • Select activity Programma del corso

    

    Programma del corso Page
  • Select activity come operare in Linux Debian ed Eclipse - brevi video tutorial

    

    come operare in Linux Debian ed Eclipse - brevi video tutorial Page
  • Select activity Gruppo TEAMS da usare per le lezioni

    

    Gruppo TEAMS da usare per le lezioni Page
  • Select activity articoli interessanti/utili

    

    articoli interessanti/utili Page
• Select section lezione 1/3/2021

  Collapse Expand

  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

  • Select activity Informazioni sul corso

    

    Informazioni sul corso File PDF
  • Select activity info su VM per esercitazioni

    

    info su VM per esercitazioni Page
  • Select activity Introduzione

    

    Introduzione File PDF
• Select section lezione 5/3

  Collapse Expand

  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

  
  

  
  

  • Select activity Kernel tasks

    

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

    

    modalità utente e modalità kernel, spazio utente e spazio kernel File PDF
• Select section lezione 8/3

  Collapse Expand

  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

  
  

  • Select activity Fasi del compilatore gcc

    

    Fasi del compilatore gcc File PDF
  • Select activity file C lezione 8/3

    

    file C lezione 8/3 C
• Select section lezione 12/3

  Collapse Expand

  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
  

  
  

  
  

  • Select activity campo d'azione (scope)

    

    campo d'azione (scope) File PDF
  • Select activity file C lezione 12/3

    

    file C lezione 12/3 C
  • Select activity esempi comandi shell

    

    esempi comandi shell Page
• Select section lezione 15/3

  Collapse Expand

  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
  

  • Select activity file C lezione 15/3

    

    file C lezione 15/3 C
• Select section lezione 19/3

  Collapse Expand

  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
  

  
  

  • Select activity esercizio per casa (da svolgere se possibile prima della lezione del 19/3)

    

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

    

    file C lezione 19/3 C
• Select section lezione 22/3

  Collapse Expand

  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

  
  

  • Select activity file C lezione 22/3

    

    file C lezione 22/3 C
• Select section lezione 26/3

  Collapse Expand

  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
  

  
  

  • Select activity Linux Kernel system calls

    

    Linux Kernel system calls Page
  • Select activity Files

    

    Files PDF
  • Select activity file C lezione 26/3

    

    file C lezione 26/3 C
• Select section lezione 29/3

  Collapse Expand

  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
  

  • Select activity file C lezione 29/3

    

    file C lezione 29/3 C
• Select section lezione 9/4

  Collapse Expand

  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

  
  

  
  

  • Select activity esempio - sessione di tutoring

    

    esempio - sessione di tutoring File C
• Select section lezione 12/4

  Collapse Expand

  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
  

  
  

  • Select activity "prova di quiz" su moodle2

    

    "prova di quiz" su moodle2

    quiz di prova per fare "pratica" con moodle2
    
• Select section provetta 16/4

  Collapse Expand

  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

  
  

  • Select activity prima provetta 2021

    

    prima provetta 2021 Quiz
• Select section lezione 19/4

  Collapse Expand

  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

  
  

  
  

  • Select activity file C lezione 19/4

    

    file C lezione 19/4 C
• Select section lezione 23/4

  Collapse Expand

  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)

  
  

  
  

  • Select activity char - Unicode

    

    char - Unicode File PDF
  • Select activity process scheduling

    

    process scheduling File PDF
  • Select activity process virtual memory

    

    process virtual memory File PDF
  • Select activity pipes

    

    pipes File PDF
• Select section lezione 26/4

  Collapse Expand

  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
  

  
  

  • Select activity funzione hash crittografica

    

    funzione hash crittografica File PDF
  • Select activity signals

    

    signals File PDF
  • Select activity esercizio C 26/4

    

    esercizio C 26/4 File C
• Select section lezione 30/4

  Collapse Expand

  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)
  

  
  

  • Select activity file C lezione 30/4 - inotify

    

    file C lezione 30/4 - inotify C
  • Select activity file C lezione 30/4 - mmap

    

    file C lezione 30/4 - mmap C
• Select section lezione 3/5

  Collapse Expand

  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

  
  

  • Select activity file C lezione 3/5

    

    file C lezione 3/5 C
• Select section lezione 7/5

  Collapse Expand

  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
  

  • Select activity risultati prima provetta

    

    risultati prima provetta File PDF
  • Select activity lezione C 7/5 parte 1

    

    lezione C 7/5 parte 1 File C
  • Select activity lezione C 7/5 parte 2

    

    lezione C 7/5 parte 2 File C
  • Select activity lezione C 7/5 parte 3

    

    lezione C 7/5 parte 3 File C
  • Select activity lezione C 7/5 parte 4

    

    lezione C 7/5 parte 4 File C
  • Select activity lezione C 7/5 parte 5

    

    lezione C 7/5 parte 5 File C
• Select section lezione 10/5

  Collapse Expand

  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
  

  
  

  
  

  • Select activity Understanding Linux Process States

    

    Understanding Linux Process States File PDF
  • Select activity esempio IPC

    

    esempio IPC File PDF
  • Select activity lezione C 10/5 parte 1

    

    lezione C 10/5 parte 1 File C
  • Select activity lezione C 10/5 parte 2

    

    lezione C 10/5 parte 2 File C
  • Select activity lezione C 10/5 parte 3

    

    lezione C 10/5 parte 3 File C
• Select section lezione 14/5

  Collapse Expand

  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

  
  

  • Select activity esercizi per seconda provetta

    

    esercizi per seconda provetta File TXT
  • Select activity materiale

    

    materiale File PDF
  • Select activity esercizio C04

    

    esercizio C04 File C
• Select section lezione 17/5

  Collapse Expand

  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.
  
  

  
  

  • Select activity crea file con array int

    

    crea file con array int C
  • Select activity quicksort.c

    

    quicksort.c File C
  • Select activity quicksort.h

    

    quicksort.h File H
  • Select activity prova.dat

    

    prova.dat File DAT
  • Select activity esercizio D01 - versione A

    

    esercizio D01 - versione A File C
  • Select activity esercizio D02

    

    esercizio D02 File C
  • Select activity esercizio B03

    

    esercizio B03 File C
• Select section lezione 21/5

  Collapse Expand

  lezione 21/5

  esercitazioni
  

  • Select activity esercizio B04

    

    esercizio B04 File C
  • Select activity esercizio B05

    

    esercizio B05 File C
  • Select activity esercizio B06

    

    esercizio B06 File C
  • Select activity esercizio B07

    

    esercizio B07 File C
  • Select activity esercizio B11

    

    esercizio B11 File C
  • Select activity esercizio D06

    

    esercizio D06 File C
  • Select activity esempio C 21/5

    

    esempio C 21/5 File C
  • Select activity esercizio C02

    

    esercizio C02 File C
  • Select activity esercizio C03

    

    esercizio C03 File C
• Select section lezione 24/5

  Collapse Expand

  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

  
  

  • Select activity esercizio D07

    

    esercizio D07 File C
  • Select activity esercizio D08

    

    esercizio D08 File C
  • Select activity esercizio D09

    

    esercizio D09 File C
  • Select activity esercizio D10

    

    esercizio D10 File C
  • Select activity esercizio D11

    

    esercizio D11 File C
  • Select activity esercizio D12

    

    esercizio D12 File C
  • Select activity esercizio D13

    

    esercizio D13 File C
• Select section provetta 28/5

  Collapse Expand

  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).

  
  

  • Select activity seconda provetta

    

    seconda provetta Quiz
  • Select activity RISULTATI PROVETTE

    

    RISULTATI PROVETTE File PDF