Źródło

   /*****************************************************************************
    Zaczerpnięto z "Linux Programmer's Guide - Rozdział 6"
    (C)opyright 1994-1995, Scott Burkett
    ***************************************************************************** 
    MODUŁ: semtool.c
    *****************************************************************************
    Narzędzie zarządzające semaforami stylu SysV z linii poleceń
    *****************************************************************************/
   
   #include <stdio.h>
   #include <ctype.h>
   #include <stdlib.h>
   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/sem.h>
   
   /* U mnie ( RedHat6.0, jądro 2.2.12-20 )
   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/sem.h>	*/
   
   
   #define SEM_RESOURCE_MAX        1       /* wartość inicjująca wszystkie semafory */
   
   void opensem(int *sid, key_t key);
   void createsem(int *sid, key_t key, int members);
   void locksem(int sid, int member);
   void unlocksem(int sid, int member);
   void removesem(int sid);
   unsigned short get_member_count(int sid);
   int getval(int sid, int member);
   void dispval(int sid, int member);
   void changemode(int sid, char *mode);
   void usage(void);
   
   int main(int argc, char *argv[])
   {
           key_t key;
           int   semset_id;
   
           if(argc == 1)
                   usage();
   
           /* tworzymy unikalny klucz za pomocą wywołania ftok() */
           key = ftok(".", 's');
   
           switch(tolower(argv[1][0]))
           {
                   case 's': if(argc != 3)
                                   usage();
                             createsem(&semset_id, key,  atoi(argv[2]));
                             break;
                   case 'z': if(argc != 3)
                                   usage();
                             opensem(&semset_id, key);
                             locksem(semset_id, atoi(argv[2]));
                             break;
                   case 'o': if(argc != 3)
                                   usage();
                             opensem(&semset_id, key);
                             unlocksem(semset_id, atoi(argv[2]));
                             break;
                   case 'u': opensem(&semset_id, key);
                             removesem(semset_id);
                             break;        
                   case 't': opensem(&semset_id, key);
                             changemode(semset_id, argv[2]);
                             break;        
                    default: usage();
   
           }
           
           return(0);
   }
   
   void opensem(int *sid, key_t key)
   {
           /* otwórz zestaw semaforów, nie twórz go! */
   
           if((*sid = semget(key, 0, 0666)) == -1) 
           {
                   printf("Zestaw semaforów nie istnieje!\n");
                   exit(1);
           }
   
   }
   
   void createsem(int *sid, key_t key, int members)
   {
           int cntr;
           union semun semopts;
   
           if(members > SEMMSL) {
                   printf("Przykro mi, maxymalną liczbą semaforów w zestawie jest %d\n",
   SEMMSL);
                   exit(1);
           }
   
           printf("Próbuję utworzyć nowy zestaw semaforów z %d elementami\n",
   members);
   
           if((*sid = semget(key, members, IPC_CREAT|IPC_EXCL|0666))
                           == -1) 
           {
                   fprintf(stderr, "Zestaw semaforów istnieje!\n");
                   exit(1);
           }
   
           semopts.val = SEM_RESOURCE_MAX;
           
           /* Inicjalizacja wszystkich członków ( można to zrobić za pomocą SETALL ) */
           for(cntr=0; cntr<members; cntr++)
                   semctl(*sid, cntr, SETVAL, semopts);
   }
   
   void locksem(int sid, int member)
   {
           struct sembuf sem_lock={ 0, -1, IPC_NOWAIT};
   
           if( member<0 || member>(get_member_count(sid)-1))
           {
                   fprintf(stderr, "%d - członek semaforu poza zasięgiem\n", member);
   return;
           }
   
           /* Próba zablokowania zestawu semaforów */
           if(!getval(sid, member))
           {
                   fprintf(stderr, "Zasoby semaforu wyczerpane ( brak blokady )!\n");
                   exit(1);
           }
           
           sem_lock.sem_num = member;
           
           if((semop(sid, &sem_lock, 1)) == -1)
           {
                   fprintf(stderr, "Blokowanie nie powiodło się\n");
                   exit(1);
           }
           else
                   printf("Zasoby semaforu zmiejszone o jeden ( zablokowane )\n");
   
           dispval(sid, member);
   }
   
   void unlocksem(int sid, int member)
   {
           struct sembuf sem_unlock={ member, 1, IPC_NOWAIT};
           int semval;
   
           if( member<0 || member>(get_member_count(sid)-1))
           {
                   fprintf(stderr, "%d - członek semaforu poza zasięgiem\n", member);
   return;
           }
   
           /* Czy semafor jest zablokowany? */
           semval = getval(sid, member);
           if(semval == SEM_RESOURCE_MAX) {
                   fprintf(stderr, "Semafor nie jest zablokowany!\n");
                   exit(1);
           }
   
           sem_unlock.sem_num = member;
   
           /* Próba odblokowania semaforu */
           if((semop(sid, &sem_unlock, 1)) == -1)
           {
                   fprintf(stderr, "Odblokowywanie nie powiodło się\n");
                   exit(1);
           }
           else
                   printf("Zasoby semaforu zwiększone o jeden ( odblokowane )\n");
   
           dispval(sid, member);
   }
   
   void removesem(int sid)
   {
           semctl(sid, 0, IPC_RMID, 0);
           printf("Usunięto zestaw semaforów\n");
   }
   
   unsigned short get_member_count(int sid)
   {
           union semun semopts;
           struct semid_ds mysemds;
   
           semopts.buf = &mysemds;
   	
   	semctl(sid, 0, IPC_STAT, semopts);
           
   	/* zwraca liczbę członków zestawu semaforów */
           return(semopts.buf->sem_nsems);
   }
   
   int getval(int sid, int member)
   {
           int semval;
   
           semval = semctl(sid, member, GETVAL, 0);
           return(semval);
   }
   
   void changemode(int sid, char *mode)
   {
           int rc;
           union semun semopts;
           struct semid_ds mysemds;
   
           /* pobierz aktalną wartość wewnętrznej struktury */
           semopts.buf = &mysemds;
   
           rc = semctl(sid, 0, IPC_STAT, semopts);
   
           if (rc == -1) {
                   perror("semctl");
                   exit(1);
           }
                   
           printf("Stare prawa dostępu: %o\n", semopts.buf->sem_perm.mode);
   
           /* Zmień prawa dostępu do zestawu semaforów */
           sscanf(mode, "%ho", &semopts.buf->sem_perm.mode);
   
           /* Zaktualizuj wewnętrzną strukturę danych */
           semctl(sid, 0, IPC_SET, semopts);
   
           printf("Zaktualizowano...\n");
   
   }
   
   void dispval(int sid, int member)
   {
           int semval;
   
           semval = semctl(sid, member, GETVAL, 0);
           printf("semval elementu %d to %d\n", member, semval);
   }
   
   void usage(void)
   {
           fprintf(stderr, "semtool - narzędzie do majstrowania przy semaforach\n");
           fprintf(stderr, "\nUŻYCIE:  semtool (s)twórz <ilość semaforów>\n");
           fprintf(stderr, "                 (z)ablokuj <nr sem.>\n");
           fprintf(stderr, "                 (o)dblokuj <nr sem.>\n");
           fprintf(stderr, "                 (u)suń\n");
           fprintf(stderr, "                 (t)ryb <tryb>\n");
           exit(1);
   }