![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_interruptions.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to gestion_interruptions.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.3 ! bertrand 3: RPL/2 (R) version 4.0.11
1.1 bertrand 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction d'affectation des interruptions aux différentes queues
29: ================================================================================
30: Entrées : s_etat_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: affectation_interruptions_logicielles(struct_processus *s_etat_processus)
40: {
41: int interruption;
42:
43: sig_atomic_t registre;
44:
45: volatile struct_liste_chainee *l_element_courant;
46:
47: struct_objet *s_objet_processus;
48:
49: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
50: {
51: (*s_etat_processus).erreur_systeme = d_es_processus;
52: return;
53: }
54:
55: if ((*s_etat_processus).var_volatile_requete_arret == -1)
56: {
57: // Si une requête d'arrêt est reçue par le processus durant la
58: // phase de verrouillage, on n'empile rien car la structure
59: // processus peut déjà être libérée par le thread de surveillance.
60:
61: (*s_etat_processus).nombre_interruptions_non_affectees = 0;
62:
63: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
64: {
65: (*s_etat_processus).erreur_systeme = d_es_processus;
66: return;
67: }
68:
69: return;
70: }
71:
72: l_element_courant = (*s_etat_processus).l_base_pile_processus;
73:
74: while(l_element_courant != NULL)
75: {
76: /*
77: * On regarde s'il y a quelque chose dans le pipe d'interruptions
78: * du processus fils.
79: *
80: * Cette routine est interruptible par l'arrivée d'une interruption
81: * de type SWI.
82: */
83:
84: if ((*(*l_element_courant).donnee).type != PRC)
85: {
86: pthread_mutex_unlock(&((*s_etat_processus).mutex));
87:
88: (*s_etat_processus).erreur_systeme = d_es_processus;
89: return;
90: }
91:
92: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
93: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
94: {
95: pthread_mutex_unlock(&((*s_etat_processus).mutex));
96:
97: (*s_etat_processus).erreur_systeme = d_es_processus;
98: return;
99: }
100:
101: if ((*(*((struct_processus_fils *) (*(*l_element_courant).donnee)
102: .objet)).thread).nombre_interruptions_dans_pipe > 0)
103: {
104: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
105: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
106:
107: if (read_atomic(s_etat_processus, (*(*((struct_processus_fils *)
108: (*(*l_element_courant).donnee)
109: .objet)).thread).pipe_interruptions[0], &interruption,
110: sizeof(interruption)) == sizeof(interruption))
111: {
112: if (registre == 0)
113: {
114: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
115: == -1)
116: {
117: (*s_etat_processus).var_volatile_requete_arret = -1;
118: }
119:
120: (*s_etat_processus).var_volatile_traitement_retarde_stop
121: = registre;
122: }
123:
124: if ((interruption < 1) || (interruption >
125: d_NOMBRE_INTERRUPTIONS))
126: {
127: pthread_mutex_unlock(&((*s_etat_processus).mutex));
128: pthread_mutex_unlock(&((*(*((struct_processus_fils *)
129: (*(*l_element_courant).donnee).objet)).thread)
130: .mutex));
131:
132: (*s_etat_processus).erreur_systeme =
133: d_es_interruption_invalide;
134: return;
135: }
136:
137: /*
138: * On ne pousse dans les queues des interruptions que les
139: * interruptions qui ne sont pas masquées.
140: */
141:
142: if ((*s_etat_processus).masque_interruptions[interruption - 1]
143: != 'I')
144: {
145: if ((s_objet_processus = copie_objet(s_etat_processus,
146: (*l_element_courant).donnee, 'P')) == NULL)
147: {
148: pthread_mutex_unlock(&((*s_etat_processus).mutex));
149: pthread_mutex_unlock(&((*(*((struct_processus_fils *)
150: (*(*l_element_courant).donnee).objet)).thread)
151: .mutex));
152:
153: (*s_etat_processus).erreur_systeme =
154: d_es_allocation_memoire;
155: return;
156: }
157:
158: if (empilement(s_etat_processus, &((*s_etat_processus)
159: .pile_origine_interruptions[interruption - 1]),
160: s_objet_processus) == d_erreur)
161: {
162: pthread_mutex_unlock(&((*s_etat_processus).mutex));
163: pthread_mutex_unlock(&((*(*((struct_processus_fils *)
164: (*(*l_element_courant).donnee).objet)).thread)
165: .mutex));
166: return;
167: }
168:
169: (*s_etat_processus).queue_interruptions[interruption - 1]++;
170: (*s_etat_processus).nombre_interruptions_en_queue++;
171:
172: if ((*s_etat_processus).debug == d_vrai)
173: if (((*s_etat_processus).type_debug &
174: d_traitement_interruption) != 0)
175: {
176: if ((*(*((struct_processus_fils *) (*s_objet_processus)
177: .objet)).thread).processus_detache == d_vrai)
178: {
179: if ((*s_etat_processus).langue == 'F')
180: {
181: printf("[%d] Interruption logicielle "
182: "%d empilée en "
183: "provenance du processus %d\n",
184: (int) getpid(), interruption,
185: (int) (*(*((struct_processus_fils *)
186: (*s_objet_processus).objet)).thread)
187: .pid);
188: }
189: else
190: {
191: printf("[%d] Software interrupt %d stacked from"
192: " process %d\n", interruption,
193: (int) getpid(),
194: (int) (*(*((struct_processus_fils *)
195: (*s_objet_processus).objet)).thread)
196: .pid);
197: }
198: }
199: else
200: {
201: if ((*s_etat_processus).langue == 'F')
202: {
203: printf("[%d] Interruption logicielle "
204: "%d empilée en "
205: "provenance du thread %lld\n",
206: (int) getpid(), interruption, (integer8)
207: (*(*((struct_processus_fils *)
208: (*s_objet_processus).objet)).thread)
209: .tid);
210: }
211: else
212: {
213: printf("[%d] Software interrupt %d stacked from"
214: " process %lld\n", interruption,
215: (int) getpid(), (integer8)
216: (*(*((struct_processus_fils *)
217: (*s_objet_processus).objet)).thread)
218: .tid);
219: }
220: }
221:
222: fflush(stdout);
223: }
224: }
225:
226: (*(*((struct_processus_fils *) (*(*l_element_courant).donnee)
227: .objet)).thread).nombre_interruptions_dans_pipe--;
228: (*s_etat_processus).nombre_interruptions_non_affectees--;
229: }
230: else
231: {
232: pthread_mutex_unlock(&((*s_etat_processus).mutex));
233: pthread_mutex_unlock(&((*(*((struct_processus_fils *)
234: (*(*l_element_courant).donnee).objet)).thread).mutex));
235:
236: if (registre == 0)
237: {
238: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
239: == -1)
240: {
241: (*s_etat_processus).var_volatile_requete_arret = -1;
242: }
243:
244: (*s_etat_processus).var_volatile_traitement_retarde_stop
245: = registre;
246: }
247:
248: (*s_etat_processus).erreur_systeme = d_es_interruption_invalide;
249: return;
250: }
251: }
252:
253: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
254: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
255: {
256: pthread_mutex_unlock(&((*s_etat_processus).mutex));
257:
258: (*s_etat_processus).erreur_systeme = d_es_processus;
259: return;
260: }
261:
262: l_element_courant = (*l_element_courant).suivant;
263: }
264:
265: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
266: {
267: (*s_etat_processus).erreur_systeme = d_es_processus;
268: return;
269: }
270:
271: return;
272: }
273:
274:
275: /*
276: ================================================================================
277: Fonction de traitement des différentes interruptions
278: ================================================================================
279: Entrées : s_etat_processus
280: --------------------------------------------------------------------------------
281: Sorties :
282: --------------------------------------------------------------------------------
283: Effets de bord : néant
284: ================================================================================
285: */
286:
287: void
288: traitement_interruptions_logicielles(struct_processus *s_etat_processus)
289: {
290: int i;
291:
292: logical1 drapeau_erreur;
293: logical1 processus;
294: logical1 registre_arret_si_exception;
295:
296: pid_t pid;
297: pthread_t tid;
298:
299: struct_objet *s_objet_processus;
300:
301: unsigned char registre;
302: unsigned char tampon[22];
303:
304: /*
305: * Les interruptions sont non interruptibles.
306: */
307:
308: if (((*s_etat_processus).traitement_interruption == 'Y') ||
309: ((*s_etat_processus).traitement_interruptible == 'N'))
310: {
311: return;
312: }
313:
314: registre = (*s_etat_processus).traitement_interruption;
315: (*s_etat_processus).traitement_interruption = 'Y';
316:
317: /*
318: * Lancement d'une interruption. Les interruptions sont d'autant plus
319: * prioritaires que leur numéro est faible.
320: */
321:
322: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
323: {
324: pid = 0;
325: tid = 0;
326: processus = d_faux;
327:
328: if ((*s_etat_processus).queue_interruptions[i] > 0)
329: {
330: if ((*s_etat_processus).masque_interruptions[i] == 'N')
331: {
332: /*
333: * Exécution de la i-ème interruption si celle-ci existe. Dans
334: * le cas contraire, une erreur d'exécution est renvoyée.
335: */
336:
337: if (((*s_etat_processus).corps_interruptions[i] != NULL) &&
338: ((*s_etat_processus).pile_origine_interruptions[i]
339: != NULL))
340: {
341: if (depilement(s_etat_processus, &((*s_etat_processus)
342: .pile_origine_interruptions[i]),
343: &s_objet_processus) == d_erreur)
344: {
345: (*s_etat_processus).traitement_interruption =
346: registre;
347: (*s_etat_processus).erreur_execution =
348: d_ex_interruption_invalide;
349: return;
350: }
351:
352: if (empilement(s_etat_processus, &((*s_etat_processus)
353: .l_base_pile), s_objet_processus) == d_erreur)
354: {
355: (*s_etat_processus).traitement_interruption =
356: registre;
357: return;
358: }
359:
360: if ((*s_etat_processus).debug == d_vrai)
361: if (((*s_etat_processus).type_debug &
362: d_traitement_interruption) != 0)
363: {
364: if ((*s_etat_processus).langue == 'F')
365: {
366: if ((processus = (*(*((struct_processus_fils *)
367: (*s_objet_processus).objet)).thread)
368: .processus_detache) == d_faux)
369: {
370: printf("[%d] Traitement de l'interruption "
371: "logicielle %d en provenance du thread "
372: "%llu\n", (int) getpid(), i + 1,
373: (unsigned long long)
374: (tid = (*(*((struct_processus_fils *)
375: (*s_objet_processus).objet)).thread)
376: .tid));
377: }
378: else
379: {
380: printf("[%d] Traitement de l'interruption "
381: "logicielle %d en provenance du "
382: "processus "
383: "%d\n", (int) getpid(), i + 1, (int)
384: (pid = (*(*((struct_processus_fils *)
385: (*s_objet_processus).objet)).thread)
386: .pid));
387: }
388: }
389: else
390: {
391: if ((processus = (*(*((struct_processus_fils *)
392: (*s_objet_processus).objet)).thread)
393: .processus_detache) == d_faux)
394: {
395: printf("[%d] Start software interrupt "
396: "%d from thread "
397: "%llu\n", (int) getpid(), i + 1,
398: (unsigned long long)
399: (tid = (*(*((struct_processus_fils *)
400: (*s_objet_processus).objet)).thread)
401: .tid));
402: }
403: else
404: {
405: printf("[%d] Start software interrupt "
406: "%d from process "
407: "%d\n", (int) getpid(), i + 1, (int)
408: (pid = (*(*((struct_processus_fils *)
409: (*s_objet_processus).objet)).thread)
410: .pid));
411: }
412: }
413:
414: fflush(stdout);
415: }
416:
417: (*s_etat_processus).nombre_interruptions_en_queue--;
418: (*s_etat_processus).queue_interruptions[i]--;
419:
420: registre_arret_si_exception =
421: (*s_etat_processus).arret_si_exception;
422: (*s_etat_processus).arret_si_exception = d_vrai;
423:
424: if ((*s_etat_processus).profilage == d_vrai)
425: {
426: sprintf(tampon, "Software interrupt %-2d", i + 1);
427: profilage(s_etat_processus, tampon);
428:
429: if ((*s_etat_processus).erreur_systeme != d_es)
430: {
431: return;
432: }
433: }
434:
435: drapeau_erreur = evaluation(s_etat_processus,
436: (*s_etat_processus).corps_interruptions[i], 'E');
437:
438: if ((*s_etat_processus).profilage == d_vrai)
439: {
440: profilage(s_etat_processus, NULL);
441: }
442:
443: if (drapeau_erreur == d_absence_erreur)
444: {
445: (*s_etat_processus).arret_si_exception =
446: registre_arret_si_exception;
447: }
448: else
449: {
450: if ((((*s_etat_processus).erreur_execution != d_ex) ||
451: ((*s_etat_processus).exception != d_ep) ||
452: ((*s_etat_processus).erreur_systeme != d_es)) &&
453: ((*s_etat_processus).core == d_vrai) &&
454: ((*s_etat_processus)
455: .var_volatile_traitement_sigint == 0))
456: {
457: printf("\n");
458:
459: if ((*s_etat_processus).langue == 'F')
460: {
461: printf("+++Information : "
462: "Génération du fichier rpl-core "
463: "[%d]\n", (int) getpid());
464: }
465: else
466: {
467: printf("+++Information : "
468: "Writing rpl-core file [%d]\n",
469: (int) getpid());
470: }
471:
472: rplcore(s_etat_processus);
473:
474: if ((*s_etat_processus).langue == 'F')
475: {
476: printf("+++Information : "
477: "Processus tracé [%d]\n",
478: (int) getpid());
479: }
480: else
481: {
482: printf("+++Information : Done [%d]\n",
483: (int) getpid());
484: }
485:
486: printf("\n");
487: fflush(stdout);
488: }
489:
490: }
491:
492: if ((*s_etat_processus).debug == d_vrai)
493: if (((*s_etat_processus).type_debug &
494: d_traitement_interruption) != 0)
495: {
496: if ((*s_etat_processus).langue == 'F')
497: {
498: if (processus == d_faux)
499: {
500: printf("[%d] Fin de l'interruption logicielle"
501: " %d en provenance du thread %llu\n",
502: (int) getpid(), i + 1,
503: (unsigned long long) tid);
504: }
505: else
506: {
507: printf("[%d] Fin de l'interruption logicielle"
508: " %d en provenance du processus %d\n",
509: (int) getpid(), i + 1, (int) pid);
510: }
511: }
512: else
513: {
514: if (processus == d_faux)
515: {
516: printf("[%d] Stop software interrupt "
517: "%d from thread "
518: "%llu\n", (int) getpid(), i + 1,
519: (unsigned long long) pid);
520: }
521: else
522: {
523: printf("[%d] Stop software interrupt "
524: "%d from process "
525: "%d\n", (int) getpid(), i + 1,
526: (int) pid);
527: }
528: }
529:
530: fflush(stdout);
531: }
532:
533: if ((drapeau_erreur == d_erreur) &&
534: ((*s_etat_processus).erreur_execution == d_ex))
535: {
536: if (((*s_etat_processus).erreur_execution == d_ex) &&
537: ((*s_etat_processus).erreur_systeme == d_es))
538: {
539: (*s_etat_processus).erreur_execution =
540: d_ex_erreur_evaluation;
541: }
542: }
543: }
544: else
545: {
546: (*s_etat_processus).erreur_execution =
547: d_ex_interruption_invalide;
548: }
549: }
550: }
551: }
552:
553: (*s_etat_processus).traitement_interruption = registre;
554:
555: return;
556: }
557:
558: // vim: ts=4