![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to semaphores.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to semaphores.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.5 bertrand 3: RPL/2 (R) version 4.0.18
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:
1.6 bertrand 23: #include "rpl-conv.h"
24:
1.1 bertrand 25: #ifdef SEMAPHORES_NOMMES
26:
27: /*
28: ================================================================================
29: Fonctions d'émulation de sémaphores anonymes
30: ================================================================================
31: Entrées :
32: --------------------------------------------------------------------------------
33: Sorties :
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: sem_t *
40: sem_init2(unsigned int valeur, enum t_semaphore semaphore)
41: {
42: snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
1.10 bertrand 43: "/RPL-SEM-%d-%llu-%d", (int) getpid(),
1.1 bertrand 44: (unsigned long long) pthread_self(),
45: (int) semaphore);
46: return(sem_open(noms_semaphores[semaphore], O_CREAT,
47: (S_IRUSR | S_IWUSR), valeur));
48: }
49:
50: int
51: sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore)
52: {
53: sem_close(semaphore_p);
54: return(sem_unlink(noms_semaphores[semaphore]));
55: }
56:
57: #undef sem_post
58: #undef sem_wait
59: #undef sem_trywait
60:
61: int
62: sem_getvalue2(sem_t *semaphore, int *valeur)
63: {
64: int i;
65:
66: logical1 drapeau_fin;
67:
68: pthread_mutex_lock(&mutex_sem);
69:
70: (*valeur) = 0;
71: drapeau_fin = d_faux;
72:
73: do
74: {
75: if (sem_trywait(semaphore) == -1)
76: {
77: if (errno == EAGAIN)
78: {
79: // Le sémaphore avait une valeur nulle
80: drapeau_fin = d_vrai;
81: }
82: else
83: {
84: // Autre erreur
85: pthread_mutex_unlock(&mutex_sem);
86: return(-1);
87: }
88: }
89: else
90: {
91: (*valeur)++;
92: }
93: } while(drapeau_fin == d_faux);
94:
95: for(i = 0; i < (*valeur); i++)
96: {
97: if (sem_post(semaphore) != 0)
98: {
99: pthread_mutex_unlock(&mutex_sem);
100: return(-1);
101: }
102: }
103:
104: pthread_mutex_unlock(&mutex_sem);
105: return(0);
106: }
107:
108: #endif
109:
1.8 bertrand 110: #ifdef SEMAPHORES_SYSV
1.6 bertrand 111:
112: /*
113: ================================================================================
114: Fonctions d'émulation de sémaphores POSIX en fonction des sémaphores SysV
115: ================================================================================
116: Entrées :
117: --------------------------------------------------------------------------------
118: Sorties :
119: --------------------------------------------------------------------------------
120: Effets de bord : néant
121: ================================================================================
122: */
123:
1.9 bertrand 124: #ifndef OS2
125: extern unsigned char *chemin_semaphores_SysV;
126: #else
127: unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
128: unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";
129: #endif
1.6 bertrand 130:
1.8 bertrand 131: #ifndef UNION_SEMUN
132: union semun
133: {
134: int val;
135: struct semid_ds *buf;
136: unsigned short *array;
137: struct seminfo *__buf;
138: };
139: #endif
140:
1.6 bertrand 141: int
1.8 bertrand 142: sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
1.6 bertrand 143: {
1.11 ! bertrand 144: // Création d'un sémaphore anonyme qui devra être supprimé par
! 145: // sem_destroy_SysV
1.9 bertrand 146: # ifndef OS2
147:
1.8 bertrand 148: int ios;
149:
1.6 bertrand 150: union semun argument;
151:
152: if (shared != 0)
153: {
1.9 bertrand 154: errno = ENOSYS;
155: return(-1);
1.6 bertrand 156: }
157:
1.11 ! bertrand 158: (*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
! 159: S_IRUSR | S_IWUSR);
! 160: (*semaphore).path = NULL;
! 161: (*semaphore).pid = getpid();
1.6 bertrand 162:
1.11 ! bertrand 163: if ((*semaphore).sem == -1)
1.6 bertrand 164: {
1.11 ! bertrand 165: perror("sem_init");
1.9 bertrand 166: errno = EINVAL;
167: return(-1);
1.6 bertrand 168: }
169:
170: argument.val = valeur;
1.11 ! bertrand 171: ios = semctl((*semaphore).sem, 0, SETVAL, argument);
1.6 bertrand 172:
1.8 bertrand 173: return(ios);
1.9 bertrand 174:
175: # else
176:
177: sem_t *psem;
178:
179: psem = semaphore;
180:
181: if (shared != 0)
182: {
183: errno = ENOSYS;
184: return(-1);
185: }
186:
187: if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
188: {
189: free(psem);
190: errno = ENOMEM;
191: return(-1);
192: }
193:
194: if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
195: {
196: free((*psem).cnt);
197: free(psem);
198: errno = ENOMEM;
199: return(-1);
200: }
201:
202: if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
203: {
204: free((*psem).cnt);
205: free((*psem).nopened);
206: free(psem);
207: return(-1);
208: }
209:
210: if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)
211: {
212: DosCloseMutexSem((*psem).hmtx);
213: free((*psem).cnt);
214: free((*psem).nopened);
215: free(psem);
216: return(-1);
217: }
218:
219: (*(*psem).cnt) = valeur;
220: (*(*psem).nopened) = 1;
221: (*psem).shared = shared;
222: (*psem).allocated = 0;
223:
224: return(0);
225:
226: # endif
1.6 bertrand 227: }
228:
229: int
1.8 bertrand 230: sem_destroy_SysV(sem_t *semaphore)
1.6 bertrand 231: {
1.11 ! bertrand 232: // Détruit un sémaphore anonmyme
1.9 bertrand 233: # ifndef OS2
234:
1.11 ! bertrand 235: if ((*semaphore).path != NULL)
! 236: {
! 237: return(EINVAL);
! 238: }
! 239:
! 240: if ((*semaphore).pid != getpid())
! 241: {
! 242: return(0);
! 243: }
! 244:
! 245: if (semctl((*semaphore).sem, IPC_RMID, 0) == -1)
1.6 bertrand 246: {
247: return(EINVAL);
248: }
249:
250: return(0);
1.9 bertrand 251:
252: # else
253:
254: sem_t *psem;
255:
256: psem = semaphore;
257:
258: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
259: {
260: return(EINVAL);
261: }
262:
263: if (DosCloseMutexSem((*psem).hmtx) != 0)
264: {
265: return(EINVAL);
266: }
267:
268: while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
269: {
270: DosPostEventSem((*psem).hev);
271: }
272:
273: (*(*psem).nopened)--;
274:
275: if ((*psem).shared == 0)
276: {
277: free((*psem).cnt);
278: free((*psem).nopened);
279: }
280: else
281: {
282: if ((*(*psem).nopened) == 0)
283: {
284: DosFreeMem((*psem).cnt);
285: }
286: }
287:
288: if ((*psem).allocated != 0)
289: {
290: free(psem);
291: }
292:
293: return(0);
294:
295: # endif
1.6 bertrand 296: }
297:
298: int
1.8 bertrand 299: sem_wait_SysV(sem_t *semaphore)
1.6 bertrand 300: {
1.9 bertrand 301: # ifndef OS2
302:
1.6 bertrand 303: struct sembuf commande;
304:
305: commande.sem_num = 0;
306: commande.sem_op = -1;
307: commande.sem_flg = 0;
308:
1.11 ! bertrand 309: while(semop((*semaphore).sem, &commande, 1) == -1)
1.6 bertrand 310: {
1.11 ! bertrand 311: if (errno != EINTR)
! 312: {
! 313: perror("sem_wait");
! 314: errno = EINVAL;
! 315: return(-1);
! 316: }
1.9 bertrand 317: }
318:
319: return(0);
320:
321: # else
322:
323: sem_t *psem;
324:
325: ULONG cnt;
326:
327: psem = semaphore;
328:
329: if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
330: {
331: errno = EINVAL;
332: return(-1);
333: }
334:
335: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
336: {
337: errno = EINVAL;
338: return(-1);
339: }
340:
341: if ((*(*psem).cnt) > 0)
342: {
343: (*(*psem).cnt)--;
344: }
345:
346: if ((*(*psem).cnt) == 0)
347: {
348: DosResetEventSem((*psem).hev, &cnt);
1.6 bertrand 349: }
350:
1.9 bertrand 351: DosReleaseMutexSem((*psem).hmtx);
1.6 bertrand 352: return(0);
1.9 bertrand 353:
354: # endif
1.6 bertrand 355: }
356:
357: int
1.8 bertrand 358: sem_trywait_SysV(sem_t *semaphore)
1.6 bertrand 359: {
1.9 bertrand 360: # ifndef OS2
361:
1.6 bertrand 362: struct sembuf commande;
363:
364: commande.sem_num = 0;
365: commande.sem_op = -1;
366: commande.sem_flg = IPC_NOWAIT;
367:
1.11 ! bertrand 368: while(semop((*semaphore).sem, &commande, 1) == -1)
1.6 bertrand 369: {
1.11 ! bertrand 370: if (errno != EINTR)
! 371: {
! 372: errno = EINVAL;
! 373: return(-1);
! 374: }
1.9 bertrand 375: }
376:
377: return(0);
378:
379: # else
380:
381: int ios;
382:
383: sem_t *psem;
384:
385: ULONG cnt;
386:
387: psem = semaphore;
388:
389: if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
390: {
391: errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
392: return(-1);
393: }
394:
395: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
396: {
397: errno = EINVAL;
398: return(-1);
399: }
400:
401: if ((*(*psem).cnt) > 0)
402: {
403: (*(*psem).cnt)--;
404: }
1.6 bertrand 405:
1.9 bertrand 406: if ((*(*psem).cnt) == 0)
407: {
408: DosResetEventSem((*psem).hev, &cnt);
1.6 bertrand 409: }
410:
1.9 bertrand 411: DosReleaseMutexSem((*psem).hmtx);
1.6 bertrand 412: return(0);
1.9 bertrand 413:
414: # endif
1.6 bertrand 415: }
416:
417: int
1.8 bertrand 418: sem_post_SysV(sem_t *semaphore)
1.6 bertrand 419: {
1.9 bertrand 420: # ifndef OS2
421:
1.6 bertrand 422: struct sembuf commande;
423:
424: commande.sem_num = 0;
425: commande.sem_op = 1;
426: commande.sem_flg = 0;
427:
1.11 ! bertrand 428: while(semop((*semaphore).sem, &commande, 1) == -1)
1.6 bertrand 429: {
1.11 ! bertrand 430: if (errno != EINTR)
! 431: {
! 432: errno = EINVAL;
! 433: return(-1);
! 434: }
1.9 bertrand 435: }
436:
437: return(0);
438:
439: # else
440:
441: sem_t *psem;
442:
443: psem = semaphore;
444:
445: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
446: {
447: errno = EINVAL;
448: return(-1);
1.6 bertrand 449: }
450:
1.9 bertrand 451: (*(*psem).cnt)++;
452: DosPostEventSem((*psem).hev);
453: DosReleaseMutexSem((*psem).hmtx);
454:
1.6 bertrand 455: return(0);
1.9 bertrand 456:
457: # endif
1.6 bertrand 458: }
459:
460: int
1.8 bertrand 461: sem_getvalue_SysV(sem_t *semaphore, int *valeur)
1.6 bertrand 462: {
1.9 bertrand 463: # ifndef OS2
464:
1.11 ! bertrand 465: (*valeur) = semctl((*semaphore).sem, 0, GETVAL);
1.6 bertrand 466:
467: if ((*valeur) < 0)
468: {
469: return(EINVAL);
470: }
471:
472: return(0);
1.9 bertrand 473:
474: # else
475:
476: sem_t *psem;
477:
478: psem = semaphore;
479:
480: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
481: {
482: errno = EINVAL;
483: return(-1);
484: }
485:
486: (*valeur) = (*(*psem).cnt);
487: DosReleaseMutexSem((*psem).hmtx);
488:
489: return(0);
490:
491: # endif
1.6 bertrand 492: }
493:
494: sem_t
1.8 bertrand 495: *sem_open_SysV(const char *nom, int oflag, ...)
1.6 bertrand 496: //*sem_open(const char *nom, int oflag)
497: //*sem_open(const char *nom, int oflag, mode_t mode, unsigned int value)
498: {
499: mode_t mode;
500:
501: sem_t *semaphore;
502:
1.9 bertrand 503: # ifndef OS2
1.10 bertrand 504: file *desc;
505:
506: key_t clef;
507:
1.6 bertrand 508: union semun argument;
1.9 bertrand 509: # endif
1.6 bertrand 510:
511: unsigned char *nom_absolu;
512:
513: unsigned int valeur;
514:
515: va_list liste;
516:
1.9 bertrand 517: # ifdef OS2
518: sem_t *psem;
519:
520: PVOID base;
521:
522: unsigned char *ptr;
523: unsigned char *nom_segment;
524: # endif
525:
526: # ifndef OS2
527:
1.6 bertrand 528: if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
529: + 1) * sizeof(unsigned char))) == NULL)
530: {
531: return(SEM_FAILED);
532: }
533:
534: sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
535:
536: if ((semaphore = malloc(sizeof(sem_t))) == NULL)
537: {
538: return(SEM_FAILED);
539: }
540:
1.9 bertrand 541: # else
542:
543: if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
544: * sizeof(unsigned char))) == NULL)
545: {
546: return(SEM_FAILED);
547: }
548:
549: sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
550: ptr = nom_segment;
551:
552: while((*ptr) != d_code_fin_chaine)
553: {
554: if ((*ptr) == '/')
555: {
556: (*ptr) = '\\';
557: }
558:
559: ptr++;
560: }
561:
562: if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)
563: + 2) * sizeof(unsigned char))) == NULL)
564: {
565: return(SEM_FAILED);
566: }
567:
568: sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
569: ptr = nom_absolu;
570:
571: while((*ptr) != d_code_fin_chaine)
572: {
573: if ((*ptr) == '/')
574: {
575: (*ptr) = '\\';
576: }
577:
578: ptr++;
579: }
580:
581: (*(ptr + 1)) = d_code_fin_chaine;
582:
583: if ((psem = malloc(sizeof(sem_t))) == NULL)
584: {
585: return(SEM_FAILED);
586: }
587:
1.11 ! bertrand 588: (*psem).allocated = 1;
! 589:
1.9 bertrand 590: # endif
591:
1.6 bertrand 592: if ((oflag & O_CREAT) == 0)
593: {
594: // 2 arguments
1.9 bertrand 595:
596: # ifndef OS2
597:
1.11 ! bertrand 598: clef = ftok(nom_absolu, 1);
! 599:
! 600: if (clef == -1)
! 601: {
! 602: return(SEM_FAILED);
! 603: }
! 604:
! 605: (*semaphore).sem = semget(clef, 0, 0);
! 606: (*semaphore).path = nom_absolu;
! 607: (*semaphore).pid = getpid();
1.6 bertrand 608:
1.11 ! bertrand 609: if ((*semaphore).sem == -1)
1.6 bertrand 610: {
611: free(semaphore);
612: free(nom_absolu);
613:
614: return(SEM_FAILED);
615: }
1.9 bertrand 616:
617: # else
618:
619: if ((psem = malloc(sizeof(sem_t))) == NULL)
620: {
621: free(nom_absolu);
622: free(nom_segment);
623: return(SEM_FAILED);
624: }
625:
626: (*ptr) = 'M';
627:
628: if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
629: {
630: free(psem);
631: free(nom_absolu);
632: free(nom_segment);
633:
634: return(SEM_FAILED);
635: }
636:
637: (*ptr) = 'S';
638:
639: if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
640: {
641: DosCloseMutexSem((*psem).hmtx);
642:
643: free(psem);
644: free(nom_absolu);
645: free(nom_segment);
646:
647: return(SEM_FAILED);
648: }
649:
650: if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)
651: {
652: DosCloseMutexSem((*psem).hmtx);
653:
654: free(nom_absolu);
655: free(nom_segment);
656: free(psem);
657:
658: return(SEM_FAILED);
659: }
660:
661: free(nom_segment);
662:
663: (*psem).cnt = (ULONG *) base;
664: (*psem).nopened = ((ULONG *) base) + 1;
665: (*psem).shared = 1;
666:
667: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
668: {
669: DosCloseMutexSem((*psem).hmtx);
670:
671: free(nom_absolu);
672: free(nom_segment);
673: free(psem);
674:
675: return(SEM_FAILED);
676: }
677:
678: (*((*psem).nopened))++;
679:
680: DosReleaseMutexSem((*psem).hmtx);
681:
682: semaphore = psem;
683:
684: # endif
1.6 bertrand 685: }
686: else
687: {
688: // 4 arguments
689:
690: // O_CREAT O_EXCL
691: // S_IRUSR S_IWUSR
692:
693: va_start(liste, oflag);
694: mode = va_arg(liste, mode_t);
695: valeur = va_arg(liste, unsigned int);
696: va_end(liste);
697:
1.9 bertrand 698: # ifndef OS2
699:
1.10 bertrand 700: if ((desc = fopen(nom_absolu, "w")) == NULL)
701: {
702: free(semaphore);
703: free(nom_absolu);
704:
705: return(SEM_FAILED);
706: }
707:
708: fclose(desc);
709:
710: if ((clef = ftok(nom_absolu, 1)) == -1)
711: {
712: free(semaphore);
713: free(nom_absolu);
714:
715: return(SEM_FAILED);
716: }
717:
1.11 ! bertrand 718: (*semaphore).sem = semget(clef, 1,
! 719: (((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |
! 720: (((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |
! 721: (int) mode);
! 722: (*semaphore).path = nom_absolu;
! 723: (*semaphore).pid = getpid();
1.6 bertrand 724:
1.11 ! bertrand 725: if ((*semaphore).sem == -1)
1.6 bertrand 726: {
727: free(semaphore);
728: free(nom_absolu);
729:
730: return(SEM_FAILED);
731: }
732:
733: argument.val = valeur;
1.11 ! bertrand 734: semctl((*semaphore).sem, 0, SETVAL, argument);
1.9 bertrand 735:
736: # else
737:
738: if ((psem = malloc(sizeof(sem_t))) == NULL)
739: {
740: free(nom_absolu);
741: free(nom_segment);
742:
743: return(SEM_FAILED);
744: }
745:
746: (*ptr) = 'M';
747:
748: if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
749: {
750: free(psem);
751: free(nom_absolu);
752: free(nom_segment);
753:
754: return(SEM_FAILED);
755: }
756:
757: (*ptr) = 'S';
758:
759: if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
760: (valeur != 0) ? 1 : 0) != 0)
761: {
762: DosCloseMutexSem((*psem).hmtx);
763:
764: free(nom_absolu);
765: free(nom_segment);
766: free(psem);
767:
768: return(SEM_FAILED);
769: }
770:
771: if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
772: PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
773: {
774: DosCloseMutexSem((*psem).hmtx);
775:
776: free(nom_absolu);
777: free(nom_segment);
778: free(psem);
779:
780: return(SEM_FAILED);
781: }
782:
783: free(nom_segment);
784:
785: (*psem).cnt = (ULONG *) base;
786: (*psem).nopened = ((ULONG *) base) + 1;
787: (*(*psem).cnt) = valeur;
788: (*(*psem).nopened) = 1;
789: (*psem).shared = 1;
790: semaphore = psem;
791:
792: # endif
1.6 bertrand 793: }
794:
1.8 bertrand 795: return(semaphore);
1.6 bertrand 796: }
797:
798: int
1.8 bertrand 799: sem_close_SysV(sem_t *semaphore)
1.6 bertrand 800: {
1.11 ! bertrand 801: // Ferme un sémaphore nommé créé par sem_open_SysV()
1.9 bertrand 802: # ifndef OS2
803:
1.11 ! bertrand 804: if ((*semaphore).path != NULL)
! 805: {
! 806: free((*semaphore).path);
! 807: }
! 808:
1.6 bertrand 809: free(semaphore);
810: return(0);
1.9 bertrand 811:
812: # else
813:
814: sem_t *psem;
815:
816: psem = semaphore;
817:
818: if (DosCloseMutexSem((*psem).hmtx) != 0)
819: {
820: return(EINVAL);
821: }
822:
823: while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
824: {
825: DosPostEventSem((*psem).hev);
826: }
827:
828: (*(*psem).nopened)--;
829:
830: if ((*psem).shared == 0)
831: {
832: free((*psem).cnt);
833: free((*psem).nopened);
834: }
835: else
836: {
837: if ((*(*psem).nopened) == 0)
838: {
839: DosFreeMem((*psem).cnt);
840: }
841: }
842:
843: if ((*psem).allocated != 0)
844: {
845: free(psem);
846: }
847:
848: return(0);
849:
850: # endif
1.6 bertrand 851: }
852:
853: int
1.8 bertrand 854: sem_unlink_SysV(const char *nom)
1.6 bertrand 855: {
1.11 ! bertrand 856: // Détruit un sémaphore nommé créé par sem_open_SysV()
1.9 bertrand 857: # ifndef OS2
858:
1.6 bertrand 859: unsigned char *nom_absolu;
860:
861: if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
862: + 1) * sizeof(unsigned char))) == NULL)
863: {
864: return(ENOMEM);
865: }
866:
867: sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
1.11 ! bertrand 868: semctl(semget(ftok(nom_absolu, 1), 0, 0), IPC_RMID, 0);
1.6 bertrand 869:
870: if (unlink(nom_absolu) == -1)
871: {
872: free(nom_absolu);
873: return(EACCES);
874: }
875:
876: free(nom_absolu);
877:
878: return(0);
1.9 bertrand 879:
880: # else
881:
882: return(0);
883:
884: # endif
1.6 bertrand 885: }
886:
887: #endif
888:
1.1 bertrand 889: // vim: ts=4