Errore di segmentazione dal gancio aperto()

Question

Sto tentando di creare un hook sulla funzione di sistema open(). L'ho fatto seguendo le linee seguenti.

Ho creato una libreria wrapper con il seguente:

extern int mocked_open(const char* fn, int flags, va_list args); 

int open(const char* fn, int flags, ...) 
{ 
    int r = -1; 
    va_list args; 

    va_start(args, flags); 
    r = mocked_open(fn, flags, args); 
    va_end(args); 

    return r; 
} 

compilo questo in libwrapper.so, che mi carico con LD_PRELOAD.

L'attuazione di mocked_open() è la seguente (io uso il quadro CPPUtest):

int mocked_open(const char* fn, int flags, va_list args) 
{ 
    if (strncmp(fn, test_device_id, 11) == 0) 
    { 
     return mock().actualCall("open").returnValue().getIntValue(); 
    } 
    else 
    { 
     int r = -1; 
     int (*my_open)(const char*, int, ...); 
     void* fptr = dlsym(RTLD_NEXT, "open"); 
     memcpy(&my_open, &fptr, sizeof(my_open)); 

     if (flags & O_CREAT) 
     { 
      r = my_open(fn, flags, va_arg(args, mode_t)); 
     } 
     else 
     { 
      r = my_open(fn, flags); 
     } 

     return r; 
    } 
} 

Il test_device_id è una semplice stringa ("test_device"), che spero non viene utilizzato altrove.

Durante l'esecuzione dei test, l'eseguibile si arresta in modo anomalo con un errore di segmentazione. Ho tracciato questo verso la funzionalità di profilazione GCC, che vuole aprire/creare un gruppo di file .gcda e chiama open() per questo.

Dopo un po 'di debug con strace (per suggerimento sotto), ho trovato che la riga r = my_open(fn, flags, va_arg(args, mode_t)); è effettivamente il colpevole. Viene chiamato ricorsivamente, o così sembra: vedo molte chiamate a questa linea, senza che la funzione ritorni. Quindi un segfault. Il file che si sta aprendo è il corrispondente file .gcda (per la profilazione). In effetti, il segfault si verifica solo con il profilo abilitato.

Answer 1

Quando si compila con gcov profiling abilitato, il compilatore inserisce codice aggiuntivo nelle vostre funzioni, per tenere traccia di quali è stato eseguito il codice. In pseudocodice ruvida, che inserito il codice farà (tra le altre cose):

if (!output_file_has_been_opened) { 
    fd = open(output_filename, ...); 
    check_ok(fd); 
    output_file_has_been_opened = TRUE; 
    track_coverage(); 
} 

... quindi se il file di output non è ancora stato aperto con successo (come all'inizio del programma), tenterà per aprirlo. Sfortunatamente, in questo caso chiameremo la tua funzione simulata open(), che ha lo stesso codice inserito; dal momento che il file non è stato ancora aperto correttamente e poiché il codice gcov non è consapevole dell'esistenza di qualcosa di insolito, tenterà nuovamente la chiamata open() - e questo è ciò che sta causando la ricorsione (e l'eventuale segfault, una volta che lo stack è esausto).

Answer 2

Prova questa

typedef int (*OpenFunction)(const char* fn, int flags, ...); 

poi

OpenFunction function; 
void  **pointer; 

pointer = (void **)&function; 
*pointer = dlsym(RTLD_NEXT, "open"); 

questo è un esempio di lavoro completo

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

#include <errno.h> 

typedef int (*OpenFunction)(const char* fn, int flags, ...); 

int main(int argc, char **argv) 
{ 
    OpenFunction function; 
    void  *dl; 
    int   fd; 
    void  **pointer; 

    if (argc < 2) 
     return -1; 
    pointer = (void **)&function; 
    *pointer = dlsym(RTLD_NEXT, "open"); 

    fd = function(argv[1], O_RDONLY); 
    if (fd != -1) 
    { 
     printf("file opened succesfully\n"); 
     close(fd); 
    } 
    else 
    { 
     printf("%s: cannot open the file\n", strerror(errno)); 
    } 
    return 0; 
} 

Answer 3

Si passa va_list in modo non corretto. Prova a seguire Spero che aiuta

 r = my_open(fn, flags, args); 

Per maggiori informazioni http://c-faq.com/varargs/handoff.html