]>
Commit | Line | Data |
---|---|---|
d4a28ab0 CW |
1 | /***************************************************************************** |
2 | Excerpt from "Linux Programmer's Guide - Chapter 6" | |
3 | (C)opyright 1994-1995, Scott Burkett | |
4 | ***************************************************************************** | |
5 | MODULE: semtool.c | |
6 | ***************************************************************************** | |
7 | A command line tool for tinkering with SysV style Semaphore Sets | |
8 | ||
9 | *****************************************************************************/ | |
bd695173 CW |
10 | /* |
11 | * This program is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU General Public License | |
13 | * as published by the Free Software Foundation; either version 2 | |
14 | * of the License, or (at your option) any later version. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
24 | * | |
25 | * See the COPYING file for license information. | |
26 | */ | |
27 | ||
28 | #if HAVE_CONFIG_H | |
29 | # include "config.h" | |
30 | #endif | |
d4a28ab0 | 31 | |
d2b03e6a | 32 | #include "common.h" |
bd695173 CW |
33 | |
34 | #if HAVE_SYS_IPC_H | |
35 | # include <sys/ipc.h> | |
36 | #endif | |
37 | #if HAVE_SYS_SEM_H | |
38 | # include <sys/sem.h> | |
39 | #endif | |
d4a28ab0 | 40 | |
b5edac4c CW |
41 | /* cygserver doesn't define this constant where we |
42 | can get it, so just use the default configuration | |
43 | value */ | |
44 | #ifndef SEMMSL | |
45 | # define SEMMSL 60 | |
46 | #endif | |
47 | ||
d4a28ab0 CW |
48 | /* arg for semctl system calls. */ |
49 | union semun { | |
50 | int val; /* value for SETVAL */ | |
51 | struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */ | |
52 | ushort *array; /* array for GETALL & SETALL */ | |
53 | struct seminfo *__buf; /* buffer for IPC_INFO */ | |
54 | void *__pad; | |
55 | }; | |
56 | ||
57 | #define SEM_RESOURCE_MAX 1 /* Initial value of all semaphores */ | |
58 | ||
59 | void opensem(int *sid, key_t key); | |
60 | void createsem(int *sid, key_t key, int members); | |
61 | void locksem(int sid, int member); | |
62 | void unlocksem(int sid, int member); | |
63 | void removesem(int sid); | |
64 | unsigned short get_member_count(int sid); | |
65 | int getval(int sid, int member); | |
66 | void dispval(int sid, int member); | |
67 | void changemode(int sid, char *mode); | |
68 | void usage(void); | |
69 | ||
70 | int main(int argc, char *argv[]) | |
71 | { | |
72 | key_t key; | |
73 | int semset_id; | |
74 | ||
75 | if(argc == 1) | |
76 | usage(); | |
77 | ||
78 | /* Create unique key via call to ftok() */ | |
79 | key = ftok(".", 's'); | |
80 | ||
81 | switch(tolower(argv[1][0])) | |
82 | { | |
83 | case 'c': if(argc != 3) | |
84 | usage(); | |
85 | createsem(&semset_id, key, atoi(argv[2])); | |
86 | break; | |
87 | case 'l': if(argc != 3) | |
88 | usage(); | |
89 | opensem(&semset_id, key); | |
90 | locksem(semset_id, atoi(argv[2])); | |
91 | break; | |
92 | case 'u': if(argc != 3) | |
93 | usage(); | |
94 | opensem(&semset_id, key); | |
95 | unlocksem(semset_id, atoi(argv[2])); | |
96 | break; | |
97 | case 'd': opensem(&semset_id, key); | |
98 | removesem(semset_id); | |
99 | break; | |
100 | case 'm': opensem(&semset_id, key); | |
101 | changemode(semset_id, argv[2]); | |
102 | break; | |
103 | default: usage(); | |
104 | ||
105 | } | |
106 | ||
107 | return(0); | |
108 | } | |
109 | ||
110 | void opensem(int *sid, key_t key) | |
111 | { | |
112 | /* Open the semaphore set - do not create! */ | |
113 | ||
114 | if((*sid = semget(key, 0, 0666)) == -1) | |
115 | { | |
116 | printf("Semaphore set does not exist!\n"); | |
117 | exit(1); | |
118 | } | |
119 | ||
120 | } | |
121 | ||
122 | void createsem(int *sid, key_t key, int members) | |
123 | { | |
124 | int cntr; | |
125 | union semun semopts; | |
126 | ||
127 | if(members > SEMMSL) { | |
128 | printf("Sorry, max number of semaphores in a set is %d\n", | |
129 | SEMMSL); | |
130 | exit(1); | |
131 | } | |
132 | ||
133 | printf("Attempting to create new semaphore set with %d members\n", | |
134 | members); | |
135 | ||
136 | if((*sid = semget(key, members, IPC_CREAT|IPC_EXCL|0666)) | |
137 | == -1) | |
138 | { | |
139 | fprintf(stderr, "Semaphore set already exists!\n"); | |
140 | exit(1); | |
141 | } | |
142 | ||
143 | semopts.val = SEM_RESOURCE_MAX; | |
144 | ||
145 | /* Initialize all members (could be done with SETALL) */ | |
146 | for(cntr=0; cntr<members; cntr++) | |
147 | semctl(*sid, cntr, SETVAL, semopts); | |
148 | } | |
149 | ||
150 | void locksem(int sid, int member) | |
151 | { | |
152 | struct sembuf sem_lock={ 0, -1, IPC_NOWAIT}; | |
153 | ||
154 | if( member<0 || member>(get_member_count(sid)-1)) | |
155 | { | |
156 | fprintf(stderr, "semaphore member %d out of range\n", member); | |
157 | return; | |
158 | } | |
159 | ||
160 | /* Attempt to lock the semaphore set */ | |
161 | if(!getval(sid, member)) | |
162 | { | |
163 | fprintf(stderr, "Semaphore resources exhausted (no lock)!\n"); | |
164 | exit(1); | |
165 | } | |
166 | ||
167 | sem_lock.sem_num = member; | |
168 | ||
169 | if((semop(sid, &sem_lock, 1)) == -1) | |
170 | { | |
171 | fprintf(stderr, "Lock failed\n"); | |
172 | exit(1); | |
173 | } | |
174 | else | |
175 | printf("Semaphore resources decremented by one (locked)\n"); | |
176 | ||
177 | dispval(sid, member); | |
178 | } | |
179 | ||
180 | void unlocksem(int sid, int member) | |
181 | { | |
182 | struct sembuf sem_unlock={ member, 1, IPC_NOWAIT}; | |
183 | int semval; | |
184 | ||
185 | if( member<0 || member>(get_member_count(sid)-1)) | |
186 | { | |
187 | fprintf(stderr, "semaphore member %d out of range\n", member); | |
188 | return; | |
189 | } | |
190 | ||
191 | /* Is the semaphore set locked? */ | |
192 | semval = getval(sid, member); | |
193 | if(semval == SEM_RESOURCE_MAX) { | |
194 | fprintf(stderr, "Semaphore not locked!\n"); | |
195 | exit(1); | |
196 | } | |
197 | ||
198 | sem_unlock.sem_num = member; | |
199 | ||
200 | /* Attempt to lock the semaphore set */ | |
201 | if((semop(sid, &sem_unlock, 1)) == -1) | |
202 | { | |
203 | fprintf(stderr, "Unlock failed\n"); | |
204 | exit(1); | |
205 | } | |
206 | else | |
207 | printf("Semaphore resources incremented by one (unlocked)\n"); | |
208 | ||
209 | dispval(sid, member); | |
210 | } | |
211 | ||
212 | void removesem(int sid) | |
213 | { | |
214 | union semun semopts; | |
215 | semopts.val = 0; | |
216 | ||
217 | semctl(sid, 0, IPC_RMID, semopts); | |
218 | printf("Semaphore removed\n"); | |
219 | } | |
220 | ||
221 | unsigned short get_member_count(int sid) | |
222 | { | |
223 | union semun semopts; | |
224 | struct semid_ds mysemds; | |
225 | ||
226 | semopts.buf = &mysemds; | |
227 | ||
228 | /* Return number of members in the semaphore set */ | |
229 | return(semopts.buf->sem_nsems); | |
230 | } | |
231 | ||
232 | int getval(int sid, int member) | |
233 | { | |
234 | int semval; | |
235 | union semun semopts; | |
236 | semopts.val = 0; | |
237 | ||
238 | semval = semctl(sid, member, GETVAL, semopts); | |
239 | return(semval); | |
240 | } | |
241 | ||
242 | void changemode(int sid, char *mode) | |
243 | { | |
244 | int rc; | |
245 | union semun semopts; | |
246 | struct semid_ds mysemds; | |
247 | ||
248 | /* Get current values for internal data structure */ | |
249 | semopts.buf = &mysemds; | |
250 | ||
251 | rc = semctl(sid, 0, IPC_STAT, semopts); | |
252 | ||
253 | if (rc == -1) { | |
254 | perror("semctl"); | |
255 | exit(1); | |
256 | } | |
257 | ||
258 | printf("Old permissions were %o\n", semopts.buf->sem_perm.mode); | |
259 | ||
260 | /* Change the permissions on the semaphore */ | |
261 | sscanf(mode, "%ho", &semopts.buf->sem_perm.mode); | |
262 | ||
263 | /* Update the internal data structure */ | |
264 | semctl(sid, 0, IPC_SET, semopts); | |
265 | ||
266 | printf("Updated...\n"); | |
267 | ||
268 | } | |
269 | ||
270 | void dispval(int sid, int member) | |
271 | { | |
272 | int semval; | |
273 | union semun semopts; | |
274 | semopts.val = 0; | |
275 | ||
276 | semval = semctl(sid, member, GETVAL, semopts); | |
277 | printf("semval for member %d is %d\n", member, semval); | |
278 | } | |
279 | ||
280 | void usage(void) | |
281 | { | |
282 | fprintf(stderr, "semtool - A utility for tinkering with semaphores\n"); | |
283 | fprintf(stderr, "\nUSAGE: semtool (c)reate <semcount>\n"); | |
284 | fprintf(stderr, " (l)ock <sem #>\n"); | |
285 | fprintf(stderr, " (u)nlock <sem #>\n"); | |
286 | fprintf(stderr, " (d)elete\n"); | |
287 | fprintf(stderr, " (m)ode <mode>\n"); | |
288 | exit(1); | |
289 | } |