Option de compilation gcc : sem.h

**Luther13** · 27/12/2004, 20h39

Je suis en train de faire un petit exercice pour apprendre l'utiliation des sémaphores.
Pour cela, j'utilise le header

Code :

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

#include <sys/sem.h>

et je compile est faisant:

gcc -o p1 p1.c

Le compilateur memet alors le warning suivant:

/usr/include/sys/ipc.h:25:3: warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE

Qu'est ce que je dois faire pour ne pas avoir ce warning ?

**Pouic** · 27/12/2004, 21h35

Avant de faire tes includes, tu dois avoir une ligne du type:

Code :

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

#define _XOPEN_SOURCE

ou

Code :

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

#define _SVID_SOURCE

et la, plus de warnings de ce genre

++
Pouic

**kaisse** · 28/12/2004, 00h05

Envoyé par Pouic

Avant de faire tes includes, tu dois avoir une ligne du type:

Code :

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

#define _XOPEN_SOURCE

ou

Code :

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

#define _SVID_SOURCE

et la, plus de warnings de ce genre

++
Pouic

Il serait peut être plus simple de compiler ainsi:

Code :

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

gcc -o p1 -D_XOPEN_SOURCE -D_SVID_SOURCE p1.c

Mais alors, je suis presque persuadé que tu auras des erreurs de la part du linker, puisque ca ne suffit pas. Si tu utilises les sémaphores de "sys/sem.h", tu dois normalement utiliser les pthreads, il te faut donc lier ton code avec la bibliothèque des threads. Donc c'est comme ca:

Code :

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

gcc -o p1 -lpthread p1.c

