1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.31
4: Copyright (C) 1989-2019 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: Procédure de lecture atomique
29: ================================================================================
30: Entrée :
31: --------------------------------------------------------------------------------
32: Sortie :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: ssize_t
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: {
73: return(((ssize_t) longueur_tampon) -
74: ((ssize_t) longueur_residuelle));
75: }
76:
77: if ((longueur_lue == -1) && (errno == EINTR))
78: {
79: scrutation_interruptions(s_etat_processus);
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: {
91: if (longueur_lue < (ssize_t) ((longueur_residuelle > PIPE_BUF)
92: ? PIPE_BUF : longueur_residuelle))
93: {
94: pointeur += longueur_lue;
95: longueur_residuelle -= (size_t) longueur_lue;
96:
97: return(((ssize_t) longueur_tampon) -
98: ((ssize_t) longueur_residuelle));
99: }
100: }
101: }
102:
103: pointeur += longueur_lue;
104: longueur_residuelle -= (size_t) longueur_lue;
105: }
106:
107: return(((ssize_t) longueur_tampon) - ((ssize_t) longueur_residuelle));
108: }
109:
110:
111: /*
112: ================================================================================
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: ================================================================================
199: Procédure d'écriture atomique
200: ================================================================================
201: Entrée :
202: --------------------------------------------------------------------------------
203: Sortie :
204: --------------------------------------------------------------------------------
205: Effets de bord : néant
206: ================================================================================
207: */
208:
209: ssize_t
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: {
245: scrutation_interruptions(s_etat_processus);
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: {
262: scrutation_interruptions(s_etat_processus);
263: nanosleep(&attente, NULL);
264: }
265: }
266:
267: pointeur += longueur_ecrite;
268: longueur_residuelle -= (size_t) longueur_ecrite;
269: }
270:
271: return((ssize_t) longueur_tampon);
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