[T07] Esercitazione del 12 aprile 2019

Istruzioni per l’esercitazione:

• Aprite il form di consegna in un browser e loggatevi con le vostre credenziali uniroma1.
• Scaricate e decomprimete sulla scrivania il codice dell’esercitazione. Vi sarà una sotto-directory separata per ciascun esercizio di programmazione.
  Non modificate in alcun modo i programmi di test *_main.c.
• Rinominare la directory chiamandola cognome.nome. Sulle postazioni del laboratorio sarà /home/biar/Desktop/cognome.nome/.
• È possibile consultare appunti/libri e il materiale didattico online.
• Per rispondere alle domande create nella vostra directory un file di nome quiz-matricola.txt dove matricola è la vostra matricola. Il file deve contenere una risposta per linea. Nella linea i-esima riportate la risposta della domanda i-esima, specificando soltanto la lettera della risposta (es.: se la risposta alla terza domanda è B, scrivete B nella terza linea del file). Occorre rispondere a tutte le domande.
• Finiti gli esercizi, e non più tardi della fine della lezione:
  • zippate la directory di lavoro in cognome.nome.zip (zip -r cognome.nome.zip cognome.nome/).
• Per consegnare:
  • inserite nel form di consegna come autovalutazione il punteggio di ciascuno dei test forniti (inserite zero se l’esercizio non è stato svolto, non compila, o dà errore di esecuzione).
  • fate upload del file cognome.nome.zip.
  • importante: fate logout dal vostro account Google!
• Prima di uscire:
  • eliminate dal desktop la directory creata (rm -rf cognome.nome).
  • firmate il foglio presenze.
  • rimettete a posto eventuali sedie prese all’ingresso dell’aula!

Per maggiori informazioni fate riferimento al regolamento delle esercitazioni.

Esercizio 1 (Parsing di una linea da stdin in C)

Questo è un esercizio di mera conoscenza del linguaggio C. Il canale stdin (di tipo FILE*) modella in C la sorgente di caratteri ASCII che proviene come input, salvo diversamente specificato, dal terminale. Si chiede di scrivere nel file E1-get-cmd-line/e1.c una funzione void get_cmd_line(char* argv[]); che legge la prossima linea di testo da stdin, estrae ciascun token (sequenza consecutiva di caratteri, esclusi spazi, tab \t e ritorni a capo \n) e produce un array di al più n<=MAX_TOKENS=64 stringhe come segue:

• le stringhe prodotte (argv[0]…argv[n-1]) devono essere allocate dinamicamente con malloc;
• la stringa in ultima posizione (argv[n]) deve essere NULL, fungendo da “terminatore”.

Assumere che la linea di testo letta da stdin contenga al più 1024 caratteri compreso il ritorno a capo \n.

Esempio: se la linea letta da stdin è rm -f .DS_store, la chiamata get_cmd_line(argv) restituisce in argv l’array di stringhe {"rm", "-f". ".DS_Store", NULL}.

Suggerimenti. Basandosi sul comando man (oppure la documentazione online cercando funzione opengroup) usare:

• la funzione fgets per leggere una linea da stdio di al più MAX_LINE=1024 caratteri terminata dal ritorno a capo \n;
• la funzione strtok per tokenizzare la linea una volta letta da stdio.

L’array di stringhe prodotto deve essere deallocabile con la semplice funzione:

void free_args(char* argv[]) {
    while (*argv) free(argv++);
}

