Definizione nuova sezione per clone, prctl, ptrace. Correzioni varie e
[gapil.git] / 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  *****************************************************************************/
26 #include <sys/sem.h>     /* SysV semaphores */
27 #include <sys/types.h>   /* primitive system data types */
28 #include <sys/stat.h>    /* file characteristics constants and functions */
29 #include <fcntl.h>       /* file control functions */
30 #include <signal.h>      /* signal constants, types and functions */
31
32 #include "Gapil.h"
33 /*
34  * Function MutexCreate: create a mutex/semaphore
35  *
36  * First call create a semaphore, using the given key. 
37  * We want only one semaphore so we set second argument to 1; third 
38  * parameter is the flag argument, and is set to create a semaphore 
39  * with R/W privilege for the user.
40  * Second call initialize the semaphore to 1 (unlocked)
41  *
42  * Input: an IPC key value (to create an unique semaphore)
43  * Return: the semaphore id# or -1 on error
44  */
45 int MutexCreate(key_t ipc_key) 
46 {
47     const union semun semunion={1};             /* semaphore union structure */
48     int sem_id, ret;
49     sem_id = semget(ipc_key, 1, IPC_CREAT|0666);         /* get semaphore ID */
50     if (sem_id == -1) {                              /* if error return code */
51         return sem_id;
52     }
53     ret = semctl(sem_id, 0, SETVAL, semunion);             /* init semaphore */
54     if (ret == -1) {
55         return ret;
56     }
57     return sem_id;
58 }
59 /*
60  * Function MutexFind: get the semaphore/mutex Id given the IPC key value
61  *
62  * Input: an IPC key value
63  */
64 int MutexFind(key_t ipc_key) 
65 {
66     return semget(ipc_key, 1, 0);
67 }
68 /*
69  * Function MutexRead: read the current value of the mutex/semaphore
70  *
71  * Input:  a semaphore id #
72  * Return: the semaphore value
73  */
74 int MutexRead(int sem_id) 
75 {
76     return semctl(sem_id, 0, GETVAL);
77 }
78 /*
79  * Define sembuf structures to lock and unlock the semaphore 
80  * (used to implement a mutex)
81  */
82 struct sembuf sem_lock={                                /* to lock semaphore */
83     0,                                   /* semaphore number (only one so 0) */
84     -1,                                    /* operation (-1 to use resource) */
85     SEM_UNDO};                                /* flag (set for undo at exit) */
86 struct sembuf sem_ulock={                             /* to unlock semaphore */
87     0,                                   /* semaphore number (only one so 0) */
88     1,                                  /* operation (1 to release resource) */
89     SEM_UNDO};                                      /* flag (in this case 0) */
90 /*
91  * Function MutexLock: to lock a mutex/semaphore
92  *
93  * Input:  a semaphore id #
94  * Output: semop return code  (0 OK, -1 KO)
95  */
96 int MutexLock(int sem_id) 
97 {
98     return semop(sem_id, &sem_lock, 1);
99 }
100 /*
101  * Function MutexUnlock: to unlock a mutex/semaphore
102  *
103  * Input:  a semaphore id #
104  * Return: semop return code (0 OK, -1 KO)
105  */
106 int MutexUnlock(int sem_id) 
107 {
108     return semop(sem_id, &sem_ulock, 1);
109 }
110 /*
111  * Function MutexRemove: remove a mutex/semaphore
112  *
113  * Input:  a semaphore id #
114  * Return: return code of semctl
115  */
116 int MutexRemove(int sem_id) 
117 {
118     return semctl(sem_id, 0, IPC_RMID);
119 }
120 /***************************************************************************** 
121  *
122  * File locking mutex 
123  *
124  * Create a mutex usinf file locking. Use file locking to lock a file
125  * as a mutex request, and unlock it as a mutex release.
126  *
127  * Author: S. Piccardi Dec. 2002
128  *
129  *****************************************************************************/
130 /*
131  * Function CreateMutex: Create a mutex using file locking.  
132  *
133  * Open a new lock file (creating it if not existent, and giving error
134  * otherwise). Is a simple wrapper for open.
135  *
136  * Input:  a filename
137  * Output: a file descriptor  (>0 OK, -1 KO)
138  */
139 int CreateMutex(const char *path_name)
140 {
141     return open(path_name, O_EXCL|O_CREAT);
142 }
143 /*
144  * Function UnlockMutex: unlock a file.  
145  * 
146  * Open a lock file (failing if not existent). Is a simple wrapper for
147  * open.
148  *
149  * Input:  a filename
150  * Output: a return code  (>0 OK, -1 KO)
151  */
152 int FindMutex(const char *path_name)
153 {
154     return open(path_name, O_RDWR);
155 }
156 /*
157  * Function LockMutex: lock mutex using file locking.
158  *
159  * Input:  a mutex (i.e. a file descriptor)
160  * Output: a return code  (0 OK, -1 KO)
161  */
162 int LockMutex(int fd)
163 {
164     struct flock lock;                                /* file lock structure */
165     /* first open the file (creating it if not existent) */
166     /* set flock structure */
167     lock.l_type = F_WRLCK;                        /* set type: read or write */
168     lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
169     lock.l_start = 0;                  /* set the start of the locked region */
170     lock.l_len = 0;                   /* set the length of the locked region */
171     /* do locking */
172     return fcntl(fd, F_SETLKW, &lock);
173 }
174 /*
175  * Function UnlockMutex: unlock a file.  
176  *
177  * Input:  a mutex (i.e. a file descriptor)
178  * Output: a return code  (0 OK, -1 KO)
179  */
180 int UnlockMutex(int fd)
181 {
182     struct flock lock;                                /* file lock structure */
183     /* set flock structure */
184     lock.l_type = F_UNLCK;                               /* set type: unlock */
185     lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
186     lock.l_start = 0;                  /* set the start of the locked region */
187     lock.l_len = 0;                   /* set the length of the locked region */
188     /* do locking */
189     return fcntl(fd, F_SETLK, &lock);
190 }
191 /*
192  * Function RemoveMutex: remove a mutex (unlinking the lock file).
193  * 
194  * Just remove the lock file.
195  *
196  * Input:  a filename
197  * Output: a return code (0 OK, -1 KO)
198  */
199 int RemoveMutex(const char *path_name)
200 {
201     return unlink(path_name);
202 }
203 /*
204  * Function ReadMutex: read a mutex status.
205  * 
206  * Read the status for a mutex.
207  *
208  * Input:  a mutex (i.e. a file descriptor)
209  * Output: the lock type (F_UNLCK,  F_RDLCK or  F_WRLCK, or -1 if KO)
210  */
211 int ReadMutex(int fd)
212 {
213     int res;
214     struct flock lock;                                /* file lock structure */
215     /* set flock structure */
216     lock.l_type = F_WRLCK;                               /* set type: unlock */
217     lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
218     lock.l_start = 0;                  /* set the start of the locked region */
219     lock.l_len = 0;                   /* set the length of the locked region */
220     /* do locking */
221     if ( (res = fcntl(fd, F_GETLK, &lock)) ) {
222         return res;
223     }
224     return lock.l_type;
225 }