Errore handling dei segnali

[LimiT-MaTz]

Ho un problema per quanto riguarda l'handling dei segnali.
Sto sviluppando una piccola applicazione (mi serve fondamentalmente per esercizio).
ho intenzione di fare un handler per il segnale SIGTSTP.
fondamentalmente vorrei ottenere questo in caso di ctrl+z l'applicazione deve morire e prima di morire deve liberare un struttura dati.

la struttura dati e' una semplice lista doppiolinkata definita nella lib standard.
il tutto viene istanziato nel main

list<process> * List_proc = new list<process>();

essendo instaziata nel main quando vado a "costruire la funzione richiamata dall'handle dei signal" non posso fare accesso in alcun modo alla struttura (non posso passarla per parametro).
Una soluzione potrebbe essere quella di dichiarare List_proc globale cio' risolverebbe i miei problemi. Non voglio seguire questa via ma provare un'altra via.

L'idea e' questa:
fare un handle banale che chiami exit(OK) e andare a definire la funzione da chiamare all'uscita:

-- Function: int on_exit (void (*FUNCTION)(int STATUS, void *ARG),void *ARG)

ho quindi creato una funzione "Delete_list" che si occupi di chiamare il delete in caso il puntatore *ARG esista.

void Delete_list(int n,void  *lst)
{
	if(lst)
	{
		cout<<"DELETE"<<endl;
		delete (list<process> *) lst;
	}
}

e l'ho registrata nel main:

	on_exit(Delete_list,List_proc);			/* Operation to do at exit   */

ora ho provato un po il programma e gira senza errore, al segnale ctrl-z si chiude senza dare errori.
Per verificare se la heap viene liberata veramente ho fatto un test con valgrind e mi sono accorto che cio' non accade

==28163== 
==28163== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 19 from 1)
==28163== malloc/free: in use at exit: 5,795 bytes in 143 blocks.
==28163== malloc/free: 1,152 allocs, 1,009 frees, 1,888,613 bytes allocated.
==28163== For counts of detected errors, rerun with: -v
==28163== searching for pointers to 143 not-freed blocks.
==28163== checked 116,208 bytes.
==28163== 
==28163== LEAK SUMMARY:
==28163==    definitely lost: 0 bytes in 0 blocks.
==28163==      possibly lost: 1,527 bytes in 71 blocks.
==28163==    still reachable: 4,268 bytes in 72 blocks.
==28163==         suppressed: 0 bytes in 0 blocks.
==28163== Reachable blocks (those to which a pointer was found) are not shown.

il problema avviene solo esclusivamente quando chiamo exit(OK) ovvero quando "premo ctrl-z".

sapreste aiutarmi?
Grazie.

[LimiT-MaTz]

poiche' registravo la funzione on_exit prima che l'oggetto list venisse istanziato il puntatore void *lst rimaneva null quindi non entrava mai nell'if in cui faccio il delete.

	List_proc = new list<process>();	
	
	on_exit(Delete_list,List_proc);							/* Operation to do at exit   */

cosi' facendo ho risolto.

vi sembra una buona soluzione?

[trallallero]

Originariamente inviato da LimiT-MaTz

...
vi sembra una buona soluzione?

NO!

é ottima
ma "valgrind" cos'é ? e che s.o. usi ?

Comunque apprezzo chi si sforza di trovare alternative al semplice "dichiaro globale e mi tolgo il pensiero"
qui a volte mi trovo dei pro*C da modificare con (non esagero) 100/150 righe di variabili globali
Peró non capisco la tua funzione legata al segnale ... io ho sempre usato
questo tipo

void Function( int , siginfo_t *, void * )

tu invece

int on_exit (void (*FUNCTION)(int STATUS, void *ARG),void *ARG)

o forse ho capito male io ? usi la struct sigaction ?

[LimiT-MaTz]

Il S.O. e' gnu/linux
per quanto riguarda valgrind ti rimando qui: http://valgrind.org/

Hai perfettamente ragione mi sono espresso male la funzione

int on_exit (void (*FUNCTION)(int STATUS, void *ARG),void *ARG)

non centra nulla con il segnale, ti posto una breve descrizione:

NAME
       on_exit - register a function to be called at normal process termination

SYNOPSIS
       #include <stdlib.h>

       int on_exit(void (*function)(int , void *), void *arg);

DESCRIPTION
       The on_exit() function registers the given function to be called at nor-
       mal process termination, whether via exit(3) or via return from the pro-
       gram's main().  The function is passed the argument to exit(3)  and  the
       arg argument from on_exit().

per quanto riguarda l'handler del segnale uso questa funzione per registrarlo:

void signal_handler_exit(int n)
{
	exit(0);
}

	signal(SIGINT,  signal_handler_exit);		/* Signal handler for ctrl-c */

ora mi si pone un altro problema, io vorrei anche gestire SIGWINCH, signal che viene mandata ad ogni resize del terminale.
handler in questione dovrebbe richiamare un funzione get_terminal_size(int *row,int *col) => questa funzione fa una ioctl e aggiorna i valori di row e col.
in modo che potro' usarli per formattare il testo correttamente.
Anche qui vorrei fare a meno di variabili globali il problema e' che non posso passare alal funzione signal una funzione void get_terminal_size(int *row,int *col) ma sono costretto ad una void function(int n).

Grazie ancora
p.s: non ditemi di usare ncurses :P