Est-il possible d'affecter une priorité à un module ?

**cartman_94** · 02/10/2013, 16h12

Bonjour

Je développe sur une carte Dimm mx6, avec un processeur ARM Cortex A9 (de chez Freescale).

Dans un module, je génère une IRQ toutes les 500µs, et toutes ces 500µs j’exécute un bout de code (pour faire mes test je fais un calcul factorielle pour mesurer son temps d’exécution).

C'est la que j'ai un problème, mon temps d'exécution double de temps en temps (une fois sur deux lorsque je lance mon module), on m'a dit que mon calcul est préempté. J'ai essayé d'appliquer un patch PREEMPT_RT au linux (3.0.35) mais il est patché par Freescale et le fournisseur de la carte donc impossible de le rendre RT. (trop de modifications subies)

J'ai décidé de "nettoyer" Linux en enlevant toutes les fonctionnalités dont je ne me servirai jamais (usb, touchscreen ....) j'ai gagné en rapidité de temps d'exécution (28µs au lieu de 70µs auparavant) mais mon calcul est toujours préempté (1 fois sur 8 lorsque je lance mon module, y a du mieux mais c'est pas encore ça).

Je voulais savoir si il existe une commande afin de rendre prioritaire mon module pour empêcher qu'il se fasse préempter ?

Si vous connaissez un autre moyen/méthode pour éviter d'être préempté je suis a votre écoute.

Merci d'avance

**Metalman** · 02/10/2013, 16h58

Un linux classique ne sera jamais "non préemptable".
C'est la base des OS "modernes" ET classiques.

Je ne connaissais pas trop "PREEMPT_RT", mais en lisant ça je vois que c'est le patch officiel.
Tant que tu n'auras pas le patch dédié pour faire du temps réel, c'est foutu.
Essaye de voir avec Freescale s'ils n'ont pas un Linux RT à leur sauce.

Ce qui m'inquiète c'est qu'ils emploient : "Ce patch a pour effet de donner au noyau Linux un comportement temps réel dur"
avec :
"Il agit en rendant préemptible la majeure partie du code du noyau, et en particulier les sections critiques, les gestionnaires d'interruptions."
Bref... ça devient juste ultra-ultra préemptible partout... du coup tout le monde a la main quand il veut ! (si on résume à l'arrache, hein !

)

**cartman_94** · 03/10/2013, 08h16

J'ai déjà demandé a Freescale, il n'ont pas de patch pour le rendre RT.

Mais ma question était de savoir si on pouvais rendre un module prioritaire afin de ne pas être interrompu. (un peu comme la commande "chrt" pour les processus)

Sinon on m'a dis d'utiliser les sémaphores/mutex avec jetons pour voir si mon problème persiste toujours. A votre avis est-ce une bonne solution ??

**Metalman** · 04/10/2013, 09h26

Les sémaphores/mutex sont "à priori" des syscalls ou en utilisent... donc ça préemptera dessus à coup sûr.

S'il n'y a aucun patch "temps réel", alors il y aura *toujours* de la préemption plus ou moins prévisible (tu peux être quasiment sûr qu'un appel système fera de la préemption déjà... donc moins tu en mettras, moins ton processus sera coupé).

**cartman_94** · 04/10/2013, 09h53

J'ai trouvé un site qui explique comment rendre son linux RT avec le patch preempt_rt mais il faut faire des modification de la mort et vu mon niveau je ne préfere pas essayer.

On m'a dis qu'il existé un pragma pour éviter la préemption des modules.

1- Déjà c'est quoi un pragma ?
2- Quel pragma choisir ?

**Metalman** · 04/10/2013, 11h28

Alors une pragma... c'est... le "code" pour le précompilateur (cpp dans la suite gcc).
Parfois on les appelles les "pragma comments".

Par exemple, tout ça ce sont des pragmas :

Code :

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

1
2
3
4
5
6
7
#ifndef MON_HEADER_H_
# define MON_HEADER_H_ 42
 
# include <unistd.h>
# include "monfichier.h"
 
#endif /* !MON_HEADER_H_ */

Je ne suis pas un expert en précompilation ni en pragma, mais ça permet déjà de désactiver des bouts de code en fonction de l'architecture cible (par exemple si ma Debian x86 ne connait pas une fonction ou un define, mais que mon Solaris SPARC oui, mais mon NetBSD Alpha n'a pas la bonne valeur... on va ajouter/supprimer/modifier le code source qui sera compilé, grâce au précompilateur) donc d'ajouter de la portabilité....

Et ça permet "aussi" d'ajouter/supprimer des bouts de code si tu le souhaites (par exemple retirer le support du protocole X.25 dans ton kernel, en commentant un "define" qui permet d'activer/désactiver le "ifndef" autour du driver... parce que tu n'as rien qui utilise du X.25 sur ta machine)