Et normalement, tu ne devrais avoir aucune macro à définir (au pire, il te faudra peut être ajouter -D_REENTRANT mais c'est pas sur du tout).

**Luther13** · 28/12/2004, 16h06

Merci pour vos reponses,
J'ai effectivement testé les deux solutions:
- La première :

#define _XOPEN_SOURCE

Ne marche pas du tout, j'ai toujours le même warning.

-La deuxième

gcc -o p1 -D_XOPEN_SOURCE -D_SVID_SOURCE p1.c

est excellente. Je n'ai plus de Warning.

Ce qui est satisfaisant.

Par contre, mon petit test ne me satisfait pas du tout

Voici Les trois fichiers de cette application test

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
 
/*
 * fichier p1.c
 * Programme de test de l'utilisation correcte de 
 * la librairie fonctions.c qui permet de creer des semaphores
 * Date Modification: 28 Decembre 2004
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> /* fonction getpid()*/
 
#include "fonctions.h"
 
int main(int argc, char* argv[])
{
	int ID_proc =0;
	int nbre_fois =12;
	int CLEF_SEM =1234;
	int SEM_ID =0;
 
	unsigned int NbreJetons =1; /*Nombre de jetons pour rentrer et sortir de la section critique*/
	int valeur_init =1; /*Valeur d'initialisation du semaphore*/
 
	ID_proc =getpid();	
	srand(ID_proc); /*--initialisation Random --*/
 
	/*-- creation du semaphore  ou recuperation --*/
	SEM_ID =creation_recuperation_sem(CLEF_SEM);
 
	if(argc ==1)
	{
		/*-- initialisation du semaphore --*/
		initialisation_sem(SEM_ID,valeur_init);
	}
 
	do
	{
 
		/* -- Entree dans la section critique*/
		P_sem(SEM_ID,NbreJetons); /* Demande d'autorisation : on prend un jeton*/
		printf("\n Le Process no %d ENTRE \n",ID_proc);
 
		/* -- attente aleatoire */
		sleep(rand()%3);
 
		/* -- Je sors de la section critique */
		printf("\n Le Process no %d SORT dans la section critique\n",ID_proc);
		sleep(rand()%3);
		V_sem(SEM_ID,NbreJetons); /*Sortie : on rend le jeton*/
 
		nbre_fois--;
	}while(nbre_fois >0); 
 
	if(argc <2)
	{
		/*-- destruction du semaphore --*/
		destruction_sem(SEM_ID);
	}
 
	printf("\n --- Fin Programme no:%d\n",ID_proc); 
	return 0;
}

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
#ifndef FON_SEM
#define FON_SEM
 
/*
 * Fichier fonctions.h
 * fichier d'entête des fonctions definies dans le fichier 
 * fonctions.cpp
 */
#include <sys/sem.h>
/* Prototype des fonctions */
int P_sem(int id_sem,unsigned int nbre_jetons);
int V_sem(int id_sem,unsigned int nbre_Jetons);
int creation_recuperation_sem(int clef_sem);
int initialisation_sem(int id_sem,int valeur);
int destruction_sem(int id_sem);
 
#endif

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
106
107
108
 
/*
 * Fichier fonctions.c
 * Regroupe les fonctions necessaires pour les semaphores
 * Date Modification: 28 Decembre 2004
 */
 
#include "fonctions.h"
 
 
 
/*------------------------------------------------------
 * Entrée dans la section critique
 * Si la demande est refusée, le processus
 * sera mis en file d'attente
 * 
 * Paramètres:
 * id_sem :ID  du sémaphore
 * nbre_jetons: Nombre de jetons que le processus souhaite prendre
 * 		Ceci est un entier non signé donc positif
 */
int P_sem(int id_sem,unsigned int nbre_jetons)
{
	int resultat =0;
	struct sembuf A;
	A.sem_num =0;
	A.sem_flg =SEM_UNDO;
	A.sem_op  = -nbre_jetons;
	/*sem_op <0  donc le process PREND  un jeton
	 * cela signifie qu'il se met en file d'attente
	 *
	 */
 
 
	resultat = semop(id_sem,&A,0);
	return resultat;
}
 
/*------------------------------------------------------
 * Sortie de la section critique
 * Paramètres:
 * id_sem :ID  du sémaphore
 * nbre_jetons: Nombre de jetons que le processus souhaite rendre
 * 		Ceci est un entier non signé donc positif
 */
int V_sem(int id_sem,unsigned int nbre_jetons)
{
	int resultat =0;
	struct sembuf A;
	A.sem_num =0;
	A.sem_flg =SEM_UNDO;
	A.sem_op  =nbre_jetons;
	/*sem_op >0  donc le process REND  un jeton
	 * cela signifie qu'il quitte la section critique
	 *
	 */
 
	resultat = semop(id_sem,&A,0);
	return resultat;
}
 
 
/*------------------------------------------------------
 * Création d'un sémaphore ou Récuperation de l'ID du semaphore
 * Paramètre: Clef du sémaphore
 *	C'est la clé commune et elle est connue de tous les process qui 
 * 	appelle ce semaphore
 */
int creation_recuperation_sem(int clef_sem)
{
	int id_sem =0;
	id_sem =semget(clef_sem,1,0666 |IPC_CREAT);
	return id_sem;
}
 
 
/*------------------------------------------------------
 * Paramètres:
 * id_sem :ID  du sémaphore
 * fonction permettant d'initialiser le semaphore
 * dans notre cas, on l'initialise à 0 ou à 1
 */
int initialisation_sem(int id_sem,int valeur)
{
 
	int resultat =0;
	/*Comme nous initialisons à une valeur int
	 * Nous n'avons pas besoins des autres structures de l'union
	*/
	resultat = semctl(id_sem,0,SETVAL,valeur);
	return resultat;
	/* Si resultat vaut -1 c'est qu'il y  eu echec
	 * On peut recuperer errno pour savoir les raisons de cet echec
	 */
}
 
/*------------------------------------------------------
 * Paramètres:
 * id_sem :ID du sémaphore
 * 	Seul le Propriétaire ou superutilisateur du semaphore a la possibilité de 
 * 	le detruire.
 */
int destruction_sem(int id_sem)
{
	int resultat =0;
	resultat = semctl(id_sem,0,IPC_RMID);
	return resultat;
}

Ici, la ressource critique, c'est la sortie standard.
Pour tester foonctions.c,
j'esxécute p1 dans un script

#!/bin/bash

#lance le premier processus
p1 &
#lance le second processus
p1 argument

Sur ma sortie standard, les deux processus entre ensemble dans la section critique.
Ce qui n'est pas du tout le but recherché.

**kaisse** · 28/12/2004, 21h28

Couc', content que les -D_XOPEN_SOURCE et -D_SVID_SOURCE fonctionnent. Oublie mon craquage sur les pthreads, je confondais en plus sys/sem.h et semaphore.h.

Je ne sais pas trop où est l'erreur dans ton code, mais je pense que ceci peut en génerer une:

Code :

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

resultat = semop(id_sem,&A,0);

Si tu fais un man semop, il te dira que le dernier argument est le nombre d'opérations que tu souhaites appliquer (en l'occurence, et dans 95% des cas, 1). Il est aussi stipulé que si cette valeur est égale à 0, semop renvoie -1 et fixe errno à je sais plus trop quoi. Donc, remplace tous tes semop (machin, bidule, 0) par des semop (machin, bidule, 1). Entre deux tests qui ne marchent pas, n'hésite pas à changer les key_t passés en première arguments de semget: il se peut que tu ais créé un sémaphore une fois, qu'il n'a pas pu libérer, et depuis, il le considère comme alloué même après la fin du programme: j'ai eu cette erreur toute l'aprés-midi (et oui, coincidence, je suis en train de faire un DM sur les sémaphores et la mémoire partagée). En ce qui me concerne, pour bien cerner les erreurs, à chaque appel de semget, semop et semctl, je sauvegardais la valeur de retour, et si elle était égale à -1, je faisais appel à une fonction de gestion d'erreur. Laquelle n'est en fait qu'un gros switch qui regroupe toutes les valeurs possibles que peut prendre errno suite à ces fonctions. Certes c'est très chiant, mais ca facilite beaucoup le deboggage.

