]>
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 CW |
40 | |
41 | /* arg for semctl system calls. */ | |
42 | union semun { | |
43 | int val; /* value for SETVAL */ | |
44 | struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */ | |
45 | ushort *array; /* array for GETALL & SETALL */ | |
46 | struct seminfo *__buf; /* buffer for IPC_INFO */ | |
47 | void *__pad; | |
48 | }; | |
49 | ||
50 | #define SEM_RESOURCE_MAX 1 /* Initial value of all semaphores */ | |
51 | ||
52 | void opensem(int *sid, key_t key); | |
53 | void createsem(int *sid, key_t key, int members); | |
54 | void locksem(int sid, int member); | |
55 | void unlocksem(int sid, int member); | |
56 | void removesem(int sid); | |
57 | unsigned short get_member_count(int sid); | |
58 | int getval(int sid, int member); | |
59 | void dispval(int sid, int member); | |
60 | void changemode(int sid, char *mode); | |
61 | void usage(void); | |
62 | ||
63 | int main(int argc, char *argv[]) | |
64 | { | |
65 | key_t key; | |
66 | int semset_id; | |
67 | ||
68 | if(argc == 1) | |
69 | usage(); | |
70 | ||
71 | /* Create unique key via call to ftok() */ | |
72 | key = ftok(".", 's'); | |
73 | ||
74 | switch(tolower(argv[1][0])) | |
75 | { | |
76 | case 'c': if(argc != 3) | |
77 | usage(); | |
78 | createsem(&semset_id, key, atoi(argv[2])); | |
79 | break; | |
80 | case 'l': if(argc != 3) | |
81 | usage(); | |
82 | opensem(&semset_id, key); | |
83 | locksem(semset_id, atoi(argv[2])); | |
84 | break; | |
85 | case 'u': if(argc != 3) | |
86 | usage(); | |
87 | opensem(&semset_id, key); | |
88 | unlocksem(semset_id, atoi(argv[2])); | |
89 | break; | |
90 | case 'd': opensem(&semset_id, key); | |
91 | removesem(semset_id); | |
92 | break; | |
93 | case 'm': opensem(&semset_id, key); | |
94 | changemode(semset_id, argv[2]); | |
95 | break; | |
96 | default: usage(); | |
97 | ||
98 | } | |
99 | ||
100 | return(0); | |
101 | } | |
102 | ||
103 | void opensem(int *sid, key_t key) | |
104 | { | |
105 | /* Open the semaphore set - do not create! */ | |
106 | ||
107 | if((*sid = semget(key, 0, 0666)) == -1) | |
108 | { | |
109 | printf("Semaphore set does not exist!\n"); | |
110 | exit(1); | |
111 | } | |
112 | ||
113 | } | |
114 | ||
115 | void createsem(int *sid, key_t key, int members) | |
116 | { | |
117 | int cntr; | |
118 | union semun semopts; | |
119 | ||
120 | if(members > SEMMSL) { | |
121 | printf("Sorry, max number of semaphores in a set is %d\n", | |
122 | SEMMSL); | |
123 | exit(1); | |
124 | } | |
125 | ||
126 | printf("Attempting to create new semaphore set with %d members\n", | |
127 | members); | |
128 | ||
129 | if((*sid = semget(key, members, IPC_CREAT|IPC_EXCL|0666)) | |
130 | == -1) | |
131 | { | |
132 | fprintf(stderr, "Semaphore set already exists!\n"); | |
133 | exit(1); | |
134 | } | |
135 | ||
136 | semopts.val = SEM_RESOURCE_MAX; | |
137 | ||
138 | /* Initialize all members (could be done with SETALL) */ | |
139 | for(cntr=0; cntr<members; cntr++) | |
140 | semctl(*sid, cntr, SETVAL, semopts); | |
141 | } | |
142 | ||
143 | void locksem(int sid, int member) | |
144 | { | |
145 | struct sembuf sem_lock={ 0, -1, IPC_NOWAIT}; | |
146 | ||
147 | if( member<0 || member>(get_member_count(sid)-1)) | |
148 | { | |
149 | fprintf(stderr, "semaphore member %d out of range\n", member); | |
150 | return; | |
151 | } | |
152 | ||
153 | /* Attempt to lock the semaphore set */ | |
154 | if(!getval(sid, member)) | |
155 | { | |
156 | fprintf(stderr, "Semaphore resources exhausted (no lock)!\n"); | |
157 | exit(1); | |
158 | } | |
159 | ||
160 | sem_lock.sem_num = member; | |
161 | ||
162 | if((semop(sid, &sem_lock, 1)) == -1) | |
163 | { | |
164 | fprintf(stderr, "Lock failed\n"); | |
165 | exit(1); | |
166 | } | |
167 | else | |
168 | printf("Semaphore resources decremented by one (locked)\n"); | |
169 | ||
170 | dispval(sid, member); | |
171 | } | |
172 | ||
173 | void unlocksem(int sid, int member) | |
174 | { | |
175 | struct sembuf sem_unlock={ member, 1, IPC_NOWAIT}; | |
176 | int semval; | |
177 | ||
178 | if( member<0 || member>(get_member_count(sid)-1)) | |
179 | { | |
180 | fprintf(stderr, "semaphore member %d out of range\n", member); | |
181 | return; | |
182 | } | |
183 | ||
184 | /* Is the semaphore set locked? */ | |
185 | semval = getval(sid, member); | |
186 | if(semval == SEM_RESOURCE_MAX) { | |
187 | fprintf(stderr, "Semaphore not locked!\n"); | |
188 | exit(1); | |
189 | } | |
190 | ||
191 | sem_unlock.sem_num = member; | |
192 | ||
193 | /* Attempt to lock the semaphore set */ | |
194 | if((semop(sid, &sem_unlock, 1)) == -1) | |
195 | { | |
196 | fprintf(stderr, "Unlock failed\n"); | |
197 | exit(1); | |
198 | } | |
199 | else | |
200 | printf("Semaphore resources incremented by one (unlocked)\n"); | |
201 | ||
202 | dispval(sid, member); | |
203 | } | |
204 | ||
205 | void removesem(int sid) | |
206 | { | |
207 | union semun semopts; | |
208 | semopts.val = 0; | |
209 | ||
210 | semctl(sid, 0, IPC_RMID, semopts); | |
211 | printf("Semaphore removed\n"); | |
212 | } | |
213 | ||
214 | unsigned short get_member_count(int sid) | |
215 | { | |
216 | union semun semopts; | |
217 | struct semid_ds mysemds; | |
218 | ||
219 | semopts.buf = &mysemds; | |
220 | ||
221 | /* Return number of members in the semaphore set */ | |
222 | return(semopts.buf->sem_nsems); | |
223 | } | |
224 | ||
225 | int getval(int sid, int member) | |
226 | { | |
227 | int semval; | |
228 | union semun semopts; | |
229 | semopts.val = 0; | |
230 | ||
231 | semval = semctl(sid, member, GETVAL, semopts); | |
232 | return(semval); | |
233 | } | |
234 | ||
235 | void changemode(int sid, char *mode) | |
236 | { | |
237 | int rc; | |
238 | union semun semopts; | |
239 | struct semid_ds mysemds; | |
240 | ||
241 | /* Get current values for internal data structure */ | |
242 | semopts.buf = &mysemds; | |
243 | ||
244 | rc = semctl(sid, 0, IPC_STAT, semopts); | |
245 | ||
246 | if (rc == -1) { | |
247 | perror("semctl"); | |
248 | exit(1); | |
249 | } | |
250 | ||
251 | printf("Old permissions were %o\n", semopts.buf->sem_perm.mode); | |
252 | ||
253 | /* Change the permissions on the semaphore */ | |
254 | sscanf(mode, "%ho", &semopts.buf->sem_perm.mode); | |
255 | ||
256 | /* Update the internal data structure */ | |
257 | semctl(sid, 0, IPC_SET, semopts); | |
258 | ||
259 | printf("Updated...\n"); | |
260 | ||
261 | } | |
262 | ||
263 | void dispval(int sid, int member) | |
264 | { | |
265 | int semval; | |
266 | union semun semopts; | |
267 | semopts.val = 0; | |
268 | ||
269 | semval = semctl(sid, member, GETVAL, semopts); | |
270 | printf("semval for member %d is %d\n", member, semval); | |
271 | } | |
272 | ||
273 | void usage(void) | |
274 | { | |
275 | fprintf(stderr, "semtool - A utility for tinkering with semaphores\n"); | |
276 | fprintf(stderr, "\nUSAGE: semtool (c)reate <semcount>\n"); | |
277 | fprintf(stderr, " (l)ock <sem #>\n"); | |
278 | fprintf(stderr, " (u)nlock <sem #>\n"); | |
279 | fprintf(stderr, " (d)elete\n"); | |
280 | fprintf(stderr, " (m)ode <mode>\n"); | |
281 | exit(1); | |
282 | } |