comment utiliser la mémoire partagée pour communiquer entre deux processus

Je suis en train d'essayer de communiquer entre les deux processus. Je suis en train d'enregistrer des données(comme le nom, numéro de téléphone, l'adresse de la mémoire partagée dans un processus et d'essayer d'imprimer des données par le biais d'autres processus.

de fabrication1.c

#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
{
  int segment_id;
  char* shared_memory[3];
  int segment_size;
  key_t shm_key;
  int i=0;
  const int shared_segment_size = 0x6400;
  /* Allocate a shared memory segment. */
  segment_id = shmget (shm_key, shared_segment_size,
            IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
  /* Attach the shared memory segment. */
  shared_memory[3] = (char*) shmat (segment_id, 0, 0);
  printf ("shared memory attached at address %p\n", shared_memory);
  /* Write a string to the shared memory segment. */
   sprintf(shared_memory[i], "maddy \n");
   sprintf(shared_memory[i+1], "73453916\n");
   sprintf(shared_memory[i+2], "america\n");

  /*calling the other process*/
  system("./process2");

  /* Detach the shared memory segment. */
  shmdt (shared_memory);
  /* Deallocate the shared memory segment.*/
  shmctl (segment_id, IPC_RMID, 0);

  return 0;
}

process2.c

#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
{
  int segment_id;
  char* shared_memory[3];
  int segment_size;
  int i=0;
  key_t shm_key;
  const int shared_segment_size = 0x6400;
  /* Allocate a shared memory segment. */
  segment_id = shmget (shm_key, shared_segment_size,
              S_IRUSR | S_IWUSR);
  /* Attach the shared memory segment. */
  shared_memory[3] = (char*) shmat (segment_id, 0, 0);
  printf ("shared memory22 attached at address %p\n", shared_memory);
   printf ("name=%s\n", shared_memory[i]);
   printf ("%s\n", shared_memory[i+1]);
   printf ("%s\n", shared_memory[i+2]);
  /* Detach the shared memory segment. */
  shmdt (shared_memory);
   return 0;
}

Mais je n'obtiens pas le résultat souhaité.
la sortie que j'ai eu est:

shared memory attached at address 0x7fff0fd2d460
Segmentation fault

Quelqu'un peut s'il vous plaît m'aider avec cela. Est-ce la bonne façon de l'initialisation de shared_memory[3].

Merci.

source d'informationauteur maddy

  1. 15
    char* shared_memory[3];
...
shared_memory[3] = (char*) shmat (segment_id, 0, 0);

    Vous déclarez shared_memory comme un ensemble capable de tenir trois pointeurs de char, mais ce que vous faites, c'est d'écrire un pointeur une place derrière la fin du tableau. Puisqu'il est impossible de dire ce que la mémoire n'est utilisée d'une autre manière, ce qui se passe ensuite est généralement imprévisible.

    Aller les choses de façon concluante mauvais par la suite lorsque vous essayez de faire usage de pointeurs dans shared_memory[0] par shared_memory[2]parce que ces pointeurs n'ont jamais été initialisé. Ils sont remplis avec sens des ordures de la pile -- ainsi, l'erreur de segmentation.

    Il semble, en général, que vous êtes ne parvenant pas à distinguer entre la matrice et de ses éléments. Vous devriez aller vous faire beaucoup plus à l'aise avec les tableaux et les pointeurs code séquentiel avant d'essayer votre main à la mémoire partagée de la CIB.

    Remarque que la mémoire partagée est l'un des plus faciles à faire de mauvaises façons de faire de la CIB. Sauf si vous avez rigide contraintes d'efficacité et d'échange beaucoup de données, il est beaucoup plus facile de travailler avec des tuyaux, tubes nommés, ou de sockets.

  2. 12

    Les deux autres réponses vous dit quel est le problème, mais je veux vous donner un code exécutable. Vous pouvez la modifier pour passer n'importe quoi, le principe est que vous devez enregistrer la longueur de chaque élément que vous avez passé de l'autre côté.

    //écriture.c

    #include <stdio.h>
#include <string.h>
#include <sys/shm.h>
#include <sys/stat.h>

int main ()
{
  key_t shm_key = 6166529;
  const int shm_size = 1024;

  int shm_id;
  char* shmaddr, *ptr;
  int next[2];

  printf ("writer started.\n");

  /* Allocate a shared memory segment. */
  shm_id = shmget (shm_key, shm_size, IPC_CREAT | S_IRUSR | S_IWUSR);

  /* Attach the shared memory segment. */
  shmaddr = (char*) shmat (shm_id, 0, 0);

  printf ("shared memory attached at address %p\n", shmaddr);

  /* Start to write data. */
  ptr = shmaddr + sizeof (next);
  next[0] = sprintf (ptr, "mandy") + 1;
  ptr += next[0];
  next[1] = sprintf (ptr, "73453916") + 1;
  ptr += next[1];
  sprintf (ptr, "amarica");
  memcpy(shmaddr, &next, sizeof (next));
  printf ("writer ended.\n");

  /*calling the other process*/
  system("./read");

  /* Detach the shared memory segment. */
  shmdt (shmaddr);
  /* Deallocate the shared memory segment.*/
  shmctl (shm_id, IPC_RMID, 0);

  return 0;
}

    //lire.c

    #include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>

int main ()
{
  key_t shm_key = 6166529;
  const int shm_size = 1024;

  int shm_id;
  char* shmaddr, *ptr;
  char* shared_memory[3];
  int *p;

  /* Allocate a shared memory segment. */
  shm_id = shmget (shm_key, shm_size, IPC_CREAT | S_IRUSR | S_IWUSR);

  /* Attach the shared memory segment. */
  shmaddr = (char*) shmat (shm_id, 0, 0);

  printf ("shared memory attached at address %p\n", shmaddr);

  /* Start to read data. */
  p = (int *)shmaddr;
  ptr = shmaddr + sizeof (int) * 2;
  shared_memory[0] = ptr;
  ptr += *p++;
  shared_memory[1] = ptr;
  ptr += *p;
  shared_memory[2] = ptr;
  printf ("0=%s\n", shared_memory[0]);
  printf ("1=%s\n", shared_memory[1]);
  printf ("2=%s\n", shared_memory[2]);

  /* Detach the shared memory segment. */
  shmdt (shmaddr);
  return 0;
}

    //Le résultat de l'exécution:

    > [lex:shm]$ ./write
> writer started.
> shared memory attached at address 0x7fa20103b000 
> writer ended.
> shared memory attached at address0x7fd85e2eb000
> 0=mandy
> 1=73453916
> 2=amarica
  3. 0

    Vous devriez être en réservant suffisamment de mémoire partagée pour l'échange de la données. Les processus ne sont pas censés l'accès des uns et des autres en mémoire, même si l'utilisation partagée des pointeurs. Gardez à l'esprit uniquement les données brutes que vous écrivez au cours de l'exécution est partagé, il n'y a pas de vérification de type ou de toute autre métadonnées passé. Vous pouvez utiliser une structure commune, si vos données à l'aide de fixe-matrices de taille, d'accéder aux données plus facilement. Sinon, vous devrez manuellement maréchal de données entre les processus.