**Luther13** · 29/12/2004, 10h46

Ouf Merci,
C'est excellent, Je devrais mettre 1 au lieu de 0 comme nombre n'opérations dans les semop.

**alveric** · 29/12/2004, 10h54

Concernant ton warning de compilation, un google m'a donné http://www.network-theory.co.uk/docs...cintro_26.html, qui indique à quoi ça corespond.

**Luther13** · 29/12/2004, 11h20

OK,
Si j'ai bien compris l'option _GNU_SOURCE
peut remplacer les deux options ? _XOPEN_SOURCE et _SVID_SOURCE

Voici mon nouveau makefile:

all: p1

p1 :fonctions.o p1.o
gcc -o p1 fonctions.o p1.o

fonctions.o : fonctions.c
gcc -o fonctions.o -D_GNU_SOURCE -c fonctions.c

p1.o : p1.c
gcc -o p1.o -D_GNU_SOURCE -c p1.c

J'obtiens alors des erreurs du genre

[luther13@u-strasbg tache]$ make
gcc -o p1 fonctions.o p1.o
p1.o(.text+0x0): In function `P_sem':
: multiple definition of `P_sem'
fonctions.o(.text+0x0): first defined here
p1.o(.text+0x99): In function `V_sem':
: multiple definition of `V_sem'

Pourtant, le code source n'a pas changé !
J'aimerais vraiment

: savoir l'impacte de ces différentes option.

**kaisse** · 29/12/2004, 12h29

Envoyé par Luther13

J'obtiens alors des erreurs du genre

[luther13@u-strasbg tache]$ make
gcc -o p1 fonctions.o p1.o
p1.o(.text+0x0): In function `P_sem':
: multiple definition of `P_sem'
fonctions.o(.text+0x0): first defined here
p1.o(.text+0x99): In function `V_sem':
: multiple definition of `V_sem'

Pourtant, le code source n'a pas changé !
J'aimerais vraiment

: savoir l'impacte de ces différentes option.

C'est bizarre, ca ressemble à un problème de multiple inclusion, pourtant tu fais bien un

Code :

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

1
2
3
#ifndef
#define
#endif

Il semblerait que le seul facteur soit le -D_GNU_SOURCE mais je ne vois pas pourquoi ca provoque cette erreur, puisque en effet, d'après le lien, il se contente juste de définir tous les standards UNIX avec une propriété pour POSIX en cas de conflit ...

Option de compilation gcc : sem.h

Linux

Discussions similaires

Partager

Partager