sources/Mutex.c

   1 /* Mutex.c
   2  *
   3  * Copyright (C) 2002 Simone Piccardi
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or (at
   8  * your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /*****************************************************************************
  20  *
  21  * File Mutex.c: define a set of functions for mutex manipulation
  22  *
  23  * Author: S. Piccardi Dec. 2002
  24  *
  25  * $Id: Mutex.c,v 1.3 2002/12/05 23:38:22 piccardi Exp $
  26  *
  27  *****************************************************************************/
  28 #include <sys/sem.h>     /* IPC semaphore declarations */
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <signal.h>      /* signal handling declarations */
  33
  34 #include "Gapil.h"
  35 /*
  36  * Function MutexCreate: create a mutex/semaphore
  37  *
  38  * First call create a semaphore, using the given key.
  39  * We want only one semaphore so we set second argument to 1; third
  40  * parameter is the flag argument, and is set to create a semaphore
  41  * with R/W privilege for the user.
  42  * Second call initialize the semaphore to 1 (unlocked)
  43  *
  44  * Input: an IPC key value (to create an unique semaphore)
  45  * Return: the semaphore id# or -1 on error
  46  */
  47 int MutexCreate(key_t ipc_key)
  48 {
  49     const union semun semunion={1};             /* semaphore union structure */
  50     int sem_id, ret;
  51     sem_id = semget(ipc_key, 1, IPC_CREAT|0666);         /* get semaphore ID */
  52     if (sem_id == -1) {                              /* if error return code */
  53         return sem_id;
  54     }
  55     ret = semctl(sem_id, 0, SETVAL, semunion);             /* init semaphore */
  56     if (ret == -1) {
  57         return ret;
  58     }
  59     return sem_id;
  60 }
  61 /*
  62  * Function MutexFind: get the semaphore/mutex Id given the IPC key value
  63  *
  64  * Input: an IPC key value
  65  */
  66 int MutexFind(key_t ipc_key)
  67 {
  68     return semget(ipc_key,1,0);
  69 }
  70 /*
  71  * Function MutexRead: read the current value of the mutex/semaphore
  72  *
  73  * Input:  a semaphore id #
  74  * Return: the semaphore value
  75  */
  76 int MutexRead(int sem_id)
  77 {
  78     return semctl(sem_id, 0, GETVAL);
  79 }
  80 /*
  81  * Define sembuf structures to lock and unlock the semaphore
  82  * (used to implement a mutex)
  83  */
  84 struct sembuf sem_lock={                                /* to lock semaphore */
  85     0,                                   /* semaphore number (only one so 0) */
  86     -1,                                    /* operation (-1 to use resource) */
  87     SEM_UNDO};                                /* flag (set for undo at exit) */
  88 struct sembuf sem_ulock={                             /* to unlock semaphore */
  89     0,                                   /* semaphore number (only one so 0) */
  90     1,                                  /* operation (1 to release resource) */
  91     SEM_UNDO};                                      /* flag (in this case 0) */
  92 /*
  93  * Function MutexLock: to lock a mutex/semaphore
  94  *
  95  * Input:  a semaphore id #
  96  * Output: semop return code  (0 OK, -1 KO)
  97  */
  98 int MutexLock(int sem_id)
  99 {
 100     return semop(sem_id, &sem_lock, 1);
 101 }
 102 /*
 103  * Function MutexUnlock: to unlock a mutex/semaphore
 104  *
 105  * Input:  a semaphore id #
 106  * Return: semop return code (0 OK, -1 KO)
 107  */
 108 int MutexUnlock(int sem_id)
 109 {
 110     return semop(sem_id, &sem_ulock, 1);
 111 }
 112 /*****************************************************************************
 113  *
 114  * File locking mutex
 115  *
 116  * Create a mutex usinf file locking. Use file locking to lock a file
 117  * as a mutex request, and unlock it as a mutex release.
 118  *
 119  * Author: S. Piccardi Dec. 2002
 120  *
 121  *****************************************************************************/
 122 /*
 123  * Function LockMutex: lock a file (creating it if not existent).
 124  *
 125  * Input:  a filename
 126  * Output: a return code  (0 OK, -1 KO)
 127  */
 128 int LockMutex(const char *path_name)
 129 {
 130     int fd, res;
 131     struct flock lock;                                /* file lock structure */
 132     /* first open the file (creating it if not existent) */
 133     if ( (fd = open(path_name, O_EXCL|O_CREAT)) < 0) {    /* first open file */
 134         return fd;
 135     }
 136     /* set flock structure */
 137     lock.l_type = F_WRLCK;                        /* set type: read or write */
 138     lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
 139     lock.l_start = 0;                  /* set the start of the locked region */
 140     lock.l_len = 0;                   /* set the length of the locked region */
 141     /* do locking */
 142     if ( (res = fcntl(fd, F_SETLKW, &lock)) < 0 ) {
 143         return res;
 144     }
 145     return 0;
 146 }
 147 /*
 148  * Function UnlockMutex: unlock a file.
 149  *
 150  * Input:  a filename
 151  * Output: a return code  (0 OK, -1 KO)
 152  */
 153 int UnlockMutex(const char *path_name)
 154 {
 155     int fd, res;
 156     struct flock lock;                                /* file lock structure */
 157     /* first open the file */
 158     if ( (fd = open(path_name, O_RDWR)) < 0) {            /* first open file */
 159         return fd;
 160     }
 161     /* set flock structure */
 162     lock.l_type = F_UNLCK;                               /* set type: unlock */
 163     lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
 164     lock.l_start = 0;                  /* set the start of the locked region */
 165     lock.l_len = 0;                   /* set the length of the locked region */
 166     /* do locking */
 167     if ( (res = fcntl(fd, F_SETLK, &lock)) < 0 ) {
 168         return res;
 169     }
 170     return 0;
 171 }