sysv_shm.c revision 1.13
1 /* 2 * Copyright (c) 1994 Adam Glass 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. The name of the Author may not be used to endorse or promote products 11 * derived from this software without specific prior written permission. 12 * 13 * THIS SOFTWARE IS PROVIDED BY Adam Glass ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL Adam Glass BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/param.h> 28 #include <sys/kernel.h> 29 #include <sys/shm.h> 30 #include <sys/proc.h> 31 #include <sys/uio.h> 32 #include <sys/time.h> 33 #include <sys/malloc.h> 34 #include <sys/mman.h> 35 #include <sys/systm.h> 36 #include <sys/stat.h> 37 38 #include <vm/vm.h> 39 #include <vm/vm_map.h> 40 #include <vm/vm_map.h> 41 #include <vm/vm_kern.h> 42 43 /* 44 * Provides the following externally accessible functions: 45 * 46 * shminit(void); initialization 47 * shmexit(struct proc *) cleanup 48 * shmfork(struct proc *, struct proc *, int) fork handling 49 * shmsys(arg1, arg2, arg3, arg4); shm{at,ctl,dt,get}(arg2, arg3, arg4) 50 * 51 * Structures: 52 * shmsegs (an array of 'struct shmid_ds') 53 * per proc array of 'struct shmmap_state' 54 */ 55 56 int shmat(), shmctl(), shmdt(), shmget(); 57 int (*shmcalls[])() = { shmat, shmctl, shmdt, shmget }; 58 59 #define SHMSEG_FREE 0x200 60 #define SHMSEG_REMOVED 0x400 61 #define SHMSEG_ALLOCATED 0x800 62 63 vm_map_t sysvshm_map; 64 int shm_last_free, shm_nused, shm_committed; 65 66 struct shm_handle { 67 vm_offset_t kva; 68 }; 69 70 struct shmmap_state { 71 vm_offset_t va; 72 int shmid; 73 }; 74 75 static int shm_allocate_segment __P((struct proc *, key_t, size_t, int, int *)); 76 static void shm_deallocate_segment __P((struct shmid_ds *)); 77 static int shm_find_segment_by_key __P((key_t)); 78 static struct shmid_ds *shm_find_segment_by_shmid __P((int, int *)); 79 static int shm_delete_mapping __P((struct proc *, struct shmmap_state *)); 80 81 static int 82 shm_allocate_segment(p, key, size, mode, retval) 83 struct proc *p; 84 key_t key; 85 size_t size; 86 int mode; 87 int *retval; 88 { 89 int i, segnum, result, shmid; 90 struct ucred *cred = p->p_ucred; 91 struct shmid_ds *shmseg; 92 struct shm_handle *shm_handle; 93 94 if (shm_nused >= shminfo.shmmni) /* any shmids left? */ 95 return ENOSPC; 96 if (shm_last_free < 0) { 97 for (i = 0; i < shminfo.shmmni; i++) 98 if (shmsegs[i].shm_perm.mode & SHMSEG_FREE) 99 break; 100 if (i == shminfo.shmmni) 101 panic("shmseg free count inconsistent"); 102 segnum = i; 103 } else { 104 segnum = shm_last_free; 105 shm_last_free = -1; 106 } 107 shmseg = &shmsegs[segnum]; 108 /* 109 * In case we sleep in malloc(), mark the segment present but deleted 110 * so that noone else tries to create the same key. 111 */ 112 shmseg->shm_perm.mode = SHMSEG_ALLOCATED | SHMSEG_REMOVED; 113 shmseg->shm_perm.key = key; 114 shmseg->shm_perm.seq = (shmseg->shm_perm.seq + 1) & 0x7fff; 115 shm_handle = (struct shm_handle *) 116 malloc(sizeof(struct shm_handle), M_SHM, M_WAITOK); 117 shmid = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); 118 result = vm_mmap(sysvshm_map, &shm_handle->kva, ctob(size), 119 VM_PROT_ALL, VM_PROT_DEFAULT, MAP_ANON, shmid, 0); 120 if (result != KERN_SUCCESS) { 121 shmseg->shm_perm.mode = SHMSEG_FREE; 122 free((caddr_t)shm_handle, M_SHM); 123 return ENOMEM; 124 } 125 shmseg->shm_internal = shm_handle; 126 shm_committed += size; 127 shmseg->shm_perm.cuid = shmseg->shm_perm.uid = cred->cr_uid; 128 shmseg->shm_perm.cgid = shmseg->shm_perm.gid = cred->cr_gid; 129 shmseg->shm_perm.mode = (mode & ACCESSPERMS) | SHMSEG_ALLOCATED; 130 shmseg->shm_segsz = ctob(size); /* XXX */ 131 shmseg->shm_cpid = p->p_pid; 132 shmseg->shm_lpid = shmseg->shm_nattch = 0; 133 shmseg->shm_atime = shmseg->shm_dtime = 0; 134 shmseg->shm_ctime = time.tv_sec; 135 shm_nused++; 136 *retval = shmid; 137 return 0; 138 } 139 140 static int 141 shm_find_segment_by_key(key) 142 key_t key; 143 { 144 int i; 145 146 for (i = 0; i < shminfo.shmmni; i++) 147 if ((shmsegs[i].shm_perm.mode & SHMSEG_ALLOCATED) && 148 shmsegs[i].shm_perm.key == key) 149 return i; 150 return -1; 151 } 152 153 static struct shmid_ds * 154 shm_find_segment_by_shmid(shmid, where) 155 int shmid; 156 int *where; 157 { 158 int segnum; 159 struct shmid_ds *shmseg; 160 161 segnum = IPCID_TO_IX(shmid); 162 if (segnum < 0 || segnum >= shminfo.shmmni) 163 return NULL; 164 shmseg = &shmsegs[segnum]; 165 if ((shmseg->shm_perm.mode & (SHMSEG_ALLOCATED | SHMSEG_REMOVED)) 166 != SHMSEG_ALLOCATED || 167 shmseg->shm_perm.seq != IPCID_TO_SEQ(shmid)) 168 return NULL; 169 if (where) 170 *where = segnum; 171 return shmseg; 172 } 173 174 static vm_offset_t 175 shm_find_space(p, size) 176 struct proc *p; 177 size_t size; 178 { 179 vm_offset_t low_end, range, current; 180 int result; 181 182 low_end = (vm_offset_t)p->p_vmspace->vm_daddr + 183 (p->p_vmspace->vm_dsize << PGSHIFT); 184 range = (USRSTACK - low_end); 185 186 /* XXXX totally bogus */ 187 /* current = range *3/4 + low_end */ 188 current = ((range&1)<<1 + range)>>2 + range>>1 + low_end; 189 #if 0 190 result = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, ¤t, size, 191 TRUE); 192 if (result) 193 return NULL; 194 #endif 195 return current; 196 } 197 198 static void 199 shm_deallocate_segment(shmseg) 200 struct shmid_ds *shmseg; 201 { 202 struct shm_handle *shm_handle; 203 204 shm_handle = shmseg->shm_internal; 205 vm_deallocate(sysvshm_map, shm_handle->kva, 206 ctob(clrnd(btoc(shmseg->shm_segsz)))); 207 free((caddr_t)shm_handle, M_SHM); 208 shmseg->shm_internal = NULL; 209 shm_committed -= clrnd(btoc(shmseg->shm_segsz)); 210 shmseg->shm_perm.mode = SHMSEG_FREE; 211 } 212 213 static int 214 shm_delete_mapping(p, shmmap_s) 215 struct proc *p; 216 struct shmmap_state *shmmap_s; 217 { 218 struct shmid_ds *shmseg; 219 int segnum, result; 220 221 segnum = IPCID_TO_IX(shmmap_s->shmid); 222 shmseg = &shmsegs[segnum]; 223 result = vm_deallocate(&p->p_vmspace->vm_map, shmmap_s->va, 224 ctob(clrnd(btoc(shmseg->shm_segsz)))); 225 if (result != KERN_SUCCESS) 226 return EINVAL; 227 shmmap_s->shmid = -1; 228 shmseg->shm_dtime = time.tv_sec; 229 if ((--shmseg->shm_nattch <= 0) && 230 (shmseg->shm_perm.mode & SHMSEG_REMOVED)) { 231 shm_deallocate_segment(shmseg); 232 shm_last_free = segnum; 233 } 234 return 0; 235 } 236 237 struct shmdt_args { 238 void *shmaddr; 239 }; 240 int 241 shmdt(p, uap, retval) 242 struct proc *p; 243 struct shmdt_args *uap; 244 int *retval; 245 { 246 struct shmmap_state *shmmap_s; 247 int i; 248 249 shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 250 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) 251 if (shmmap_s->shmid != -1 && 252 shmmap_s->va == (vm_offset_t)uap->shmaddr) 253 break; 254 if (i == shminfo.shmseg) 255 return EINVAL; 256 return shm_delete_mapping(p, shmmap_s); 257 } 258 259 struct shmat_args { 260 int shmid; 261 void *shmaddr; 262 int shmflg; 263 }; 264 int 265 shmat(p, uap, retval) 266 struct proc *p; 267 struct shmat_args *uap; 268 int *retval; 269 { 270 int error, i, flags; 271 struct ucred *cred = p->p_ucred; 272 struct shmid_ds *shmseg; 273 struct shmmap_state *shmmap_s = NULL; 274 vm_offset_t attach_va; 275 vm_prot_t prot; 276 vm_size_t size; 277 278 shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 279 if (shmmap_s == NULL) { 280 size = shminfo.shmseg * sizeof(struct shmmap_state); 281 shmmap_s = malloc(size, M_SHM, M_WAITOK); 282 bzero((caddr_t)shmmap_s, size); 283 p->p_vmspace->vm_shm = (caddr_t)shmmap_s; 284 } 285 shmseg = shm_find_segment_by_shmid(uap->shmid, NULL); 286 if (shmseg == NULL) 287 return EINVAL; 288 if (error = ipcperm(cred, &shmseg->shm_perm, 289 (uap->shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W)) 290 return error; 291 for (i = 0; i < shminfo.shmseg; i++) { 292 if (shmmap_s->shmid == -1) 293 break; 294 shmmap_s++; 295 } 296 if (i >= shminfo.shmseg) 297 return EMFILE; 298 size = ctob(clrnd(btoc(shmseg->shm_segsz))); 299 prot = VM_PROT_READ; 300 if ((uap->shmflg & SHM_RDONLY) == 0) 301 prot |= VM_PROT_WRITE; 302 flags = MAP_ANON | MAP_SHARED; 303 if (uap->shmaddr) { 304 flags |= MAP_FIXED; 305 if (uap->shmflg & SHM_RND) 306 attach_va = (vm_offset_t)uap->shmaddr & ~(SHMLBA-1); 307 else 308 attach_va = (vm_offset_t)uap->shmaddr; 309 } else { 310 attach_va = shm_find_space(p, shmseg->shm_segsz); 311 if (attach_va == NULL) 312 return ENOMEM; 313 } 314 error = vm_mmap(&p->p_vmspace->vm_map, &attach_va, size, prot, 315 VM_PROT_DEFAULT, flags, uap->shmid, 0); 316 if (error) 317 return error; 318 shmmap_s->va = attach_va; 319 shmmap_s->shmid = uap->shmid; 320 shmseg->shm_lpid = p->p_pid; 321 shmseg->shm_atime = time.tv_sec; 322 shmseg->shm_nattch++; 323 *retval = attach_va; 324 return 0; 325 } 326 327 struct shmctl_args { 328 int shmid; 329 int cmd; 330 struct shmat_ds *ubuf; 331 }; 332 int 333 shmctl(p, uap, retval) 334 struct proc *p; 335 struct shmctl_args *uap; 336 int *retval; 337 { 338 int error, segnum; 339 struct ucred *cred = p->p_ucred; 340 struct shmid_ds inbuf; 341 struct shmid_ds *shmseg; 342 343 shmseg = shm_find_segment_by_shmid(uap->shmid, &segnum); 344 if (shmseg == NULL) 345 return EINVAL; 346 switch (uap->cmd) { 347 case IPC_STAT: 348 if (error = ipcperm(cred, &shmseg->shm_perm, IPC_R)) 349 return error; 350 if (error = copyout((caddr_t)shmseg, uap->ubuf, sizeof(inbuf))) 351 return error; 352 break; 353 case IPC_SET: 354 if (error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) 355 return error; 356 if (error = copyin(uap->ubuf, (caddr_t)&inbuf, sizeof(inbuf))) 357 return error; 358 shmseg->shm_perm.uid = inbuf.shm_perm.uid; 359 shmseg->shm_perm.gid = inbuf.shm_perm.gid; 360 shmseg->shm_perm.mode = 361 (shmseg->shm_perm.mode & ~ACCESSPERMS) | 362 (inbuf.shm_perm.mode & ACCESSPERMS); 363 shmseg->shm_ctime = time.tv_sec; 364 break; 365 case IPC_RMID: 366 if (error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) 367 return error; 368 shmseg->shm_perm.key = IPC_PRIVATE; 369 shmseg->shm_perm.mode |= SHMSEG_REMOVED; 370 if (shmseg->shm_nattch <= 0) { 371 shm_deallocate_segment(shmseg); 372 shm_last_free = segnum; 373 } 374 break; 375 #if 0 376 case SHM_LOCK: 377 case SHM_UNLOCK: 378 #endif 379 default: 380 return EINVAL; 381 } 382 return 0; 383 } 384 385 struct shmget_args { 386 key_t key; 387 size_t size; 388 int shmflg; 389 }; 390 static int 391 shmget_existing(p, uap, mode, segnum, retval) 392 struct proc *p; 393 struct shmget_args *uap; 394 int mode; 395 int segnum; 396 int *retval; 397 { 398 struct shmid_ds *shmseg; 399 struct ucred *cred = p->p_ucred; 400 int error; 401 402 shmseg = &shmsegs[segnum]; 403 if (shmseg->shm_perm.mode & SHMSEG_REMOVED) 404 return EBUSY; 405 if (error = ipcperm(cred, &shmseg->shm_perm, mode)) 406 return error; 407 if (uap->size && uap->size > shmseg->shm_segsz) 408 return EINVAL; 409 if (uap->shmflg & (IPC_CREAT | IPC_EXCL)) /* XXX */ 410 return EEXIST; 411 *retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); 412 return 0; 413 } 414 415 int 416 shmget(p, uap, retval) 417 struct proc *p; 418 struct shmget_args *uap; 419 int *retval; 420 { 421 int segnum, mode, error; 422 size_t size; 423 struct shmid_ds *shmseg; 424 425 mode = uap->shmflg & ACCESSPERMS; 426 if (uap->key != IPC_PRIVATE) { 427 segnum = shm_find_segment_by_key(uap->key); 428 if (segnum >= 0) 429 return shmget_existing(p, uap, mode, segnum, retval); 430 } 431 if ((uap->shmflg & IPC_CREAT) == 0) 432 return ENOENT; 433 if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax) 434 return EINVAL; 435 size = clrnd(btoc(uap->size)); 436 if (shm_committed + size > shminfo.shmall) 437 return ENOMEM; 438 return shm_allocate_segment(p, uap->key, size, mode, retval); 439 } 440 441 struct shmsys_args { 442 u_int which; 443 }; 444 int 445 shmsys(p, uap, retval) 446 struct proc *p; 447 struct shmsys_args *uap; 448 int *retval; 449 { 450 451 if (uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0])) 452 return EINVAL; 453 return ((*shmcalls[uap->which])(p, &uap[1], retval)); 454 } 455 456 void 457 shmfork(p1, p2, isvfork) 458 struct proc *p1, *p2; 459 int isvfork; 460 { 461 struct shmmap_state *shmmap_s; 462 size_t size; 463 int i; 464 465 size = shminfo.shmseg * sizeof(struct shmmap_state); 466 shmmap_s = malloc(size, M_SHM, M_WAITOK); 467 bcopy((caddr_t)p1->p_vmspace->vm_shm, (caddr_t)shmmap_s, size); 468 p2->p_vmspace->vm_shm = (caddr_t)shmmap_s; 469 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) 470 if (shmmap_s->shmid != -1) 471 shmsegs[IPCID_TO_IX(shmmap_s->shmid)].shm_nattch++; 472 } 473 474 void 475 shmexit(p) 476 struct proc *p; 477 { 478 struct shmmap_state *shmmap_s; 479 struct shmid_ds *shmseg; 480 int i; 481 482 shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 483 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) 484 if (shmmap_s->shmid != -1) 485 shm_delete_mapping(p, shmmap_s); 486 free((caddr_t)p->p_vmspace->vm_shm, M_SHM); 487 p->p_vmspace->vm_shm = NULL; 488 } 489 490 void 491 shminit() 492 { 493 int i; 494 vm_offset_t garbage1, garbage2; 495 496 /* actually this *should* be pageable. SHM_{LOCK,UNLOCK} */ 497 sysvshm_map = kmem_suballoc(kernel_map, &garbage1, &garbage2, 498 shminfo.shmall * NBPG, FALSE); 499 for (i = 0; i < shminfo.shmmni; i++) { 500 shmsegs[i].shm_perm.mode = SHMSEG_FREE; 501 shmsegs[i].shm_perm.seq = 0; 502 } 503 shm_last_free = 0; 504 shm_nused = 0; 505 shm_committed = 0; 506 } 507
Indexes created Tue Sep 30 20:09:53 GMT 2025