Totò, Peppino e il Watchdog – come scrivere un Watchdog in C, C++ e Go – pt.1

Totò, Peppino e il Watchdog
come scrivere un Watchdog in C, C++ e Go – pt.1

Peppino: Che.
Totò: Che! Scusate se sono poche.
Peppino: Che…
Totò: Che, scusate se sono poche, ma settecentomila lire, punto e virgola, noi, noi ci fanno specie che quest’anno, una parola, quest’anno c’è stato una grande moria delle vacche, come voi ben sapete! Punto! Due punti!! Ma si, fai vedere che abbondiamo. Abbondandis in abbondandum. Questa moneta servono, questa moneta servono, questa moneta servono che voi vi consolate. Scrivi presto!
Peppino: Con insalata.
Totò: Che voi vi consolate!
Peppino: Ah! Avevo capito con l’insalata.

L’argomento della mitica e famosissima lettera di Totò e Peppino era, per loro, molto importante, era una questione familiare di un certo rilievo. Ed anche noi, con questo articolo, tratteremo un argomento di un certo peso, anche se non familiare: sarà un argomento industriale. Ebbene si, oggi parleremo di un oggetto per molti misterioso, il Watchdog.

…ma si, fai vedere che abbondiamo. Watchdog in abbondandum…

Una applicazione industriale che si rispetti (specialmente se embedded) include sempre un Watchdog a più livelli. vediamoli:

• primo livello: Watchdog Hardware. Questo non può mancare: in presenza di malfunzionamenti che provocano il blocco o lo stallo della applicazione si può forzare il reset e riavvio del sistema.
• secondo livello: Watchdog Software dei processi. Si monitorizzano i vari processi che compongono l’applicazione (su Linux, ad esempio, si può fare con Monit) e si effettuano eventuali attività di recupero in caso di necessità (restart di quelli “morti”, ad esempio).
• terzo livello: Watchdog Software dei thread. Se l’applicazione da monitorare è multithread si controlla che tutti i thread funzionino correttamente, ossia si controlla che nessuno di essi rimanga bloccato in attesa di qualche evento che non arriva mai, oppure che nessun thread lavori a velocità molto più bassa di quella prevista e/o ammessa, ecc. e, in caso di problemi, si agisce opportunamente (come minimo alzando degli allarmi per segnalare la situazione).

Perché ho affermato che il Watchdog è un oggetto per molti misterioso? Perché, anche se quasi tutte le applicazioni industriali usano quello di primo livello, alcune omettono quello di secondo e moltissime (ahimè) non usano quello di terzo livello (e questo, secondo me, è molto grave). Ma niente paura! vedremo in questo post ben tre semplici implementazioni di un Watchdog di terzo livello: in C, C++ e Go, così dopo avrete solo l’imbarazzo della scelta su quale usare.

Come funziona un Watchdog di terzo livello? Il modus operandi è abbastanza semplice, e include il rispetto di poche direttive di base:

• i thread da monitorare devono avere una struttura “classica”, e cioè quella di una funzione “che fa cose” in loop infinito con un opportuno intervallo di sleep tra un ciclo e l’altro.
• i thread da monitorare devono registrarsi al Watchdog prima di avviare il loop infinito.
• nessuna delle cose che il thread fa nel loop deve essere bloccante: ad esempio se si legge da un socket questo deve essere stato aperto in modo nonblocking.
• ad ogni giro del loop (appena prima della sleep) si deve aggiornare una variabile di monitoring che verrà letta dal Watchdog vero e proprio.

Viste le direttive di base si può già dedurre che cosa è il Watchdog: è una funzione che esegue un loop infinito in cui testa le variabili di monitoring dei thread che si sono registrati. Anche questo loop avrà una sleep che, al contrario di quella dei thread che, tipicamente, è piccola (dell’ordine dei millisecondi) sarà grande (dell’ordine dei secondi), perché normalmente è inutile sorvegliare i thread con frequenze altissime (ma ci sono, ovviamente, delle eccezioni). Se il Watchdog si accorge che un thread non risponde (ossia: non rinfresca la variabile di stato), prenderà gli opportuni provvedimenti che dipendono dalla natura dell’applicazione (alzare allarmi, effettuare una procedura di recovery, ecc.).