Dans ton cas, ça permet de modifier le comportement du kernel, comme l'exemple du driver.

Je ne connais pas assez les patchs RT pour te dire laquelle utiliser. Désolé :s

**grim7reaper** · 04/10/2013, 18h25

Salut,

Envoyé par cartman_94

Je voulais savoir si il existe une commande afin de rendre prioritaire mon module pour empêcher qu'il se fasse préempter ?

Il y a probablement moyen de faire quelque chose en mettant le code que tu veux exécuter sans interruption entre un appel à preempt_disable et preempt_enable.
Je ne suis pas certain que ça soit la meilleure solution, mais à priori ça peut se tenter.
Ou il vaut peut-être mieux passer par un spinlock (ça dépend de ton cas), car ça désactive aussi la préemption.
Dans tout les cas, je te conseille un peu de lecture sur le sujet : Linux Device Drivers, Third Edition, chapitre 5.

Envoyé par cartman_94

On m'a dis qu'il existé un pragma pour éviter la préemption des modules.

1- Déjà c'est quoi un pragma ?
2- Quel pragma choisir ?

Je n’ai jamais entendu parler d’une pragma de ce genre (mais je suis peut-être passé à côté, et tout cas ça sera plutôt étonnant qu’une pragma puisse y faire quelque chose), il y a peut-être eu un abus de langage.
Le meilleur moyen de le savoir et de demander à la personne qui t’a parlé de cette fameuse pragma

**souviron34** · 07/10/2013, 13h07

Envoyé par cartman_94

Dans un module, je génère une IRQ toutes les 500µs, et toutes ces 500µs j’exécute un bout de code (pour faire mes test je fais un calcul factorielle pour mesurer son temps d’exécution).

C'est la que j'ai un problème, mon temps d'exécution double de temps en temps (une fois sur deux lorsque je lance mon module), on m'a dit que mon calcul est préempté. J'ai essayé d'appliquer un patch PREEMPT_RT au linux (3.0.35) mais il est patché par Freescale et le fournisseur de la carte donc impossible de le rendre RT. (trop de modifications subies)

Comment ton "module" est-il lancé ?
Qu'est-ce que c'est que ton "module" ?

Est-ce qu'une fonction appelée par un simple appel à alarm avec le flag realtime :

Code C :

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

1
2
       signal ( SIGALRM, (void (*)())Timer_Expiration );
       setitimer (ITIMER_REAL, &rttimer, &old_rttimer);

ne marcherait pas ???

Normalement le timer est en microsecondes...

**cartman_94** · 07/10/2013, 13h23

@souviron34 : 1) je lance le module par la commande "insmod". Le module transforme un signal (EPIT) en une interruption. J'exécute un bout de code a chaque front montant de l'interruption.
2) Après je n'ai pas essayer de le faire par l'appel d'une alarm comme tu le propose. (il me faut une interruption précise toute les 500µs)

@ManusDei : j'ai désactiver quelques interruptions (pas de la même méthode que toi, mais par la config du kernel en supprimant des options), mais je ne sais vraiment pas lesquelles je peux encore enlever. je te met la liste des interruption qu'il me reste dans cat /proc/interrupts :

CPU0 CPU1 CPU2 CPU3
34: 1 0 0 0 GIC sdma
35: 0 0 0 0 GIC VPU_JPG_IRQ
37: 0 0 0 0 GIC imx-ipuv3
38: 1 0 0 0 GIC imx-ipuv3
39: 0 0 0 0 GIC imx-ipuv3
40: 0 0 0 0 GIC imx-ipuv3
43: 1 0 0 0 GIC galcore interrupt service for 2D
44: 0 0 0 0 GIC VPU_CODEC_IRQ
59: 1823 0 0 0 GIC IMX-uart
75: 0 0 0 0 GIC usb_wakeup
81: 0 0 0 0 GIC THERMAL_ALARM_IRQ
87: 198056 0 0 0 GIC i.MX Timer Tick
88: 27965893 0 0 0 GIC epit, irq_epit
121: 0 0 0 0 GIC dvfs
139: 0 0 0 0 GIC mmdc_1
144: 0 0 0 0 GIC mmdc_1
145: 0 0 0 0 GIC mmdc_1
146: 0 0 0 0 GIC mmdc_1
150: 148952 0 0 0 GIC enet
343: 0 0 0 0 GPIO gpiolib
431: 0 0 0 0 GPIO gpiolib
IPI0: 0 26578 831 81 Timer broadcast interrupts
IPI1: 1273 10358 438 228 Rescheduling interrupts
IPI2: 2 4 6 6 Function call interrupts
IPI3: 2158 2068 4225 4226 Single function call interrupts
IPI4: 0 0 0 0 CPU stop interrupts
LOC: 1749 125 65 43 Local timer interrupts

