Prendi il makefile e scappa come scrivere un makefile universale - pt.2

Louise: Sai una cosa? Presto avremo un bambino.
Virgil: Scherzi...
Louise: No! Avremo proprio un bambino: me l'ha detto il dottore, è sicuro. Sarà il mio regalo per Natale.
Virgil: Ma a me bastava una cravatta!

A Virgil Starkwell bastava una cravatta... a noi invece basta un bel makefile universale. Ricordate quel vecchio post in cui ve ne ho proposto uno? Non ve lo ricordate? Subito a rileggerlo e poi tornate qua.

...presto avremo un makefile...

Rieccoci (e, piccola premessa: alcuni punti di questo post sono parzialmente copiati dal mio vecchio post... posso copiare me stesso, no?). Se avete riletto il post sapete già che questo sarà un post veloce, e non propriamente sul C: ho pensato che era ora di scrivere e proporvi una versione estesa e perfezionata del vecchio makefile universale: rispetto all'originale questo usa maggiormente le variabili, così il codice è più pulito e leggibile (lo stile, prima di tutto!) e aggiunge una funzionalità molto interessante: la creazione di una shared library (una .so, per gli amici). Vediamo schematicamente quali sono i passi da eseguire (su un Linux della famiglia Debian) per creare e usare una shared-lib:

1. creare una directory per condividere la shared-lib, ad esempio: 
       /usr/share/pluto/lib
2. modificare (come vedremo tra poco) il makefile per generare la libreria 
   (che chiameremo "libmyutils.so") e copiarla in "/usr/share/pluto/lib".
3. aggiungere in "/etc/ld.so.conf.d" un nuovo file "libmyutils.conf" che 
   contiene le seguenti due linee (la prima è solo un commento): 
       # libmyutils.so default configuration
       /usr/share/pluto/lib
4. rendere disponibile la nuova shared-lib eseguendo: 
       sudo ldconfig

Proseguiamo: supponiamo di usare lo stesso progetto dell'altra volta (si chiamava pluto). I nostri file sono organizzati in una maniera canonica, questa volta in quattro directory (l'altra volta erano tre): pluto, lib, libmyutils e include. La nuova directory è libmyutils, e contiene i sorgenti della shared-lib che vogliamo creare. Nella directory pluto troviamo il main() e il makefile, nella directory lib troviamo gli altri sorgenti dell'applicazione pluto e, infine, nella directory include troviamo gli header-files comuni a main(), lib e libmyutils. Vediamo il nuovo makefile:

# variabili
CC = gcc
CPPFLAGS = -I../include -g -Wall -Wshadow -pedantic -std=c11
CPPFLAGS_UTI = -fpic -I../include -g -Wall -Wshadow -pedantic -std=c11
LDFLAGS = -lmyutils -std=c11
LDFLAGS_UTI = -shared -fpic -lcurl -std=c11

