Discussion :

[vever001]

Bonjour à tous,

Je suis en train de faire un projet en système d'exploitation en c avec la mémoire partagée, les message queue et les sémaphores.
Je travaille sous vmware avec ubuntu et je viens de remarquer qqch d'étrange:

Lorsque je veux créer un segment de mémoire partagée avec la fonction shmget(), si je met plus que 24 octets pour la taille cela me retourne une erreur (Invalid argument)

Donc je me demande si c'est normal qu'on ne puisse pas partager des segments de mémoire de plus de 24 octets ?? car c'est quand même très peu et il me faudrait bien plus que cela...

Merci

[Obsidian]

Bonjour,

Montre-nous ton code (avec les balises [code] et [/code]).

Les ressources IPC SysV (sémaphores, mémoire partagée et file de messages) survivent à la mort du processus. Il y a fort à parier que tu utilises une clé fixe pour allouer ton segment, que celui existe déjà, et que sa taille ne soit pas la bonne puisque tu as modifié ton code.

Fais ipcs depuis le Shell pour voir ce qui traîne sur ton système. Attention : la plupart des ressources déclarées le seront probablement de manière tout-à-fait légitime par d'autres processus. À toi de reconnaître ton segment.

[vever001]

Bonjour et merci pour votre aide,

Donc j'ai choisi de stocker un tableau de structures en mémoire partagée.

En fait j'ai 3 problèmes en ce moment:

1)Lorsque je lis dans mon fichier ligne par ligne avec fgets() je récupère le \r ce qui me fait un retour de ligne quand j'affiche les noms

2)Je n'arrive à récupérer que 2 structures dans le serveur donc j'ai un problème lors de l'écriture après avoir forké je crois...est-ce parce que je n'ai pas encore implémenté les sémaphores? ou parce que j'écris au mauvais endroit?? (avant le exit dans le "case 0" du client)

3)Le fork est-il cohérent dans mon programme ? il crée 5 fils...


Voici mon code:
client :
Qui écrit dans la mémoire partagée après avoir forké 5 fois

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
 
#define SHMKEY 1234567
 
int mem_ID;
void* ptr_mem_partagee;
char tabNoms[80][25];
 
void recupNoms(void);
 
typedef struct coureur{
	char nom[25];
	int temps[3];
	int cibles[1];
	int penalite;
}c;
c candidat[4];
 
int main()
{
 int parent=0, child=0, i, result=0, pid;
 
 if ((mem_ID = shmget(SHMKEY, 5*sizeof(c), 0666 | IPC_CREAT)) < 0) 
 {
  perror("shmget");
  exit(1);
 }
 
 if ((ptr_mem_partagee = shmat(mem_ID, NULL, 0)) == (void*) -1) 
 {
  perror("shmat"); 
  exit(1);
 }  
 
 recupNoms();
 
 for(i=0;i<79;i++) printf("%s \n",tabNoms[i]); 
 
 pid = fork(); //crée un fils
 for (i = 0; i < 5; i++)
 {
  switch (pid)
  {
   case -1:
           //erreur 
           perror("Une erreur est survenue lors du fork()\n");
           exit(99);
   case 0:
           //processus enfant
 
           printf("child %d %d\n",parent, child++); 
	   strcpy(candidat[i].nom,tabNoms[i]);
 
	   printf("candidat %d : %s \n",i+1,candidat[i].nom);
 
	   //on met Ã* jour la structure dans la memoire partagée
 	   *((c*)ptr_mem_partagee + (i*sizeof(c))) = candidat[i]; 
 
           exit(1);	  		
   default:
           //processus parent
           wait(NULL);
 
	   printf("parent %d %d\n", parent++, child);
           pid = fork(); //on crée un nouveau processus enfant
           break;
  }
 }
 
 shmdt(ptr_mem_partagee);  
 
 return 0;
}
 
void recupNoms()
{
 FILE * pFile;
 int i=0;
 
 pFile=fopen("candidats.txt","r");
 if(pFile==NULL)
 {
  perror("fopen");
  exit(1);
 }
 else
 {
  while(!feof(pFile))
  {
   fgets(tabNoms[i], 25, pFile);
   i++;
  } 
  fclose(pFile);
 }
}

serveur:
Qui lit le nom stocké dans chaque structure en mémoire partagée

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
 
#define SHMKEY 1234567
 
int i;
int mem_ID;
void* ptr_mem_partagee;
 
typedef struct coureur{
	char nom[25];
	int temps[3];
	int cibles[1];
	int penalite;
}c;
c candidat[4];
 
int main()
{ 
 if ((mem_ID = shmget(SHMKEY, 5*sizeof(c), 0666 | IPC_CREAT)) < 0) 
 {
  perror("shmget");
  exit(1);
 }
 
 if ((ptr_mem_partagee = shmat(mem_ID, NULL, 0)) == (void*) -1) 
 {
  perror("shmat"); 
  exit(1);
 } 
 
 for(i=0;i<5;i++)
 {
  //on copie le nom (stocké dans la memoire) dans la structure puis on lit
  strcpy(candidat[i].nom,((c*)ptr_mem_partagee+(i*sizeof(c)))->nom); 
  printf("candidat %d : %s\n",i+1,candidat[i].nom);
 }
 
 shmdt(ptr_mem_partagee);
 shmctl(mem_ID, IPC_RMID, 0);
 return 0; 
}

Un tout grand merci à vous

[vever001]

personne pour m'aider ou me mettre sur la bonne voie...