Scrivere il codice di un Watchdog è relativamente semplice ma, ovviamente, si può complicare a piacere. La versione che vi proporrò, ad esempio, controlla tutti i thread con una cadenza fissa, impostata da un valore in secondi che si passa al Watchdog. Quindi un primo livello di complicazione potrebbe essere quello di avere intervalli di sorveglianza indipendenti e impostati dal thread nella fase di registrazione: in questa maniera un unico Watchdog potrebbe sorvegliare velocemente alcuni thread e lentamente altri. E così via, si possono aggiungere e/o perfezionare prestazioni, ma il modello base che vedremo è, sicuramente, una buona base di lavoro per usi reali.

Cominceremo con la versione C (qualcuno lo dubitava?) e, prima di mostrare il Watchdog, vedremo un esempio d’uso con test incorporato: ho scritto un main() che avvia due thread passandogli un pointer al Watchdog. I thread non fanno nulla ma, ogni tanto, smettono di dare segni di vita, permettendoci di osservare realmente cosa fa il nostro Watchdog in questi casi. Vai col codice!

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

// prototipi locali
void* myThreadA(void *arg);
void* myThreadB(void *arg);

// funzione main()
int main(int argc, char* argv[])
{
    int error;

    // init del watchdog
    Watchdog watchdog;
    if (setWatchdog(&watchdog) != 0) {
        printf("%s: non posso usare il watchdog\n", argv[0]);
        return EXIT_FAILURE;
    }

    // avvio thread A
    pthread_t tid_A;
    if ((error = pthread_create(&tid_A, NULL, &myThreadA, (void *)&watchdog)) != 0) {
        printf("%s: non posso creare il thread A (%s)\n", argv[0], strerror(error));
        return EXIT_FAILURE;
    }

    // avvio thread B
    pthread_t tid_B;
    if ((error = pthread_create(&tid_B, NULL, &myThreadB, (void *)&watchdog)) != 0) {
        printf("%s: non posso creare il thread A (%s)\n", argv[0], strerror(error));
        return EXIT_FAILURE;
    }

    // avvio check watchdog (contiene un loop infinito)
    chkWatchdog(&watchdog, 1);  // sleep interna di 1 sec

    // attesa terminazione thread A
    if ((error = pthread_join(tid_A, NULL)) != 0) {
        printf("%s: non posso unire il thread A (%s)\n", argv[0], strerror(error));
        return EXIT_FAILURE;
    }

    // attesa terminazione thread B
    if ((error = pthread_join(tid_B, NULL)) != 0) {
        printf("%s: non posso unire il thread B (%s)\n", argv[0], strerror(error));
        return EXIT_FAILURE;
    }

    // esce con Ok
    printf("%s: thread terminati\n", argv[0]);
    return EXIT_SUCCESS;
}

// thread routine A
void* myThreadA(void *arg)
{
    // ottengo i dati del thread con un cast (tdata*) di (void*) arg
    Watchdog *watchdog = (Watchdog *)arg;

    // aggiunge un watch per questo thread
    int watch_id;
    if ((watch_id = addWatch(watchdog, "myThreadA")) < 0) {
        // errore: non posso usare il watch
        printf("%s: non posso usare il watch: fermo il thread myThreadA", __func__);
        return NULL;
    }

    // loop del thread
    printf("thread A partito\n");
    int i = 0;
    for (;;) {
        // il thread fa cose...

        // ...

        // TEST: ogni 5 secondi simulo un blocco del thread
        if (i++ == 500) {
            printf("thread A: sleep di 5 sec\n");
            i = 0;
            sleep(5);
        }

        // rinfresco il watch del thread
        setWatch(watchdog, watch_id);

        // sleep del thread (10 ms)
        usleep(10000);
    }

    // il thread esce
    printf("thread A finito\n");
    return NULL;
}

