Annotation of rpl/src/operations_atomiques.c, revision 1.71
1.1 bertrand 1: /*
2: ================================================================================
1.70 bertrand 3: RPL/2 (R) version 4.1.31
1.69 bertrand 4: Copyright (C) 1989-2019 Dr. BERTRAND Joël
1.1 bertrand 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:
1.12 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Procédure de lecture atomique
29: ================================================================================
30: Entrée :
31: --------------------------------------------------------------------------------
32: Sortie :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
1.12 bertrand 38: ssize_t
1.1 bertrand 39: read_atomic(struct_processus *s_etat_processus,
40: int descripteur, void *tampon, size_t longueur_tampon)
41: {
42: logical1 drapeau;
43:
44: size_t longueur_residuelle;
45: ssize_t longueur_lue;
46:
47: struct timespec attente;
48:
49: void *pointeur;
50:
51: longueur_residuelle = longueur_tampon;
52: pointeur = tampon;
53:
54: attente.tv_sec = 0;
55: attente.tv_nsec = GRANULARITE_us * 1000;
56:
57: while(longueur_residuelle != 0)
58: {
59: errno = 0;
60: longueur_lue = 0;
61:
62: while(longueur_lue == 0)
63: {
64: do
65: {
66: longueur_lue = read(descripteur, pointeur,
67: (longueur_residuelle > PIPE_BUF)
68: ? PIPE_BUF : longueur_residuelle);
69:
70: if ((longueur_lue == 0) &&
71: (longueur_tampon == longueur_residuelle))
72: {
1.44 bertrand 73: return(((ssize_t) longueur_tampon) -
74: ((ssize_t) longueur_residuelle));
1.1 bertrand 75: }
76:
77: if ((longueur_lue == -1) && (errno == EINTR))
78: {
1.30 bertrand 79: scrutation_interruptions(s_etat_processus);
1.1 bertrand 80: nanosleep(&attente, NULL);
81: drapeau = d_vrai;
82: }
83: else
84: {
85: drapeau = d_faux;
86: }
87: } while(drapeau == d_vrai);
88:
89: if (longueur_lue != 0)
90: {
1.66 bertrand 91: if (longueur_lue < (ssize_t) ((longueur_residuelle > PIPE_BUF)
92: ? PIPE_BUF : longueur_residuelle))
1.1 bertrand 93: {
94: pointeur += longueur_lue;
1.44 bertrand 95: longueur_residuelle -= (size_t) longueur_lue;
1.1 bertrand 96:
1.44 bertrand 97: return(((ssize_t) longueur_tampon) -
98: ((ssize_t) longueur_residuelle));
1.1 bertrand 99: }
100: }
101: }
102:
103: pointeur += longueur_lue;
1.44 bertrand 104: longueur_residuelle -= (size_t) longueur_lue;
1.1 bertrand 105: }
106:
1.44 bertrand 107: return(((ssize_t) longueur_tampon) - ((ssize_t) longueur_residuelle));
1.1 bertrand 108: }
109:
110:
111: /*
112: ================================================================================
1.71 ! bertrand 113: Procédure de lecture atomique interruptible par var_volatile_requete_arret
! 114: ================================================================================
! 115: Entrée :
! 116: --------------------------------------------------------------------------------
! 117: Sortie :
! 118: --------------------------------------------------------------------------------
! 119: Effets de bord : néant
! 120: ================================================================================
! 121: */
! 122:
! 123: ssize_t
! 124: read_atomic_signal(struct_processus *s_etat_processus,
! 125: int descripteur, void *tampon, size_t longueur_tampon)
! 126: {
! 127: logical1 drapeau;
! 128:
! 129: size_t longueur_residuelle;
! 130: ssize_t longueur_lue;
! 131:
! 132: struct timespec attente;
! 133:
! 134: void *pointeur;
! 135:
! 136: longueur_residuelle = longueur_tampon;
! 137: pointeur = tampon;
! 138:
! 139: attente.tv_sec = 0;
! 140: attente.tv_nsec = GRANULARITE_us * 1000;
! 141:
! 142: while(longueur_residuelle != 0)
! 143: {
! 144: errno = 0;
! 145: longueur_lue = 0;
! 146:
! 147: while(longueur_lue == 0)
! 148: {
! 149: do
! 150: {
! 151: longueur_lue = read(descripteur, pointeur,
! 152: (longueur_residuelle > PIPE_BUF)
! 153: ? PIPE_BUF : longueur_residuelle);
! 154:
! 155: if (((longueur_lue == 0) &&
! 156: (longueur_tampon == longueur_residuelle)) ||
! 157: ((*s_etat_processus).var_volatile_requete_arret == -1))
! 158: {
! 159: return(((ssize_t) longueur_tampon) -
! 160: ((ssize_t) longueur_residuelle));
! 161: }
! 162:
! 163: if ((longueur_lue == -1) && (errno == EINTR))
! 164: {
! 165: scrutation_interruptions(s_etat_processus);
! 166: nanosleep(&attente, NULL);
! 167: drapeau = d_vrai;
! 168: }
! 169: else
! 170: {
! 171: drapeau = d_faux;
! 172: }
! 173: } while(drapeau == d_vrai);
! 174:
! 175: if (longueur_lue != 0)
! 176: {
! 177: if (longueur_lue < (ssize_t) ((longueur_residuelle > PIPE_BUF)
! 178: ? PIPE_BUF : longueur_residuelle))
! 179: {
! 180: pointeur += longueur_lue;
! 181: longueur_residuelle -= (size_t) longueur_lue;
! 182:
! 183: return(((ssize_t) longueur_tampon) -
! 184: ((ssize_t) longueur_residuelle));
! 185: }
! 186: }
! 187: }
! 188:
! 189: pointeur += longueur_lue;
! 190: longueur_residuelle -= (size_t) longueur_lue;
! 191: }
! 192:
! 193: return(((ssize_t) longueur_tampon) - ((ssize_t) longueur_residuelle));
! 194: }
! 195:
! 196:
! 197: /*
! 198: ================================================================================
1.1 bertrand 199: Procédure d'écriture atomique
200: ================================================================================
201: Entrée :
202: --------------------------------------------------------------------------------
203: Sortie :
204: --------------------------------------------------------------------------------
205: Effets de bord : néant
206: ================================================================================
207: */
208:
1.12 bertrand 209: ssize_t
1.1 bertrand 210: write_atomic(struct_processus *s_etat_processus,
211: int descripteur, void *tampon, size_t longueur_tampon)
212: {
213: logical1 drapeau;
214:
215: size_t longueur_residuelle;
216: ssize_t longueur_ecrite;
217:
218: struct timespec attente;
219:
220: void *pointeur;
221:
222: longueur_residuelle = longueur_tampon;
223: pointeur = tampon;
224:
225: attente.tv_sec = 0;
226: attente.tv_nsec = GRANULARITE_us * 1000;
227:
228: while(longueur_residuelle != 0)
229: {
230: errno = 0;
231: longueur_ecrite = 0;
232:
233: while(longueur_ecrite == 0)
234: {
235: do
236: {
237: longueur_ecrite = write(descripteur, pointeur,
238: (longueur_residuelle > PIPE_BUF)
239: ? PIPE_BUF : longueur_residuelle);
240:
241: if (longueur_ecrite == -1)
242: {
243: if (errno == EINTR)
244: {
1.30 bertrand 245: scrutation_interruptions(s_etat_processus);
1.1 bertrand 246: nanosleep(&attente, NULL);
247: drapeau = d_vrai;
248: }
249: else // EPIPE
250: {
251: return(-1);
252: }
253: }
254: else
255: {
256: drapeau = d_faux;
257: }
258: } while(drapeau == d_vrai);
259:
260: if (longueur_ecrite == 0)
261: {
1.30 bertrand 262: scrutation_interruptions(s_etat_processus);
1.1 bertrand 263: nanosleep(&attente, NULL);
264: }
265: }
266:
267: pointeur += longueur_ecrite;
1.44 bertrand 268: longueur_residuelle -= (size_t) longueur_ecrite;
1.1 bertrand 269: }
270:
1.44 bertrand 271: return((ssize_t) longueur_tampon);
1.1 bertrand 272: }
273:
274: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to operations_atomiques.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src