Annotation of rpl/src/semaphores.c, revision 1.9
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,
43: "/RPLSEM-%d-%llu-%d", (int) getpid(),
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.9 ! bertrand 144: # ifndef OS2
! 145:
1.8 bertrand 146: int ios;
147:
1.6 bertrand 148: union semun argument;
149:
150: if (shared != 0)
151: {
1.9 ! bertrand 152: errno = ENOSYS;
! 153: return(-1);
1.6 bertrand 154: }
155:
156: (*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | SEM_R | SEM_A);
157:
158: if ((*semaphore) == -1)
159: {
1.9 ! bertrand 160: errno = EINVAL;
! 161: return(-1);
1.6 bertrand 162: }
163:
164: argument.val = valeur;
1.8 bertrand 165: ios = semctl((*semaphore), 0, SETVAL, argument);
1.6 bertrand 166:
1.8 bertrand 167: return(ios);
1.9 ! bertrand 168:
! 169: # else
! 170:
! 171: sem_t *psem;
! 172:
! 173: psem = semaphore;
! 174:
! 175: if (shared != 0)
! 176: {
! 177: errno = ENOSYS;
! 178: return(-1);
! 179: }
! 180:
! 181: if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
! 182: {
! 183: free(psem);
! 184: errno = ENOMEM;
! 185: return(-1);
! 186: }
! 187:
! 188: if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
! 189: {
! 190: free((*psem).cnt);
! 191: free(psem);
! 192: errno = ENOMEM;
! 193: return(-1);
! 194: }
! 195:
! 196: if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
! 197: {
! 198: free((*psem).cnt);
! 199: free((*psem).nopened);
! 200: free(psem);
! 201: return(-1);
! 202: }
! 203:
! 204: if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)
! 205: {
! 206: DosCloseMutexSem((*psem).hmtx);
! 207: free((*psem).cnt);
! 208: free((*psem).nopened);
! 209: free(psem);
! 210: return(-1);
! 211: }
! 212:
! 213: (*(*psem).cnt) = valeur;
! 214: (*(*psem).nopened) = 1;
! 215: (*psem).shared = shared;
! 216: (*psem).allocated = 0;
! 217:
! 218: return(0);
! 219:
! 220: # endif
1.6 bertrand 221: }
222:
223: int
1.8 bertrand 224: sem_destroy_SysV(sem_t *semaphore)
1.6 bertrand 225: {
1.9 ! bertrand 226: # ifndef OS2
! 227:
1.6 bertrand 228: if (semctl((*semaphore), IPC_RMID, 0) == -1)
229: {
230: return(EINVAL);
231: }
232:
233: return(0);
1.9 ! bertrand 234:
! 235: # else
! 236:
! 237: sem_t *psem;
! 238:
! 239: psem = semaphore;
! 240:
! 241: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 242: {
! 243: return(EINVAL);
! 244: }
! 245:
! 246: if (DosCloseMutexSem((*psem).hmtx) != 0)
! 247: {
! 248: return(EINVAL);
! 249: }
! 250:
! 251: while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
! 252: {
! 253: DosPostEventSem((*psem).hev);
! 254: }
! 255:
! 256: (*(*psem).nopened)--;
! 257:
! 258: if ((*psem).shared == 0)
! 259: {
! 260: free((*psem).cnt);
! 261: free((*psem).nopened);
! 262: }
! 263: else
! 264: {
! 265: if ((*(*psem).nopened) == 0)
! 266: {
! 267: DosFreeMem((*psem).cnt);
! 268: }
! 269: }
! 270:
! 271: if ((*psem).allocated != 0)
! 272: {
! 273: free(psem);
! 274: }
! 275:
! 276: return(0);
! 277:
! 278: # endif
1.6 bertrand 279: }
280:
281: int
1.8 bertrand 282: sem_wait_SysV(sem_t *semaphore)
1.6 bertrand 283: {
1.9 ! bertrand 284: # ifndef OS2
! 285:
1.6 bertrand 286: struct sembuf commande;
287:
288: commande.sem_num = 0;
289: commande.sem_op = -1;
290: commande.sem_flg = 0;
291:
292: if (semop((*semaphore), &commande, 1) == -1)
293: {
1.9 ! bertrand 294: errno = EINVAL;
! 295: return(-1);
! 296: }
! 297:
! 298: return(0);
! 299:
! 300: # else
! 301:
! 302: sem_t *psem;
! 303:
! 304: ULONG cnt;
! 305:
! 306: psem = semaphore;
! 307:
! 308: if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
! 309: {
! 310: errno = EINVAL;
! 311: return(-1);
! 312: }
! 313:
! 314: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 315: {
! 316: errno = EINVAL;
! 317: return(-1);
! 318: }
! 319:
! 320: if ((*(*psem).cnt) > 0)
! 321: {
! 322: (*(*psem).cnt)--;
! 323: }
! 324:
! 325: if ((*(*psem).cnt) == 0)
! 326: {
! 327: DosResetEventSem((*psem).hev, &cnt);
1.6 bertrand 328: }
329:
1.9 ! bertrand 330: DosReleaseMutexSem((*psem).hmtx);
1.6 bertrand 331: return(0);
1.9 ! bertrand 332:
! 333: # endif
1.6 bertrand 334: }
335:
336: int
1.8 bertrand 337: sem_trywait_SysV(sem_t *semaphore)
1.6 bertrand 338: {
1.9 ! bertrand 339: # ifndef OS2
! 340:
1.6 bertrand 341: struct sembuf commande;
342:
343: commande.sem_num = 0;
344: commande.sem_op = -1;
345: commande.sem_flg = IPC_NOWAIT;
346:
347: if (semop((*semaphore), &commande, 1) == -1)
348: {
1.9 ! bertrand 349: return(-1);
! 350: }
! 351:
! 352: return(0);
! 353:
! 354: # else
! 355:
! 356: int ios;
! 357:
! 358: sem_t *psem;
! 359:
! 360: ULONG cnt;
! 361:
! 362: psem = semaphore;
! 363:
! 364: if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
! 365: {
! 366: errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
! 367: return(-1);
! 368: }
! 369:
! 370: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 371: {
! 372: errno = EINVAL;
! 373: return(-1);
! 374: }
! 375:
! 376: if ((*(*psem).cnt) > 0)
! 377: {
! 378: (*(*psem).cnt)--;
! 379: }
1.6 bertrand 380:
1.9 ! bertrand 381: if ((*(*psem).cnt) == 0)
! 382: {
! 383: DosResetEventSem((*psem).hev, &cnt);
1.6 bertrand 384: }
385:
1.9 ! bertrand 386: DosReleaseMutexSem((*psem).hmtx);
1.6 bertrand 387: return(0);
1.9 ! bertrand 388:
! 389: # endif
1.6 bertrand 390: }
391:
392: int
1.8 bertrand 393: sem_post_SysV(sem_t *semaphore)
1.6 bertrand 394: {
1.9 ! bertrand 395: # ifndef OS2
! 396:
1.6 bertrand 397: struct sembuf commande;
398:
399: commande.sem_num = 0;
400: commande.sem_op = 1;
401: commande.sem_flg = 0;
402:
403: if (semop((*semaphore), &commande, 1) == -1)
404: {
1.9 ! bertrand 405: errno = EINVAL;
! 406: return(-1);
! 407: }
! 408:
! 409: return(0);
! 410:
! 411: # else
! 412:
! 413: sem_t *psem;
! 414:
! 415: psem = semaphore;
! 416:
! 417: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 418: {
! 419: errno = EINVAL;
! 420: return(-1);
1.6 bertrand 421: }
422:
1.9 ! bertrand 423: (*(*psem).cnt)++;
! 424: DosPostEventSem((*psem).hev);
! 425: DosReleaseMutexSem((*psem).hmtx);
! 426:
1.6 bertrand 427: return(0);
1.9 ! bertrand 428:
! 429: # endif
1.6 bertrand 430: }
431:
432: int
1.8 bertrand 433: sem_getvalue_SysV(sem_t *semaphore, int *valeur)
1.6 bertrand 434: {
1.9 ! bertrand 435: # ifndef OS2
! 436:
1.6 bertrand 437: (*valeur) = semctl((*semaphore), 0, GETVAL);
438:
439: if ((*valeur) < 0)
440: {
441: return(EINVAL);
442: }
443:
444: return(0);
1.9 ! bertrand 445:
! 446: # else
! 447:
! 448: sem_t *psem;
! 449:
! 450: psem = semaphore;
! 451:
! 452: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 453: {
! 454: errno = EINVAL;
! 455: return(-1);
! 456: }
! 457:
! 458: (*valeur) = (*(*psem).cnt);
! 459: DosReleaseMutexSem((*psem).hmtx);
! 460:
! 461: return(0);
! 462:
! 463: # endif
1.6 bertrand 464: }
465:
466: sem_t
1.8 bertrand 467: *sem_open_SysV(const char *nom, int oflag, ...)
1.6 bertrand 468: //*sem_open(const char *nom, int oflag)
469: //*sem_open(const char *nom, int oflag, mode_t mode, unsigned int value)
470: {
471: mode_t mode;
472:
473: sem_t *semaphore;
474:
1.9 ! bertrand 475: # ifndef OS2
1.6 bertrand 476: union semun argument;
1.9 ! bertrand 477: # endif
1.6 bertrand 478:
479: unsigned char *nom_absolu;
480:
481: unsigned int valeur;
482:
483: va_list liste;
484:
1.9 ! bertrand 485: # ifdef OS2
! 486: sem_t *psem;
! 487:
! 488: PVOID base;
! 489:
! 490: unsigned char *ptr;
! 491: unsigned char *nom_segment;
! 492: # endif
! 493:
! 494: # ifndef OS2
! 495:
1.6 bertrand 496: if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
497: + 1) * sizeof(unsigned char))) == NULL)
498: {
499: return(SEM_FAILED);
500: }
501:
502: sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
503:
504: if ((semaphore = malloc(sizeof(sem_t))) == NULL)
505: {
506: return(SEM_FAILED);
507: }
508:
1.9 ! bertrand 509: (*psem).allocated = 1;
! 510:
! 511: # else
! 512:
! 513: if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
! 514: * sizeof(unsigned char))) == NULL)
! 515: {
! 516: return(SEM_FAILED);
! 517: }
! 518:
! 519: sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
! 520: ptr = nom_segment;
! 521:
! 522: while((*ptr) != d_code_fin_chaine)
! 523: {
! 524: if ((*ptr) == '/')
! 525: {
! 526: (*ptr) = '\\';
! 527: }
! 528:
! 529: ptr++;
! 530: }
! 531:
! 532: if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)
! 533: + 2) * sizeof(unsigned char))) == NULL)
! 534: {
! 535: return(SEM_FAILED);
! 536: }
! 537:
! 538: sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
! 539: ptr = nom_absolu;
! 540:
! 541: while((*ptr) != d_code_fin_chaine)
! 542: {
! 543: if ((*ptr) == '/')
! 544: {
! 545: (*ptr) = '\\';
! 546: }
! 547:
! 548: ptr++;
! 549: }
! 550:
! 551: (*(ptr + 1)) = d_code_fin_chaine;
! 552:
! 553: if ((psem = malloc(sizeof(sem_t))) == NULL)
! 554: {
! 555: return(SEM_FAILED);
! 556: }
! 557:
! 558: # endif
! 559:
1.6 bertrand 560: if ((oflag & O_CREAT) == 0)
561: {
562: // 2 arguments
1.9 ! bertrand 563:
! 564: # ifndef OS2
! 565:
1.6 bertrand 566: (*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);
567:
568: if ((*semaphore) == -1)
569: {
570: free(semaphore);
571: free(nom_absolu);
572:
573: return(SEM_FAILED);
574: }
1.9 ! bertrand 575:
! 576: # else
! 577:
! 578: if ((psem = malloc(sizeof(sem_t))) == NULL)
! 579: {
! 580: free(nom_absolu);
! 581: free(nom_segment);
! 582: return(SEM_FAILED);
! 583: }
! 584:
! 585: (*ptr) = 'M';
! 586:
! 587: if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
! 588: {
! 589: free(psem);
! 590: free(nom_absolu);
! 591: free(nom_segment);
! 592:
! 593: return(SEM_FAILED);
! 594: }
! 595:
! 596: (*ptr) = 'S';
! 597:
! 598: if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
! 599: {
! 600: DosCloseMutexSem((*psem).hmtx);
! 601:
! 602: free(psem);
! 603: free(nom_absolu);
! 604: free(nom_segment);
! 605:
! 606: return(SEM_FAILED);
! 607: }
! 608:
! 609: if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)
! 610: {
! 611: DosCloseMutexSem((*psem).hmtx);
! 612:
! 613: free(nom_absolu);
! 614: free(nom_segment);
! 615: free(psem);
! 616:
! 617: return(SEM_FAILED);
! 618: }
! 619:
! 620: free(nom_segment);
! 621:
! 622: (*psem).cnt = (ULONG *) base;
! 623: (*psem).nopened = ((ULONG *) base) + 1;
! 624: (*psem).shared = 1;
! 625:
! 626: if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
! 627: {
! 628: DosCloseMutexSem((*psem).hmtx);
! 629:
! 630: free(nom_absolu);
! 631: free(nom_segment);
! 632: free(psem);
! 633:
! 634: return(SEM_FAILED);
! 635: }
! 636:
! 637: (*((*psem).nopened))++;
! 638:
! 639: DosReleaseMutexSem((*psem).hmtx);
! 640:
! 641: semaphore = psem;
! 642:
! 643: # endif
1.6 bertrand 644: }
645: else
646: {
647: // 4 arguments
648:
649: // O_CREAT O_EXCL
650: // S_IRUSR S_IWUSR
651:
652: va_start(liste, oflag);
653: mode = va_arg(liste, mode_t);
654: valeur = va_arg(liste, unsigned int);
655: va_end(liste);
656:
1.9 ! bertrand 657: # ifndef OS2
! 658:
1.6 bertrand 659: (*semaphore) = semget(ftok(nom_absolu, 1), 1,
660: ((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT |
661: ((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL |
662: ((oflag & S_IRUSR) == 0) ? 0 : SEM_R |
663: ((oflag & S_IWUSR) == 0) ? 0 : SEM_A);
664:
665: if ((*semaphore) == -1)
666: {
667: free(semaphore);
668: free(nom_absolu);
669:
670: return(SEM_FAILED);
671: }
672:
673: argument.val = valeur;
674: semctl((*semaphore), 0, SETVAL, argument);
1.9 ! bertrand 675:
! 676: # else
! 677:
! 678: if ((psem = malloc(sizeof(sem_t))) == NULL)
! 679: {
! 680: free(nom_absolu);
! 681: free(nom_segment);
! 682:
! 683: return(SEM_FAILED);
! 684: }
! 685:
! 686: (*ptr) = 'M';
! 687:
! 688: if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
! 689: {
! 690: free(psem);
! 691: free(nom_absolu);
! 692: free(nom_segment);
! 693:
! 694: return(SEM_FAILED);
! 695: }
! 696:
! 697: (*ptr) = 'S';
! 698:
! 699: if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
! 700: (valeur != 0) ? 1 : 0) != 0)
! 701: {
! 702: DosCloseMutexSem((*psem).hmtx);
! 703:
! 704: free(nom_absolu);
! 705: free(nom_segment);
! 706: free(psem);
! 707:
! 708: return(SEM_FAILED);
! 709: }
! 710:
! 711: if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
! 712: PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
! 713: {
! 714: DosCloseMutexSem((*psem).hmtx);
! 715:
! 716: free(nom_absolu);
! 717: free(nom_segment);
! 718: free(psem);
! 719:
! 720: return(SEM_FAILED);
! 721: }
! 722:
! 723: free(nom_segment);
! 724:
! 725: (*psem).cnt = (ULONG *) base;
! 726: (*psem).nopened = ((ULONG *) base) + 1;
! 727: (*(*psem).cnt) = valeur;
! 728: (*(*psem).nopened) = 1;
! 729: (*psem).shared = 1;
! 730: semaphore = psem;
! 731:
! 732: # endif
1.6 bertrand 733: }
734:
735: free(nom_absolu);
736:
1.8 bertrand 737: return(semaphore);
1.6 bertrand 738: }
739:
740: int
1.8 bertrand 741: sem_close_SysV(sem_t *semaphore)
1.6 bertrand 742: {
1.9 ! bertrand 743: # ifndef OS2
! 744:
1.6 bertrand 745: free(semaphore);
746: return(0);
1.9 ! bertrand 747:
! 748: # else
! 749:
! 750: sem_t *psem;
! 751:
! 752: psem = semaphore;
! 753:
! 754: if (DosCloseMutexSem((*psem).hmtx) != 0)
! 755: {
! 756: return(EINVAL);
! 757: }
! 758:
! 759: while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
! 760: {
! 761: DosPostEventSem((*psem).hev);
! 762: }
! 763:
! 764: (*(*psem).nopened)--;
! 765:
! 766: if ((*psem).shared == 0)
! 767: {
! 768: free((*psem).cnt);
! 769: free((*psem).nopened);
! 770: }
! 771: else
! 772: {
! 773: if ((*(*psem).nopened) == 0)
! 774: {
! 775: DosFreeMem((*psem).cnt);
! 776: }
! 777: }
! 778:
! 779: if ((*psem).allocated != 0)
! 780: {
! 781: free(psem);
! 782: }
! 783:
! 784: return(0);
! 785:
! 786: # endif
1.6 bertrand 787: }
788:
789: int
1.8 bertrand 790: sem_unlink_SysV(const char *nom)
1.6 bertrand 791: {
1.9 ! bertrand 792: # ifndef OS2
! 793:
1.6 bertrand 794: sem_t semaphore;
795:
796: struct sembuf commande;
797:
798: unsigned char *nom_absolu;
799:
800: if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
801: + 1) * sizeof(unsigned char))) == NULL)
802: {
803: return(ENOMEM);
804: }
805:
806: sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
807:
808: if ((semaphore = semget(ftok(nom_absolu, 1), 0, 0)) == -1)
809: {
810: free(nom_absolu);
811: return(EINVAL);
812: }
813:
814: commande.sem_num = 0;
815: commande.sem_op = 0;
816: commande.sem_flg = 0;
817:
818: if (semop(semaphore, &commande, 1) == -1)
819: {
820: free(nom_absolu);
821: return(EINVAL);
822: }
823:
824: if (semctl(semaphore, IPC_RMID, 0) == -1)
825: {
826: free(nom_absolu);
827: return(EINVAL);
828: }
829:
830: if (unlink(nom_absolu) == -1)
831: {
832: free(nom_absolu);
833: return(EACCES);
834: }
835:
836: free(nom_absolu);
837:
838: return(0);
1.9 ! bertrand 839:
! 840: # else
! 841:
! 842: return(0);
! 843:
! 844: # endif
1.6 bertrand 845: }
846:
847: #endif
848:
1.1 bertrand 849: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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