// thread routine B
void* myThreadB(void *arg)
{
    // ottengo i dati del thread con un cast (tdata*) di (void*) arg
    Watchdog *watchdog = (Watchdog *)arg;

    // aggiunge un watch per questo thread
    int watch_id;
    if ((watch_id = addWatch(watchdog, "myThreadB")) < 0) {
        // errore: non posso usare il watch
        printf("%s: non posso usare il watch: fermo il thread myThreadA", __func__);
        return NULL;
    }

    // loop del thread
    printf("thread B partito\n");
    int i = 0;
    for (;;) {
        // il thread fa cose...

        // ...

        // TEST: ogni 15 secondi simulo un blocco del thread
        if (i++ == 1500) {
            printf("thread B: sleep di 5 sec\n");
            i = 0;
            sleep(5);
        }

        // rinfresco il watch del thread
        setWatch(watchdog, watch_id);

        // sleep del thread (10 ms)
        usleep(10000);
    }

    // il thread esce
    printf("thread B finito\n");
    return NULL;
}

È abbastanza semplice, no? Grazie ai commenti credo che sia sufficientemente auto-esplicativo, e non credo che ci sia molto da aggiungere: il main() inizializza il Watchdog, avvia i due thread e avvia la funzione chkWatchdog() che è il cuore del nostro sistema. I due thread si registrano ed entrano in un loop infinito che non fa nulla, a parte (come detto sopra) simulare un blocco ogni tanto per testare il corretto funzionamento del Watchdog.

E adesso vediamo l’header, watchdog.h:

#ifndef WATCHDOG_H
#define WATCHDOG_H

#include <pthread.h>
#include <stdbool.h>

#define MAX_WATCH   32  // numero massimo di watch in uso

// typedef del tipo Watch
typedef struct {
    int  id;            // identificatore del watch (numero)
    char name[16];      // identificatore del watch (stringa)
    bool active;        // flag di attività (true=attivo)
} Watch;

// typedef del tipo Watchdog
typedef struct {
    Watch           *watch_list[MAX_WATCH]; // lista di watch
    pthread_mutex_t watch_mutex;            // mutex per operazioni add/set/check
} Watchdog;

// prototipi globali
int  setWatchdog(Watchdog *watchdog);
void delWatchdog(Watchdog *watchdog);
void chkWatchdog(Watchdog *watchdog, unsigned int wait_sec);
int  addWatch(Watchdog *watchdog, char *name);
void delWatch(Watchdog *watchdog, int id);
void setWatch(Watchdog *watchdog, int id);

#endif /* WATCHDOG_H */

Come si nota ho definito due tipi, uno che descrive un punto di sorveglianza elementare (il tipo Watch) e uno che descrive il Watchdog vero e proprio (il tipo Watchdog) che è, alla fin fine, solo una lista di watch protetta da un mutex (ebbene si, stiamo parlando di multithreading, quindi un mutex ci voleva proprio).

Ed ora siamo, finalmente, pronti ad esaminare il codice contenuto in watchdog.c:

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

// setWatchdog - set iniziale del Watchdog
int setWatchdog(
    Watchdog *watchdog)     // watchdog pointer
{
    // init mutex
    int error;
    if ((error = pthread_mutex_init(&watchdog->watch_mutex, NULL)) != 0) {
        // errore fatale: fermo la inizializzazione
        printf("%s: non posso creare il mutex (%s)\n", __func__,  strerror(error));
        return -1;
    }

    // reset pointers watchdog
    for (int i = 0; i < MAX_WATCH; i++) {
        // set pointer to NULL
        watchdog->watch_list[i] = NULL;
    }

    // set watchdog Ok
    return 0;
}

// delWatchdog - elimina tutti i watch
void delWatchdog(
    Watchdog *watchdog)     // watchdog pointer
{
    // rilascia le risorse allocate
    for (int i = 0; i < MAX_WATCH; i++) {
        // check se il watch è disponibile
        if (watchdog->watch_list[i] != NULL) {
            // cancella un watch
            delWatch(watchdog, i);
        }
    }
}

