1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include "lint.h" 30 #include "mtlib.h" 31 #include <sys/types.h> 32 #include <semaphore.h> 33 #include <synch.h> 34 #include <errno.h> 35 #include <stdarg.h> 36 #include <limits.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <sys/stat.h> 40 #include <sys/mman.h> 41 #include <unistd.h> 42 #include <thread.h> 43 #include "pos4obj.h" 44 45 typedef struct semaddr { 46 struct semaddr *sad_next; /* next in the link */ 47 char sad_name[PATH_MAX + 1]; /* name of sem object */ 48 sem_t *sad_addr; /* mmapped address of semaphore */ 49 ino64_t sad_inode; /* inode # of the mmapped file */ 50 } semaddr_t; 51 52 static long semvaluemax = 0; 53 static semaddr_t *semheadp = NULL; 54 static mutex_t semlock = DEFAULTMUTEX; 55 56 sem_t * 57 sem_open(const char *path, int oflag, /* mode_t mode, int value */ ...) 58 { 59 va_list ap; 60 mode_t crmode = 0; 61 sem_t *sem = NULL; 62 struct stat64 statbuf; 63 semaddr_t *next = NULL; 64 int fd = 0; 65 int error = 0; 66 int cr_flag = 0; 67 uint_t value = 0; 68 69 if (__pos4obj_check(path) == -1) 70 return (SEM_FAILED); 71 72 /* acquire semaphore lock to have atomic operation */ 73 if (__pos4obj_lock(path, SEM_LOCK_TYPE) < 0) 74 return (SEM_FAILED); 75 76 /* modify oflag to have RDWR and filter CREATE mode only */ 77 oflag = (oflag & (O_CREAT|O_EXCL)) | (O_RDWR); 78 if (oflag & O_CREAT) { 79 if (semvaluemax == 0 && 80 (semvaluemax = _sysconf(_SC_SEM_VALUE_MAX)) <= 0) 81 semvaluemax = -1; 82 va_start(ap, oflag); 83 crmode = va_arg(ap, mode_t); 84 value = va_arg(ap, uint_t); 85 va_end(ap); 86 /* check value < the max for a named semaphore */ 87 if (semvaluemax < 0 || 88 (ulong_t)value > (ulong_t)semvaluemax) { 89 errno = EINVAL; 90 goto out; 91 } 92 } 93 94 errno = 0; 95 96 if ((fd = __pos4obj_open(path, SEM_DATA_TYPE, 97 oflag, crmode, &cr_flag)) < 0) 98 goto out; 99 100 if (cr_flag) 101 cr_flag = DFILE_CREATE | DFILE_OPEN; 102 else 103 cr_flag = DFILE_OPEN; 104 105 /* find out inode # for the opened file */ 106 if (fstat64(fd, &statbuf) < 0) 107 goto out; 108 109 /* if created, acquire total_size in the file */ 110 if ((cr_flag & DFILE_CREATE) != 0) { 111 if (ftruncate64(fd, (off64_t)sizeof (sem_t)) < 0) 112 goto out; 113 } else { 114 /* 115 * if this semaphore has already been opened, inode 116 * will indicate then return the same semaphore address 117 */ 118 lmutex_lock(&semlock); 119 for (next = semheadp; next != NULL; next = next->sad_next) { 120 if (statbuf.st_ino == next->sad_inode && 121 strcmp(path, next->sad_name) == 0) { 122 (void) __close_nc(fd); 123 lmutex_unlock(&semlock); 124 (void) __pos4obj_unlock(path, SEM_LOCK_TYPE); 125 return (next->sad_addr); 126 } 127 } 128 lmutex_unlock(&semlock); 129 } 130 131 132 /* new sem descriptor to be allocated and new address to be mapped */ 133 if ((next = malloc(sizeof (semaddr_t))) == NULL) { 134 errno = ENOMEM; 135 goto out; 136 } 137 cr_flag |= ALLOC_MEM; 138 139 /* LINTED */ 140 sem = (sem_t *)mmap64(NULL, sizeof (sem_t), PROT_READ|PROT_WRITE, 141 MAP_SHARED, fd, (off64_t)0); 142 (void) __close_nc(fd); 143 cr_flag &= ~DFILE_OPEN; 144 if (sem == MAP_FAILED) 145 goto out; 146 cr_flag |= DFILE_MMAP; 147 148 /* if created, initialize */ 149 if (cr_flag & DFILE_CREATE) { 150 error = sema_init((sema_t *)sem, value, USYNC_PROCESS, 0); 151 if (error) { 152 errno = error; 153 goto out; 154 } 155 } 156 157 if (__pos4obj_unlock(path, SEM_LOCK_TYPE) == 0) { 158 /* add to the list pointed by semheadp */ 159 lmutex_lock(&semlock); 160 next->sad_next = semheadp; 161 semheadp = next; 162 next->sad_addr = sem; 163 next->sad_inode = statbuf.st_ino; 164 (void) strcpy(next->sad_name, path); 165 lmutex_unlock(&semlock); 166 return (sem); 167 } 168 /* fall into the error case */ 169 out: 170 error = errno; 171 if ((cr_flag & DFILE_OPEN) != 0) 172 (void) __close_nc(fd); 173 if ((cr_flag & DFILE_CREATE) != 0) 174 (void) __pos4obj_unlink(path, SEM_DATA_TYPE); 175 if ((cr_flag & ALLOC_MEM) != 0) 176 free(next); 177 if ((cr_flag & DFILE_MMAP) != 0) 178 (void) munmap((caddr_t)sem, sizeof (sem_t)); 179 (void) __pos4obj_unlock(path, SEM_LOCK_TYPE); 180 errno = error; 181 return (SEM_FAILED); 182 } 183 184 int 185 sem_close(sem_t *sem) 186 { 187 semaddr_t **next; 188 semaddr_t *freeit; 189 190 lmutex_lock(&semlock); 191 for (next = &semheadp; (freeit = *next) != NULL; 192 next = &(freeit->sad_next)) { 193 if (freeit->sad_addr == sem) { 194 *next = freeit->sad_next; 195 lmutex_unlock(&semlock); 196 free(freeit); 197 return (munmap((caddr_t)sem, sizeof (sem_t))); 198 } 199 } 200 lmutex_unlock(&semlock); 201 errno = EINVAL; 202 return (-1); 203 } 204 205 int 206 sem_unlink(const char *path) 207 { 208 int error; 209 int oerrno; 210 211 if (__pos4obj_check(path) < 0) 212 return (-1); 213 214 if (__pos4obj_lock(path, SEM_LOCK_TYPE) < 0) 215 return (-1); 216 217 error = __pos4obj_unlink(path, SEM_DATA_TYPE); 218 219 oerrno = errno; 220 221 (void) __pos4obj_unlock(path, SEM_LOCK_TYPE); 222 223 errno = oerrno; 224 225 return (error); 226 } 227 228 /* 229 * SUSV3 requires ("shall fail") an EINVAL failure for operations 230 * on invalid semaphores, including uninitialized unnamed semaphores. 231 * The best we can do is check that the magic number is correct. 232 * This is not perfect, but it allows the test suite to pass. 233 * (Standards bodies are filled with fools and idiots.) 234 */ 235 static int 236 sem_invalid(sem_t *sem) 237 { 238 if (sem->sem_magic != SEMA_MAGIC) { 239 errno = EINVAL; 240 return (-1); 241 } 242 return (0); 243 } 244 245 int 246 sem_init(sem_t *sem, int pshared, uint_t value) 247 { 248 int error; 249 250 if ((error = sema_init((sema_t *)sem, value, 251 pshared ? USYNC_PROCESS : USYNC_THREAD, NULL)) != 0) { 252 errno = error; 253 return (-1); 254 } 255 return (0); 256 } 257 258 int 259 sem_destroy(sem_t *sem) 260 { 261 int error; 262 263 if (sem_invalid(sem)) 264 return (-1); 265 if ((error = sema_destroy((sema_t *)sem)) != 0) { 266 errno = error; 267 return (-1); 268 } 269 return (0); 270 } 271 272 int 273 sem_post(sem_t *sem) 274 { 275 int error; 276 277 if (sem_invalid(sem)) 278 return (-1); 279 if ((error = sema_post((sema_t *)sem)) != 0) { 280 errno = error; 281 return (-1); 282 } 283 return (0); 284 } 285 286 int 287 sem_wait(sem_t *sem) 288 { 289 int error; 290 291 if (sem_invalid(sem)) 292 return (-1); 293 if ((error = sema_wait((sema_t *)sem)) != 0) { 294 errno = error; 295 return (-1); 296 } 297 return (0); 298 } 299 300 int 301 sem_timedwait(sem_t *sem, const timespec_t *abstime) 302 { 303 int error; 304 305 if (sem_invalid(sem)) 306 return (-1); 307 if ((error = sema_timedwait((sema_t *)sem, abstime)) != 0) { 308 if (error == ETIME) 309 error = ETIMEDOUT; 310 errno = error; 311 return (-1); 312 } 313 return (0); 314 } 315 316 int 317 sem_reltimedwait_np(sem_t *sem, const timespec_t *reltime) 318 { 319 int error; 320 321 if (sem_invalid(sem)) 322 return (-1); 323 if ((error = sema_reltimedwait((sema_t *)sem, reltime)) != 0) { 324 if (error == ETIME) 325 error = ETIMEDOUT; 326 errno = error; 327 return (-1); 328 } 329 return (0); 330 } 331 332 int 333 sem_trywait(sem_t *sem) 334 { 335 int error; 336 337 if (sem_invalid(sem)) 338 return (-1); 339 if ((error = sema_trywait((sema_t *)sem)) != 0) { 340 if (error == EBUSY) 341 error = EAGAIN; 342 errno = error; 343 return (-1); 344 } 345 return (0); 346 } 347 348 int 349 sem_getvalue(sem_t *sem, int *sval) 350 { 351 if (sem_invalid(sem)) 352 return (-1); 353 *sval = (int)sem->sem_count; 354 return (0); 355 } 356