Usare il main di prova nella directory di lavoro E1-parse-line compilando con `gcc e1_main.c e1.c -o e1´.

Esercizio 2 (Scrittura di una semplice shell dei comandi Linux)

[Svolgere questo esercizio solo dopo aver svolto l’Esercizio 1]

Una shell è un programma che chiede all’utente di eseguire altri programmmi sotto forma di nuovi processi, passandogli eventuali argomenti specificati dall’utente. Una shell fornisce normalmente un prompt, vale a dire un breve testo (es. $, >, ecc.) che segnala all’utente che la shell è in attesa di ricevere comandi.

Si chiede di scrivere nel file E2-shell/e2.c una semplice shell sotto forma di una funzione int do_shell(const char* prompt); che prende come parametro la stringa di prompt e si comporta come segue;

1. stampa il prompt;
2. attende che l’utente inserisca in stdin un comando seguito dai suoi eventuali argomenti (es: ls -l, dove ls è il comando e -l è il suo unico argomento). Per ottenere comando e argomenti da stdin usare il risultato dell’esercizio 2;
3. se il comando è vuoto (NULL) tornare al punto 1;
4. se il comando è quit terminare con successo la shell;
5. creare con fork un nuovo processo che esegua il comando con gli argomenti dati usando execvp;
6. se il comando si riferisce a un programma inesistente riportare l’errore unknown command seguito dal nome del comando e tornare al punto 1;
7. attendere con wait la terminazione del processo e tornare al punto 1.

Per valutare il corretto funzionamento della shell, effettuare i seguenti quattro test:

1. inserire ls -l e verificare che listi la directory corrente
2. inserire echo hello e verificare che venga stampato hello
3. inserire sergente hartman e verificare che venga stampato un messaggio di errore
4. inserire quite verificare la terminazione della shell

Il risultatao di ogni system call deve essere controllato e in caso di errore segnalato con perror e terminazione EXIT_FAILURE.

Esercizio 3 (Domande)

Rispondi alle seguenti domande, tenendo conto che una risposta corretta vale 1 punti, mentre una risposta errata vale 0 punti.

Domanda 1 Quale tra le seguenti affermazioni è FALSA?

• A. Alcune istruzioni x86 non possono essere eseguite quando la CPU è in “user mode”
• B. All’interno del kernel le system call sono identificate da un numero
• C. L’istruzione int genera un interrupt sincrono che passa il controllo al kernel
• D. Funzioni wrapper di system call come read, write, fork e _exit vengono eseguite interamente in “kernel mode”
• E. Le system call eseguono codice del kernel

Domanda 2 Quale tra le seguenti affermazioni è VERA?

• A. POSIX è un sistema operativo
• B. La X di POSIX è un riferimento a Linux.
• C. La funzione printf non fa parte dello standard POSIX, ma della libreria standard C (libc)
• D. POSIX definisce solo l’interfaccia tra programmi utente e kernel basata su system call
• E. Nessuna delle precedenti

Domanda 3 Quale tra le seguenti affermazioni è VERA?

• A. Una “trap” è un tipo di interruzione asincrona
• B. Una “trap” viene generata, ad esempio, quando si muove il mouse
• C. L’istruzione int può essere usata esclusivamente per invocare le system call
• D. L’interrupt generata dal timer è asincrona
• E. Nessuna delle precedenti

Domanda 4 Quale tra le seguenti affermazioni è VERA?

• A. Una system call si invoca con l’istruzione int seguita da un numero che identifica la system call da eseguire
• B. Il valore di ritorno di una system call viene scritto nel registro EAX.
• C. Un programma utente può passare i parametri ad una system call anche copiandoli sullo stack del kernel
• D. Se una system call viene invocata da un programma utente, viene eseguita interamente in user mode
• E. Nessuna delle precedenti

Domanda 5 Quale tra le seguenti affermazioni è VERA?

• A. perror non è una system call, ma un wrapper che invoca una system call
• B. perror stampa un messaggio di errore che dipende dal valore contenuto nella variabile errno
• C. errno è una variabile di tipo char* che contiene la stringa identificativa dell’errore
• D. La variabile errno viene restituita come valore di ritorno dalle funzioni della libreria standard C in caso di errore
• E. Nessuna delle precedenti

Domanda 6 Relativamente al seguente codice C (supponendo che la fork non generi un errore), quale tra le seguenti affermazioni è VERA?

• A. Viene stampato “Padre: 1” e poi “Figlio: 2”
• B. Viene stampato “Figlio: 2” e poi “Padre: 1”
• C. Viene stampato “Figlio: 1” e poi “Padre: 1”
• D. Viene stampato “Figlio: 1” e poi “Padre: 2”
• E. Viene stampato “Figlio: 2” e poi “Padre: 2”
• F. L’ordine delle stampe è impredicibile, poiché dipende dallo scheduler
• G. Nessuna delle precedenti

Domanda 7 Relativamente al seguente codice C (supponendo che la fork non generi un errore), qual è l’output atteso?

• A. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=20”, “Figlio 3: x=30”, “Padre: x=40”
• B. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=10”, “Figlio 3: x=10”, “Padre: x=30”
• C. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=10”, “Figlio 3: x=10”, “Padre: x=40”
• D. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=20”, “Figlio 3: x=30”, “Padre: x=30”
• E. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=30”, “Figlio 3: x=60”, “Padre: x=100”
• F. L’ordine delle stampe è impredicibile, poiché dipende dallo scheduler
• G. Nessuna delle precedenti

Domanda 8 Relativamente al seguente codice C (supponendo che la execv non generi un errore), qual è l’output atteso?

• A. Nell’ordine (una per linea): “--- started ---”, “Hello”, “NULL, “--- finished ---”
• B. Nell’ordine (una per linea): “--- started ---”, “Hello”, “--- finished ---”
• C. Nell’ordine (una per linea): “--- started ---”, “Hello”
• D. Nell’ordine (una per linea): “--- started ---”, “--- finished ---”
• E. L’ordine delle stampe è impredicibile, poiché dipende dallo scheduler
• F. Nessuna delle precedenti

Soluzioni

Esercizio 1 (Parsing di una linea da stdin in C)

e1.c

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "e1.h"

char* dup_string(const char* in) {
    size_t n = strlen(in);
    char* out = malloc(n + 1);
    strcpy(out, in);
    return out;
}

void get_cmd_line(char* argv[MAX_TOKENS]) {
    int argc = 0;
    char line[MAX_LINE];
    fgets(line, MAX_LINE, stdin);
    char* token = strtok(line, " \t\n");
    argc = 0;
    while (argc < MAX_TOKENS && token != NULL) {
        argv[argc++] = dup_string(token);
        token = strtok(NULL, " \t\n");
    }
    argv[argc] = NULL;
}

Esercizio 2 (Scrittura di una semplice shell dei comandi Linux)

e2.c

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include "../e2.h"

#define MAX_LINE    1024
#define MAX_TOKENS  64

void do_cmd(char* argv[MAX_TOKENS]) {
    int res;
    pid_t pid = fork();

    if (pid == -1) {
        perror("fork error");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        res = execvp(argv[0], argv);
        if (res == -1) {
            printf("unkwnown command %s\n", argv[0]);
            _exit(EXIT_FAILURE);
        }
    }

    res = wait(NULL);
    if (pid == -1) {
        perror("wait error");
        exit(EXIT_FAILURE);
    }
}

char* dup_string(const char* in) {
    size_t n = strlen(in);
    char* out = malloc(n + 1);
    strcpy(out, in);
    return out;
}

void get_cmd_line(char* argv[MAX_TOKENS]) {
    int argc = 0;
    char line[MAX_LINE];
    fgets(line, MAX_LINE, stdin);
    char* token = strtok(line, " \t\n");
    argc = 0;
    while (argc < MAX_TOKENS && token != NULL) {
        argv[argc++] = dup_string(token);
        token = strtok(NULL, " \t\n");
    }
    argv[argc] = NULL;
}

int do_shell(const char* prompt){
    for (;;) {
        printf("%s", prompt);
        char* argv[MAX_TOKENS];
        get_cmd_line(argv);
        if (argv[0] == NULL) continue;
        if (strcmp(argv[0], "quit") == 0) break;
        do_cmd(argv);
    }
    return EXIT_SUCCESS;
}

Esercizio 3 (Domande)

1. D. Funzioni wrapper di system call come read, write, fork e _exit vengono eseguite interamente in “kernel mode”
2. E. Nessuna delle precedenti
3. D. L’interrupt generata dal timer è asincrona
4. B. Il valore di ritorno di una system call viene scritto nel registro EAX.
5. B. perror stampa un messaggio di errore che dipende dal valore contenuto nella variabile errno
6. C. Viene stampato “Figlio: 1” e poi “Padre: 1”
7. A. Nell’ordine (una per linea): “Figlio 1: x=10”, “Figlio 2: x=20”, “Figlio 3: x=30”, “Padre: x=40”
8. C. Nell’ordine (una per linea): “--- started ---”, “Hello”