**souviron34** · 07/10/2013, 14h03

Envoyé par cartman_94

2) Après je n'ai pas essayer de le faire par l'appel d'une alarm comme tu le propose. (il me faut une interruption précise toute les 500µs)

C'est bien ce qu'est censé faire la fonction alarm avec un timer itmerreal....

**cartman_94** · 07/10/2013, 14h32

la fonction "alarm" avec un itimer_real m'évitera d'être préempté ?

**gangsoleil** · 07/10/2013, 15h00

En fait, il y a un probleme conceptuel a rendre un module non preemptable : tu prends un risque de famine sur ton OS.

Ton module se lance toutes les 500 ms, et dure 100ms, ce qui laisse 400ms au systeme pour faire autre chose. Que se passera-t-il si, quelle que soit la raison, ton module prend plus de 500 ms ? Ou bien si le systeme a besoin de plus de 400ms ?

**grim7reaper** · 07/10/2013, 15h19

Envoyé par souviron34

C'est bien ce qu'est censé faire la fonction alarm avec un timer itmerreal....

Il me semble que ce genre de chose n’est pas dispo’ quand on fait du code kernel.
Le C kernel c’est du C freestanding, pas hosted.

**cartman_94** · 10/10/2013, 14h23

Bon j'ai avancé un peux sur le sujet.

@souviron34 : j'ai refait un morceau du code qu'exécute ma machine dans le handler (bien entendu c'est qu'une petite partie mais l'idée est la), afin de voir plus précisément ce que je recherche.

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/gpio.h>
 
#define MXC_INT_EPIT1 88 	//numéro d'interruption EPIT
 
#define IRQ_Time 32 	// Sortie sur GPIO_0 : Oscillo
#define HVL 33			// Sortie sur GPIO_1
#define HVE 34			// Sortie sur GPIO_2
#define HVI 59			// Sortie sur GPIO_7 : Utilisable uniquement en Output
#define Trig 9			// Sortie sur GPIO_4
 
#define HVLEOC 41			// Entrée sur GPIO_5
#define HVEEOC 42			// Entrée sur GPIO_6
#define HVIEOC 35			// Entrée sur GPIO_3
 
int m_TimePeriode = 0;
int m_CurrentStep = 0;
int m_SLoadTimeHVL = 300;	//150ms
int m_SLoadTimeHVE = 100;	//50ms
int m_SLoadTimeHVI = 300;	//150ms
int m_SPeriode = 500;		//250ms
 
	//Handler 
static irqreturn_t gpio_handler(int irq, void * ident)
{
	gpio_set_value(IRQ_Time, 1);
 
		//Action depends of step
	switch (m_CurrentStep)
	{
			//Initialisation des GPIO
		case 0 :
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(HVI, 1);
			m_CurrentStep++;
		break;
 
			//
		case 1 :
			if (gpio_get_value(HVIEOC) == 0)
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVIEOC = 0\n");
				m_CurrentStep = 4;
				}
			gpio_set_value(HVL, 1);
			if(m_TimePeriode <= (m_SLoadTimeHVL - m_SLoadTimeHVE)) break;
			gpio_set_value(HVE, 1);
 
			m_CurrentStep++;
		break;
 
			//
		case 2 :
			if ((gpio_get_value(HVLEOC) == 0) && (gpio_get_value(HVIEOC) == 0))
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVLEOC = 0\n");
				m_CurrentStep = 4;
				}
			if(m_TimePeriode <= m_SLoadTimeHVL) break;
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(Trig, 1);
			m_CurrentStep++;
		break;
 
			//Trig à 0
		case 3 :
			gpio_set_value(Trig, 0);
			m_CurrentStep++;
		break;
 
			//Wait 250ms
		case 4 :
			if(m_TimePeriode <= m_SPeriode) break; 
			m_CurrentStep++;
 
			//Reset
		case 5 :
			m_CurrentStep = 0;
			m_TimePeriode = 0;
		break;
	}
 
	m_TimePeriode++;
	gpio_set_value(IRQ_Time, 0);
 
	return IRQ_HANDLED;
}
 
 
	//Module Init