// chkWatchdog - check di tutti i watch nella lista watch
void chkWatchdog(
    Watchdog     *watchdog, // watchdog pointer
    unsigned int wait_sec)  // sleep del loop interno in secondi
{
    // loop infinito di check watch
    for (;;) {
        // lock della funzione per uso thread-safe
        pthread_mutex_lock(&watchdog->watch_mutex);

        // check di tutti i watch nella lista watch
        for (int i = 0; i < MAX_WATCH; i++) {
            // check solo dei watch in uso
            if (watchdog->watch_list[i] != NULL) {
                // check del watch
                if (watchdog->watch_list[i]->active) {
                    // watch attivo: reset flag active
                    watchdog->watch_list[i]->active = false;
                }
                else {
                    // watch inattivo: mostro l'errore
                    printf("%s: watch %d: %s thread inattivo\n", 
                            __func__, watchdog->watch_list[i]->id, watchdog->watch_list[i]->name);
                }
            }
        }

        // unlock della funzione
        pthread_mutex_unlock(&watchdog->watch_mutex);

        // sleep del loop
        sleep(wait_sec);
    }
}

// addWatch - aggiunge un watch nella watch list
int addWatch(
    Watchdog *watchdog,     // watchdog pointer
    char     *name)         // watch name
{
    // lock della funzione per uso thread-safe
    pthread_mutex_lock(&watchdog->watch_mutex);

    // loop sulla watch list per trovare il primo watch disponibile
    for (int i = 0; i < MAX_WATCH; i++) {
        // check se il watch è disponibile
        if (watchdog->watch_list[i] == NULL) {
            // aggiunge un watch in watch list
            watchdog->watch_list[i] = malloc(sizeof(Watch));

            // set valori
            watchdog->watch_list[i]->id = i;
            snprintf(watchdog->watch_list[i]->name, 
                     sizeof(watchdog->watch_list[i]->name), "%s", name);
            watchdog->watch_list[i]->active = false;
            printf("%s: watch aggiunto: id=%d name=%s\n", __func__, i, name);

            // unlock della funzione
            pthread_mutex_unlock(&watchdog->watch_mutex);

            // return id
            return i;
        }
    }

    // watch disponibili finiti: mostro errore
    printf("%s: non ci sono più watch disponibili\n", __func__);

    // unlock della funzione
    pthread_mutex_unlock(&watchdog->watch_mutex);

    // return errore
    return -1;
}

// delWatch - cancella un watch nella watch list
void delWatch(
    Watchdog *watchdog,     // watchdog pointer
    int      id)            // watch id
{
    // lock della funzione per uso thread-safe
    pthread_mutex_lock(&watchdog->watch_mutex);

    // cancella un watch
    printf("%s: cancella un watch: id=%d name=%s\n", 
           __func__, watchdog->watch_list[id]->id, watchdog->watch_list[id]->name);
    free(watchdog->watch_list[id]);
    watchdog->watch_list[id] = NULL;

    // unlock della funzione
    pthread_mutex_unlock(&watchdog->watch_mutex);
}

// setWatch - set di un watch
void setWatch(
    Watchdog *watchdog,     // watchdog pointer
    int      id)            // watch id
{
    // lock della funzione per uso thread-safe
    pthread_mutex_lock(&watchdog->watch_mutex);

    // set a true del flag active
    if (watchdog->watch_list[id] != NULL)
        watchdog->watch_list[id]->active = true;

    // unlock della funzione
    pthread_mutex_unlock(&watchdog->watch_mutex);
}

Anche questo è molto commentato ed è auto-esplicativo. Si può solo aggiungere che la variabile di monitoring è una booleana che il thread associato mette a true (dicendo “sono vivo”): la funzione chkWatchdog() la legge e la rimette a false (dicendo “al prossimo giro devi dimostrami che sei vivo”). Tutte le operazioni che coinvolgono la variabile di stato sono protette dal mutex (ovviamente) e così anche quelle di creazione/rimozione dei watch. Nel caso che un thread risulti inattivo dopo l’intervallo di check, il problema viene segnalato (solo con una printf() in questo semplice esempio).

Che ne dite? direi che su questa base si può costruire un vero Watchdog “industriale”, ad esempio abbinandolo a un gestore di allarmi (segnatevelo: in futuro parleremo anche di questo). E credo che per oggi può bastare: nella seconda parte esamineremo le altre versioni che ho scritto (in C++ e Go), e vi anticipo che, difficilmente, riuscirò a evitare qualche piccola polemica parlando della versione C++ (ma non si sa mai, dipenderà dall’umore del momento…).

Ciao, e al prossimo post!