# sorgenti, oggetti e dipendenze
SRCS = $(wildcard *.c)
SRCS_LIB = $(wildcard ../lib/*.c)
SRCS_LIB_UTI = $(wildcard ../libmyutils/*.c)
OBJS = $(SRCS:.c=.o)
OBJS_LIB = $(SRCS_LIB:.c=.o)
OBJS_LIB_UTI = $(SRCS_LIB_UTI:.c=.ou)
DEPS = $(SRCS:.c=.d)
DEPS_LIB = $(SRCS_LIB:.c=.d)
DEPS_LIB_UTI = $(SRCS_LIB_UTI:.c=.d)

# tutti i target
all: libmyutils pluto

# creazione del target file eseguibile
pluto: $(OBJS) $(OBJS_LIB)
 $(CC) $^ -o $@ $(LDFLAGS) -L/usr/share/pluto/lib

# creazione della shared-lib libmyutils.so
libmyutils: $(OBJS_LIB_UTI)
 $(CC) $^ -o libmyutils.so $(LDFLAGS_UTI)
 mv libmyutils.so /usr/share/pluto/lib

# creazione degli object file (per la applicazione e la shared-lib)
%.o: %.c
 $(CC) -MMD -MP $(CPPFLAGS) -c $< -o $@

%.ou: %.c
 $(CC) -MMD -MP $(CPPFLAGS_UTI) -c $< -o $@

# direttive phony
.PHONY: clean

# pulizia progetto ($(RM) è di default "rm -f")
clean:
 $(RM) $(OBJS) $(OBJS_LIB) $(OBJS_LIB_UTI) $(DEPS) $(DEPS_LIB) $(DEPS_LIB_UTI)

# creazione dipendenze
-include $(DEPS) $(DEPS_LIB) $(DEPS_LIB_UTI)

Come vedete il nuovo makefile presentato è uno stretto parente di quello vecchio e continua ad essere veramente semplice e universale: fa tutto quello che serve, compresa la generazione dei file di dipendenza dagli header, e possiamo usarlo per qualsiasi progetto, indipendentemente dal numero di file (le directory lib e include potrebbero essere vuote oppure contenere centinaia di file). Possiamo aggiungere e togliere sorgenti e header e ricompilare senza modificare una sola linea del makefile, perché lui si adatta automaticamente a quello che trova nelle directory del progetto: cosa vogliamo di più?

Aggiungo qualche piccolo dettaglio sui blocchi (commentati) che compongono il makefile universale:

# variabili
Qua si mettono le variabili che vengono usate nel resto del makefile. Notare che in CPPFLAGS e LDFLAGS sono contenute tutte le opzioni di compilazione e link necessarie nelle fasi di creazione della applicazione, mentre che in CPPFLAGS_UTI e LDFLAGS_UTI sono contenute quelle relative alla shared-lib). Non mi dilungherò sul significato delle singole opzioni: magari potrebbero essere l'argomento di un prossimo post... comunque le opzioni che ho usato sono decisamente "universali". Se si usa qualche libreria esterna si può aggiungere qui: nell'esempio (ricordarsi: è solo un esempio!) ho scritto che pluto usa libmyutils (con il comando -lmyutils in LDFLAGS) e ho scritto che libmyutils usa la libreria open-source libcurl (con il comando -lcurl in LDFLAGS_UTI). Notare che per compilare e linkare la shared-lib si usano due direttive fondamentali: -fpic (in compilazione e link) e  -shared (solo in link). E ribadisco: -fpic si usa sia in compilazione che in link: questo è un dettaglio che molte delle guide che si trovano in rete omettono e può essere una possibile causa di strani malfunzionamenti di una shared-lib.

# sorgenti, oggetti e dipendenze
Qua ci sono le direttive che usa internamente il programma make per decidere come e dove cercare sorgenti, oggetti e dipendenze.

# tutti i target
Qua ci sono gli obiettivi di creazione: nel nostro caso la libreria libmyutils e l'applicazione pluto: il comando make "da solo" esegue entrambi gli obiettivi (la parola chiave è "all"), ma si può bypassare questo eseguendo, ad esempio, "make libmyutils" che crea solo la shared-lib.

# creazione del target file eseguibile
Qua si mette il comando per linkare i file oggetto creati e produrre il file eseguibile finale. Notare che con la direttiva -L/usr/share/pluto/lib indichiamo al linker dove si trova la libreria libmyutils.so. Notare anche che questa direttiva serve solo a livello linker, mentre, a livello esecuzione delle applicazioni che usano la nostra shared-lib, servono i passi della lista descritta all'inizio del post (in particolare i passi 3 e 4).

# creazione della shared-lib libmyutils.so
Qua ci sono le istruzioni per la creazione della shared-lib libmyutils.so e per spostarla (col comando "mv") nella directory destinazione.

# creazione degli object file (per la applicazione e la shared-lib)
Qua si mette il comando per compilare ogni sorgente e creare il file oggetto corrispondente, attivando (attraverso le variabili definite all'inizio) tutte le opzioni del compilatore che ci servono.

# direttive phony
Qua si mettono tutte le direttive phony (è un po' lungo da spiegare: guardate il link, che è chiarissimo).

# pulizia progetto ($(RM) è di default "rm -f")
Qua si mette il comando di cancellazione degli oggetti per, eventualmente, forzare una successiva ricompilazione completa.

# creazione dipendenze
Qua si mette il comando per generare i file di dipendenza che ci permettono di ricompilare solo quello che serve quando modifichiamo un header-file.

Credo che per oggi possa bastare... fatevi un piccolo progetto di prova (ad esempio usando funzioni semivuote che scrivono solo "Ciao, sono la funzione xyz") e provate il nuovo makefile universale: scoprirete che è veramente facilissimo da usare!

Ciao e al prossimo post!

Il grande lighttpd come scrivere un modulo lighttpd in C - pt.4

Maude: E di cosa ti occupi nel tempo libero?
Drugo: Mah, le solite cose: Bowling, un giro in macchina, un trip d'acido quando capita...

Sottinteso che per scrivere del buon Software non c'è bisogno di imitare le abitudini del mitico Drugo del Grande Lebowski, ritorniamo sull'argomento lighttpd, perchè nel terzo post della serie (qui, qui e ancora qui) avevo promesso di ampliare il discorso. Ebbene è venuto il momento, le promesse si mantengono!

...Mah, le solite cose: Bowling, un giro in macchina, un modulo lighttpd quando capita...

Bene, ne "Il grande lighttpd - pt.3" (che, avete appena riletto, immagino...) avevamo scritto un bel modulo elementare per lighttpd. Faceva poco (era un classico "Helloworld": scriveva solo una presentazione nel browser) però era un buon inizio per entrare nel mondo dei moduli di questo notevole Web Server. Ecco, adesso riprenderemo la base fatta a suo tempo e gli aggiungeremo una funzione che estrae i dati POST inclusi in una eventuale petizione HTTP di tipo POST che arriva al modulo. Perché ho scelto di aggiungere proprio questa funzionalità? Beh, ovviamente perché è abbastanza normale che un modulo tratti vari tipi di petizioni (GET, POST, ecc.), e poi, in particolare, ricordo che la prima volta che aggiunsi questa funzionalità in un modulo Apache che avevo scritto, notai che non erano disponibili molte indicazioni su questo argomento (e questo nonostante la enorme mole di documentazione su Apache disponibile rispetto a quella su lighttpd)... vi lascio immaginare, quindi, quanta documentazione e quanti esempi ho trovato per fare la stessa cosa per lighttpd: praticamente niente.

Bene, senza stare a ripetere tutto il codice e la maniera di generarlo, riscriveremo solo la funzione mod_helloworld_uri_handler() e aggiungeremo una nuova funzione getPost(). Premetto che, per integrare il codice che ho scritto, è necessario seguire la guida di installazione indicata in "Il grande lighttpd - pt.1" e ripetere tutti i 10 passi indicati in "Il grande lighttpd - pt.2", usando questa volta la versione 1.4.45 di lighttpd (occhio: se usate una versione più vecchia il codice che sto per mostrarvi non funziona). Fatto? Allora vai col codice!

URIHANDLER_FUNC(
    mod_helloworld_uri_handler)
{
    plugin_data *p = p_d;

    UNUSED(srv);

    // test modo (return se errore)
    if (con->mode != DIRECT)
        return HANDLER_GO_ON;

    // test uri path (return se errore)
    size_t s_len = buffer_string_length(con->uri.path);
    if (s_len == 0)
        return HANDLER_GO_ON;

    mod_helloworld_patch_connection(srv, con, p);

    // test handler (return se errore)
    if (con->uri.path->ptr && strstr(con->uri.path->ptr, "helloworld")) {
        // prepara il buffer per la risposta
        buffer *buf = buffer_init();

        // test metodo http
        if (strstr(con->request.request->ptr, "GET")) {
            // metodo GET: scrive risposta
            buffer_append_string(buf, "<big>Hello, world!</big>");
        }
        else if (strstr(con->request.request->ptr, "POST")) {
            // metodo POST: controlla la presenza di post-data
            size_t len = con->request.content_length;
            if (len) {
                // post-data presenti; li legge per scrivere la risposta
                char *data = malloc(len + 1);
                if (readPost(con, data, len)) {
                    // scrive la risposta
                    buffer_append_string(buf, data);
                }

                // libera la memoria
                free(data);
            }
            else {
                // errore: messaggio POST senza post-data
                buffer_append_string(buf, "mod_helloworld: errore: POST senza post-data");
            }
        }
        else {
            // errore: messaggio con metodo non trattato
            buffer_append_string(buf, "mod_helloworld errore: metodo non trattato");
        }

        // scrive il buffer e lo libera
        chunkqueue_append_buffer(con->write_queue, buf);
        buffer_free(buf);

        // spedisce l'header
        response_header_overwrite(
                srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));
        con->http_status = 200;
        con->file_finished = 1;

        // handling finito
        return HANDLER_FINISHED;
    }

    // handler non trovato
    return HANDLER_GO_ON;
}

static bool readPost(
    connection *con,                // dati connessione
    char       *data,               // buffer destinazione per post-data
    size_t     len)                 // lunghezza data (senza terminatore)
{
    // set valore di return di default
    int retval = false;

    // legge post-data (nello stream di chunks)
    size_t rpos = 0;
    chunkqueue *cq = con->read_queue;
    for (chunk *mychunk = cq->first; mychunk; mychunk = cq->first) {
        // calcola il size del buffer corrispondente al chunk di post-data corrente
        size_t n_tocopy = buffer_string_length(mychunk->mem) - mychunk->offset;

        // test se ci sono dati da copiare
        if (n_tocopy <= (len - rpos)) {
            // copia un chunk e set della posizione di copia del prossimo chunk
            memcpy(data + rpos, mychunk->mem->ptr + mychunk->offset, n_tocopy);
            rpos += n_tocopy;

            // é stato letto (almeno) un chunk di post-data: set retval=true
            retval = true;
        }
        else {
            // buffer overflow: forzo uscita dal loop
            break;
        }

        // segnalo come letto il chunk di post-data corrente
        chunkqueue_mark_written(cq, chunkqueue_length(cq));
    }

    // aggiungo il terminatore di stringa (il buffer é lungo len+1)
    data[len] = 0;

    // esco con retval
    return retval;
}

Ok, come vedete è ampiamente commentato e quindi è auto-esplicativo, per cui non mi dilungherò sulle singole istruzioni e/o gruppi di istruzioni (leggete i commenti! sono li per quello!), ma aggiungerò, solo, qualche dettaglio strutturale.

L'originale funzione mod_helloworld_uri_handler() è ancora una sorta di funzione "Helloworld", ma ora distingue i tipi di petizione e, nel caso POST, chiama la funzione readPost() e scrive come risposta "Hello, world!" più i dati POST. Nel caso di petizioni GET si limita a scrivere "Hello, world!" e, con altri tipi di petizione o con petizioni POST senza dati, scrive un messaggio di un errore.

La funzione readPost() è semplice ma non immediata: vista la scarsezza quasi totale di esempi disponibili in rete ho dovuto, praticamente, fare reverse engineering sugli (ottimi) moduli integrati nella distribuzione (avere il codice sorgente originale a disposizione è sempre una cosa ottima!) in maniera di dedurre come fare quello che mi ero prefisso. Il risultato finale è (modestia a parte) buono, sia come aspetto (stile) sia come prestazioni (ho fatto dei test e funziona bene).

Ah, il test, dimenticavo! Testare con petizioni POST non è semplice come farlo con le GET, dove è sufficiente (come detto nel post precedente) scrivere la URI del modulo nella barra degli indirizzi di Firefox o Chrome (o qualsiasi altro browser meno IE, per favore...) e aspettare la risposta. Per testare il nostro nuovo modulo è meglio usare un bel plugin del browser (tipo Poster) per semplificare il lavoro.

Va bene, per il momento credo che possiamo fermare per un tempo l'argomento moduli lighttpd. Giuro che nel prossimo post parlerò d'altro, non vorrei che pensaste che il C si usa solo per i Web Servers...

Ciao e al prossimo post!

Dawn of the CPU come testare l'uso di CPU e Memoria in C - pt.2

Ci siamo, dopo la presentazione nello scorso post è venuta l'ora di vedere se il nostro sistema di test continuo di CPU e Memoria funziona. E se funziona bene. Ricordate l'argomento, no? Gli zombi da supermercato, Dawn of the Dead, Dawn of the CPU... si, quello.

...ma veramente dobbiamo andare armati per comprare un po' di RAM?...

Per verificare il funzionamento della funzione di test descritta nello scorso post, ho scritto un piccolo programma di test (testsys.c) che crea un thread in grado di stressare CPU e Memoria di un sistema e che poi, direttamente nel main(), chiama in un loop infinito la nostra funzione testSys(), mostrando ogni due secondi i risultati del test. Nel codice che segue manca solo la funzione di test: quella potete andare a ripescarla nell'ultimo post e così potete approfittare per rileggerne le parti salienti (bravi se lo fate!). Vai col codice!

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <linux/kernel.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/sysinfo.h>

// struct per i risultati
typedef struct {
    ...
} Results;

// prototipi locali
void testSys(Results *results);
void *tMyThread(void *arg);

// funzione main()
int main(int argc, char *argv[])
{
    // init thread
    pthread_t tid;
    int error;
    if ((error = pthread_create(&tid, NULL, &tMyThread, NULL)) != 0)
        printf("%s: non posso creare il thread (%s)\n", argv[0], strerror(error));

    // chiama testSys() per primo set valori statici
    Results results;
    testSys(&results);
    sleep(2);

    // testSys() loop per testare ripetutamente il sistema
    for (;;) {
        // get valori
        testSys(&results);
        printf("cpu: total usage = %.1f\n", results.total_cpu / results.prec);
        printf("mem: total usage = %.1f\n", results.mem_system / results.prec);
        printf("cpu: proc  usage = %.1f\n", results.proc_cpu / results.prec);
        printf("mem: proc  usage = %.1f\n", results.mem_proc / results.prec);
        printf("load average: %.2f , %.2f , %.2f\n", 
                results.loads[0] / results.loads_prec,
                results.loads[1] / results.loads_prec, 
                results.loads[2] / results.loads_prec);

        // sleep 2 secondi
        sleep(2);
    }

    // exit
    exit(EXIT_SUCCESS);
}

// funzione di test del sistema
void testSys(
    Results *results)   // destinazione dei risultati
{
    ...
}

// thread routine
void *tMyThread(void *arg)
{
    // alloc memoria
    unsigned long mem = 1024 * 1024 * 512;  // 512 mb
    char *ptr = malloc(mem);

    // thread loop infinito
    for (;;) {
        // usa memoria
        memset(ptr, 0, mem);

        // thread sleep
        usleep(10);    // NOTA: sleep molto piccola per forzare molta attività di cpu
    }

    return NULL;
}

Come potete ben vedere il programma è di una semplicità disarmante (e con  ottimi commenti, al solito). Per stressare CPU e Memoria ho solo usato alcuni semplici trucchetti: alloco (con malloc()) un bufferone di 512MB, e poi in un loop infinito lo uso intensamente (con una memset() completa). Il loop del thread usa una usleep moooolto piccola (10 us) che carica non poco la CPU (che ci odierà un poco, ma è l'obiettivo del nostro test, no?).

Adesso viene il bello: come detto varie volte nel post precedente, il nostro riferimento è il comando top della famiglia UNIX, quindi dobbiamo aprire due terminali, e in uno eseguiamo il nostro programma di test, e nell'altro eseguiamo top e così possiamo confrontare in tempo reale se i risultati corrispondono (ricordatevi di attivare l'opzione "I" di top, come descritto nell'altro post). Vediamo cosa è successo sulla mia macchina:

nel terminale con testsys
...
load average: 0.85 , 0.42 , 0.32
cpu: total usage = 12.9
mem: total usage = 47.8
cpu: proc  usage = 12.5
mem: proc  usage = 6.9
...

nel terminale con top
top - 18:45:16 up 39 min,  2 users,  load average: 0,85, 0,42, 0,32
Tasks: 236 total,   1 running, 235 sleeping,   0 stopped,   0 zombie
%Cpu(s): 12,5 us,  0,1 sy,  0,0 ni, 87,2 id,  0,0 wa,  0,0 hi,  0,1 si,  0,0 st
KiB Mem :  7600656 total,  3962420 free,  1705536 used,  1932700 buff/cache
KiB Swap:        0 total,        0 free,        0 used.  5384092 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND            
 5266 aldo      20   0  604548 524744    628 S 12,5  6,9   0:43.01 testpstat          
 1380 root      20   0  559772  94056  82400 S  0,1  1,2   0:43.89 Xorg               
 1012 root      20   0    4396   1276   1196 S  0,0  0,0   0:00.07 acpid              
 2628 aldo      20   0 2542528 358152 128056 S  0,0  4,7   3:18.25 firefox            
 ...

visto che l'output è continuo ne ho selezionato solo una parte e ho aggiunto i puntini di sospensione, comunque potete ripetere facilmente il test sulla vostra macchina per verificare la costanza dei risultati: direi che il risultato è più che soddisfacente, no? Missione compiuta!

Cosa manca? Ah, si, avevo promesso qualche appunto sui risultati che mostra top (e per riflesso anche il nostro testsys): per quanto riguarda la CPU sono sufficienti i commenti nel codice della testSys() (descrizione dei carichi medi, opzione "I", ecc.). In più si può aggiungere che la linea %Cpu(s) mostrata qua sopra conferma le formule contenute (e commentate) nella testSys(): ad esempio la somma dei vari componenti (user, idle, sys, ecc.) vale, guarda caso, 100.

Per la memoria, invece, il discorso è un po' più complesso, e bisognerebbe dedicargli un post apposito (magari lo farò in futuro): per il momento vi passo un link interessante: understanding-memory-usage-on-linux, e vi aggiungo solo una spiegazione semplicissima di una cosa (strana) che a volte succede su sistemi embedded realizzati con BusyBox: in alcuni casi sembra che alcuni processi usino più del 100% della memoria (nella colonna %MEM): questo è dovuto al fatto che si sta usando una vecchia versione di top fornita da BusyBox che calcola %MEM come VSZ/MemTotal invece di RSS/MemTotal: bisogna considerare che RSS è un valore residente mentre VSZ è un valore virtuale, quindi influenzato, ad esempio, da eventuali shared library che vengono caricate e condivise tra varie applicazioni, pagine di memoria non usate al momento, ecc., per cui non c'è da stupirsi se il valore supera il 100%. Comunque le versioni più recenti di top per BusyBox ridefiniscono la colonna %MEM in %VSZ risolvendo così eventuali incomprensioni (oops... si, i significati delle strane sigle qui sopra li trovate nei commenti della testSys(), nel manuale di top e nel link che vi ho passato sulla memoria di Linux).

Beh, direi che per questo post può bastare. Vi lascio con una piccola nota: visto che ho usato solo loop infiniti nel programma di test potete modificarlo a piacere aggiungendo condizioni di uscita. Oppure non abbiate paura a fermarlo con CTL-C, non credo che Linux si arrabbi molto...

Ciao, e al prossimo post!