static int __init gpio_init (void)
{
  int err;
 
	//allocation mémoire pour le IRQ_Time
  if ((err = gpio_request(IRQ_Time, THIS_MODULE->name)) != 0)
    return err;
	//allocation mémoire pour HVL
  if ((err = gpio_request(HVL, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		return err;
	}
	//allocation mémoire pour le HVE
  if ((err = gpio_request(HVE, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		return err;
	}
	//allocation mémoire pour le HVI
  if ((err = gpio_request(HVI, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		return err;
	}
	//allocation mémoire pour le Trig
  if ((err = gpio_request(Trig, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		return err;
	}
	//allocation mémoire pour HVLEOC
  if ((err = gpio_request(HVLEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		return err;
	}
	//allocation mémoire pour HVEEOC
  if ((err = gpio_request(HVEEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		return err;
	}
	//allocation mémoire pour HVIEOC
  if ((err = gpio_request(HVIEOC, THIS_MODULE->name)) != 0)
	{    
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		return err;
	}
 
	//direction IRQ_Time : Output
  if ((err = gpio_direction_output(IRQ_Time,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	}
  	//direction HVL : Output
  if ((err = gpio_direction_output(HVL,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVE : Output
  if ((err = gpio_direction_output(HVE,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVI : Output
  if ((err = gpio_direction_output(HVI,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  	//direction Trig : Output
  if ((err = gpio_direction_output(Trig,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVLEOC : Input
  if ((err = gpio_direction_input(HVLEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVEEOC : Input
  if ((err = gpio_direction_input(HVEEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVIEOC : Input
  if ((err = gpio_direction_input(HVIEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
 
  //declaration IRQ
  if ((err = request_irq(MXC_INT_EPIT1, gpio_handler, IRQF_SHARED, THIS_MODULE->name, THIS_MODULE->name)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
  return 0; 
}
 
	//Module Exit
static void __exit gpio_exit (void)
{
	free_irq(MXC_INT_EPIT1, THIS_MODULE->name);	
	gpio_free(IRQ_Time);
	gpio_free(HVL);
	gpio_free(HVE);
	gpio_free(HVI);
	gpio_free(Trig);
	gpio_free(HVLEOC);
	gpio_free(HVEEOC);
	gpio_free(HVIEOC);
}
 
module_init(gpio_init);
module_exit(gpio_exit);
MODULE_LICENSE("GPL");

Nouvelle problématique :
Je souhaite maintenant envoyé des données de ma carte à mon pc (valeur de mes sorties). J'ai pensé faire une sorte de client(pc)/serveur(carte) en tcp/ip.

Vu que sur ma carte, je suis au niveau kernel j'ai utilisé des ksocket pour communiquer avec mon pc. Avant d'implémenter la comm tcp/ip dans mon module, j'ai testé la comm entre le kernel et mon pc (user space).

C'est magique ça communique.... mais pas exactement comme je le veux (quelques bugs d'affichage). lorsque je veux envoyé un message à partir du client, j'obtiens ceci :

client: serveur: Hello, this is from a kernel thread��)
coucou
client: serveur: coucou
slt
client: serveur: slt
bonjour
client: serveur: bonjour

on voit qu'il affiche a chaque fois "client : serveur : texte". Il faudrait qu'il affiche soit client : quand c'est le client qui envoi un message ou serveur : qu'on le client recoit un message et non les 2.

je vous met le code de mon client.c :

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
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
	#include <stdio.h>
    #include <string.h>
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR -1
    #define closesocket(s) close(s)
    typedef int SOCKET;
    typedef struct sockaddr_in SOCKADDR_IN;
    typedef struct sockaddr SOCKADDR;
 
#include <stdio.h>
#include <stdlib.h>
#define PORT 4444
 
int main(void)
{
    int erreur = 0;
    SOCKET sock;
    SOCKADDR_IN sin;
    char buffer[256];
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Configuration de la connexion */
        sin.sin_addr.s_addr = inet_addr("192.168.101.2");
        sin.sin_family = AF_INET;
        sin.sin_port = htons(PORT);
 
	while (1)
	{
        /* Si l'on a réussi à* se connecter */
        connect(sock, (SOCKADDR*)&sin, sizeof(sin));
		int pid;
        pid=fork();
  	 	if (pid == 0) 
        {
			 /* fils */      
	       	 while(1) 
			{
			printf("client: ");
			scanf("%s",buffer);
        	send(sock,buffer,sizeof(buffer),0);//envoi de ce qu'on a ecrit au serveur
			}         
        }
 
        else
        {
           	/*pere*/
			while(1) 
			{
	     recv(sock,buffer,sizeof(buffer),0);//reception des données du serveur
	     printf("serveur: %s\n",buffer);
	     	} 
        }
	}
        /* On ferme la socket */
        closesocket(sock);
    }
    /* On attend que l'utilisateur tape sur une touche, puis on ferme */
    getchar();
    return EXIT_SUCCESS;
}

Si vous pouvez m'aidez a corriger ces bugs d'affichage sur mon client.c

Merci d'avance

Est-il possible d'affecter une priorité à un module ?

C

Vue hybride

Discussions similaires

Partager

Partager