Lesen aus dem gemeinsamen Speicher mit mmap - Segmentation Fault

Question

Ich versuche immer noch, meinen Kopf um Shared Memory einzuwickeln. Was ich versuche zu erreichen, ist eine Reihe von Pods. Jeder Pod enthält außerdem ein Array von keyValue.

typedef struct { 
    char key[256]; 
    char value[256]; 
}keyValue; 

typedef struct { 
    keyValue **arr; 
    int count; 
}pod; 

int fd; 

int main(int argc, char **argv) { 
    int kv_store_create(char *name) { 
     return shm_open(name, O_CREAT|O_RDWR, S_IRWXU); 
    } 

    void kv_store_write(char *key1, char *value1) { 

     static pod (*str)[28]; 

     ftruncate(fd, sizeof(str)); 

     str = (pod(*)[28])mmap(NULL, sizeof(str), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 

     for (int i = 0; i < 28; i++) { 
     str[i]->arr = (keyValue **)malloc(28 * sizeof(keyValue)); 
     for(int j = 0; j < 28; j++) { 
      str[i]->arr[j] = (keyValue *)malloc(256 * sizeof(keyValue)); 
     } 
     } 

     strncpy(str[0]->arr[0]->key, key1, strlen(key1)); 
     strncpy(str[0]->arr[0]->value, value1, strlen(value1)); 
     str[0]->count = 1; 
    } 

    fd = kv_store_create("sharedmem"); 

    kv_store_write("key", "value"); 

Deshalb an dieser Stelle habe ich eine keyValue in einer Hülse, und wenn ich den gemeinsam genutzten Speicher aus der gleichen Datei zu lesen, ich habe keine Probleme.

Das Problem tritt auf, wenn ich versuche, von einem anderen Prozess zu lesen. Ich habe die folgende Datei

int main(int argc, char **argv) { 

    typedef struct { 
     char key[256]; 
     char value[256]; 
    }keyValue; 

    typedef struct { 
     keyValue **arr; 
     int count; 
    }pod; 


    int fd = shm_open("sharedmem", O_RDWR, 0); 
    if (fd < 0) { 
     printf("Error... opening shm\n"); 
    } 

    struct stat s; 

    if (fstat(fd, &s) == -1) { 
     printf("Error fstat\n"); 
    } 

    pod (*str2)[28]; 

    str2 = (pod(*)[28])mmap(NULL, s.st_size, PROT_READ, MAP_SHARED, fd, 0); 

    printf("%s", str2[0]->arr[0]->key); 

} 

Die printf einen seg Fehler verursacht und ich glaube, es versucht, einen Teil eines Speicher zuzugreifen, die nichts zugewiesen hat, während die printf tatsächlich in meiner ersten Datei drucken.

Ich versuche, herauszufinden, warum ein Fehler spuckt wird und welche Route sollte ich

ein Array von Strukturen zwischen zwei Prozessen zu teilen

Dank der Lage sein!

Answer 1

Was Sie sagen, ist:

Jeder Pod wird auch eine Reihe von keyValue enthalten.

Aber das ist nicht der Fall, weil eine Schote ist:

typedef struct { 
    keyValue **arr; 
    int count; 
}pod; 

die nicht eine Reihe von KeyValue enthalten. Es enthält einen Zeiger auf ein Array von KeyValue*, aber die KeyValue Objekte selbst sind weder in der pod noch in dem Speicher von arr gezeigt. Sie sind also definitiv nicht in der Erinnerung, die Sie zwischen den beiden Prozessen teilen.

So wird der Leseprozess ein pod die einen Zeiger auf eine Adresse im besitzenden Prozess enthält; Offensichtlich ist dieser Zeiger im Leser völlig bedeutungslos, da Prozesse keinen Speicher teilen, so dass eine Adresse eines Objekts in einem anderen Prozess mehr oder weniger äquivalent zu einer Zufallszahl ist.

Kurz gesagt, Sie müssen sicherstellen, dass der Shared Memory-Bereich tatsächlich alle Objekte enthält, die Sie freigeben möchten, nicht nur Zeiger auf sie. Und da es unwahrscheinlich ist, dass mmap die gleiche Adresse in den beiden Prozessen zurückgibt, ist es nicht sinnvoll, Zeiger in den gemeinsam genutzten Speicher einzufügen, selbst für Objekte, die im gemeinsamen Speicher abgelegt sind.