1c3aac50fSPeter Wemm /* $FreeBSD$ */ 23d903220SDoug Rabson /* $NetBSD: sysv_shm.c,v 1.23 1994/07/04 23:25:12 glass Exp $ */ 33d903220SDoug Rabson 43d903220SDoug Rabson /* 53d903220SDoug Rabson * Copyright (c) 1994 Adam Glass and Charles Hannum. All rights reserved. 63d903220SDoug Rabson * 73d903220SDoug Rabson * Redistribution and use in source and binary forms, with or without 83d903220SDoug Rabson * modification, are permitted provided that the following conditions 93d903220SDoug Rabson * are met: 103d903220SDoug Rabson * 1. Redistributions of source code must retain the above copyright 113d903220SDoug Rabson * notice, this list of conditions and the following disclaimer. 123d903220SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 133d903220SDoug Rabson * notice, this list of conditions and the following disclaimer in the 143d903220SDoug Rabson * documentation and/or other materials provided with the distribution. 153d903220SDoug Rabson * 3. All advertising materials mentioning features or use of this software 163d903220SDoug Rabson * must display the following acknowledgement: 173d903220SDoug Rabson * This product includes software developed by Adam Glass and Charles 183d903220SDoug Rabson * Hannum. 193d903220SDoug Rabson * 4. The names of the authors may not be used to endorse or promote products 203d903220SDoug Rabson * derived from this software without specific prior written permission. 213d903220SDoug Rabson * 223d903220SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 233d903220SDoug Rabson * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 243d903220SDoug Rabson * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 253d903220SDoug Rabson * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 263d903220SDoug Rabson * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 273d903220SDoug Rabson * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 283d903220SDoug Rabson * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 293d903220SDoug Rabson * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 303d903220SDoug Rabson * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 313d903220SDoug Rabson * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 323d903220SDoug Rabson */ 333d903220SDoug Rabson 345591b823SEivind Eklund #include "opt_compat.h" 35255108f3SPeter Wemm #include "opt_sysvipc.h" 36511b67b7SGarrett Wollman 373d903220SDoug Rabson #include <sys/param.h> 38725db531SBruce Evans #include <sys/systm.h> 393d903220SDoug Rabson #include <sys/kernel.h> 40fb919e4dSMark Murray #include <sys/lock.h> 41255108f3SPeter Wemm #include <sys/sysctl.h> 423d903220SDoug Rabson #include <sys/shm.h> 433d903220SDoug Rabson #include <sys/proc.h> 443d903220SDoug Rabson #include <sys/malloc.h> 453d903220SDoug Rabson #include <sys/mman.h> 469dceb26bSJohn Baldwin #include <sys/mutex.h> 473d903220SDoug Rabson #include <sys/stat.h> 4878525ce3SAlfred Perlstein #include <sys/syscall.h> 49725db531SBruce Evans #include <sys/sysent.h> 50fb919e4dSMark Murray #include <sys/sysproto.h> 51cb1f0db9SRobert Watson #include <sys/jail.h> 523d903220SDoug Rabson 533d903220SDoug Rabson #include <vm/vm.h> 54efeaf95aSDavid Greenman #include <vm/vm_param.h> 55efeaf95aSDavid Greenman #include <vm/pmap.h> 56a51f7119SJohn Dyson #include <vm/vm_object.h> 573d903220SDoug Rabson #include <vm/vm_map.h> 581c7c3c6aSMatthew Dillon #include <vm/vm_page.h> 59ae9b8c3aSJohn Dyson #include <vm/vm_pager.h> 603d903220SDoug Rabson 61a1c995b6SPoul-Henning Kamp static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments"); 6255166637SPoul-Henning Kamp 63725db531SBruce Evans struct oshmctl_args; 644d77a549SAlfred Perlstein static int oshmctl(struct thread *td, struct oshmctl_args *uap); 65255108f3SPeter Wemm 664d77a549SAlfred Perlstein static int shmget_allocate_segment(struct thread *td, 674d77a549SAlfred Perlstein struct shmget_args *uap, int mode); 684d77a549SAlfred Perlstein static int shmget_existing(struct thread *td, struct shmget_args *uap, 694d77a549SAlfred Perlstein int mode, int segnum); 70725db531SBruce Evans 71725db531SBruce Evans /* XXX casting to (sy_call_t *) is bogus, as usual. */ 72303b270bSEivind Eklund static sy_call_t *shmcalls[] = { 73725db531SBruce Evans (sy_call_t *)shmat, (sy_call_t *)oshmctl, 74725db531SBruce Evans (sy_call_t *)shmdt, (sy_call_t *)shmget, 75725db531SBruce Evans (sy_call_t *)shmctl 76725db531SBruce Evans }; 773d903220SDoug Rabson 783d903220SDoug Rabson #define SHMSEG_FREE 0x0200 793d903220SDoug Rabson #define SHMSEG_REMOVED 0x0400 803d903220SDoug Rabson #define SHMSEG_ALLOCATED 0x0800 813d903220SDoug Rabson #define SHMSEG_WANTED 0x1000 823d903220SDoug Rabson 83255108f3SPeter Wemm static int shm_last_free, shm_nused, shm_committed, shmalloced; 84255108f3SPeter Wemm static struct shmid_ds *shmsegs; 853d903220SDoug Rabson 863d903220SDoug Rabson struct shm_handle { 87a51f7119SJohn Dyson /* vm_offset_t kva; */ 88a51f7119SJohn Dyson vm_object_t shm_object; 893d903220SDoug Rabson }; 903d903220SDoug Rabson 913d903220SDoug Rabson struct shmmap_state { 923d903220SDoug Rabson vm_offset_t va; 933d903220SDoug Rabson int shmid; 943d903220SDoug Rabson }; 953d903220SDoug Rabson 964d77a549SAlfred Perlstein static void shm_deallocate_segment(struct shmid_ds *); 974d77a549SAlfred Perlstein static int shm_find_segment_by_key(key_t); 984d77a549SAlfred Perlstein static struct shmid_ds *shm_find_segment_by_shmid(int); 994d77a549SAlfred Perlstein static struct shmid_ds *shm_find_segment_by_shmidx(int); 1004d77a549SAlfred Perlstein static int shm_delete_mapping(struct proc *p, struct shmmap_state *); 1014d77a549SAlfred Perlstein static void shmrealloc(void); 1024d77a549SAlfred Perlstein static void shminit(void); 1034d77a549SAlfred Perlstein static int sysvshm_modload(struct module *, int, void *); 1044d77a549SAlfred Perlstein static int shmunload(void); 1054d77a549SAlfred Perlstein static void shmexit_myhook(struct proc *p); 1064d77a549SAlfred Perlstein static void shmfork_myhook(struct proc *p1, struct proc *p2); 1074d77a549SAlfred Perlstein static int sysctl_shmsegs(SYSCTL_HANDLER_ARGS); 108255108f3SPeter Wemm 109255108f3SPeter Wemm /* 110028f979dSDima Dorfman * Tuneable values. 111255108f3SPeter Wemm */ 112255108f3SPeter Wemm #ifndef SHMMAXPGS 113028f979dSDima Dorfman #define SHMMAXPGS 8192 /* Note: sysv shared memory is swap backed. */ 114255108f3SPeter Wemm #endif 115255108f3SPeter Wemm #ifndef SHMMAX 116255108f3SPeter Wemm #define SHMMAX (SHMMAXPGS*PAGE_SIZE) 117255108f3SPeter Wemm #endif 118255108f3SPeter Wemm #ifndef SHMMIN 119255108f3SPeter Wemm #define SHMMIN 1 120255108f3SPeter Wemm #endif 121255108f3SPeter Wemm #ifndef SHMMNI 1221766b2e5SMatthew Dillon #define SHMMNI 192 123255108f3SPeter Wemm #endif 124255108f3SPeter Wemm #ifndef SHMSEG 1251766b2e5SMatthew Dillon #define SHMSEG 128 126255108f3SPeter Wemm #endif 127255108f3SPeter Wemm #ifndef SHMALL 128255108f3SPeter Wemm #define SHMALL (SHMMAXPGS) 129255108f3SPeter Wemm #endif 130255108f3SPeter Wemm 131255108f3SPeter Wemm struct shminfo shminfo = { 132255108f3SPeter Wemm SHMMAX, 133255108f3SPeter Wemm SHMMIN, 134255108f3SPeter Wemm SHMMNI, 135255108f3SPeter Wemm SHMSEG, 136255108f3SPeter Wemm SHMALL 137255108f3SPeter Wemm }; 138255108f3SPeter Wemm 1398b03c8edSMatthew Dillon static int shm_use_phys; 1408b03c8edSMatthew Dillon 141255108f3SPeter Wemm SYSCTL_DECL(_kern_ipc); 142255108f3SPeter Wemm SYSCTL_INT(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0, ""); 143255108f3SPeter Wemm SYSCTL_INT(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0, ""); 144255108f3SPeter Wemm SYSCTL_INT(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RD, &shminfo.shmmni, 0, ""); 145a02f3136SBrian Feldman SYSCTL_INT(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RD, &shminfo.shmseg, 0, ""); 146255108f3SPeter Wemm SYSCTL_INT(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0, ""); 147028f979dSDima Dorfman SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW, 148028f979dSDima Dorfman &shm_use_phys, 0, ""); 149a723c4e1SDima Dorfman SYSCTL_PROC(_kern_ipc, OID_AUTO, shmsegs, CTLFLAG_RD, 150a723c4e1SDima Dorfman NULL, 0, sysctl_shmsegs, "", ""); 1513d903220SDoug Rabson 1523d903220SDoug Rabson static int 1533d903220SDoug Rabson shm_find_segment_by_key(key) 1543d903220SDoug Rabson key_t key; 1553d903220SDoug Rabson { 1563d903220SDoug Rabson int i; 1573d903220SDoug Rabson 158255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 1593d903220SDoug Rabson if ((shmsegs[i].shm_perm.mode & SHMSEG_ALLOCATED) && 1603d903220SDoug Rabson shmsegs[i].shm_perm.key == key) 1613d903220SDoug Rabson return i; 1623d903220SDoug Rabson return -1; 1633d903220SDoug Rabson } 1643d903220SDoug Rabson 1653d903220SDoug Rabson static struct shmid_ds * 1663d903220SDoug Rabson shm_find_segment_by_shmid(shmid) 1673d903220SDoug Rabson int shmid; 1683d903220SDoug Rabson { 1693d903220SDoug Rabson int segnum; 1703d903220SDoug Rabson struct shmid_ds *shmseg; 1713d903220SDoug Rabson 1723d903220SDoug Rabson segnum = IPCID_TO_IX(shmid); 173255108f3SPeter Wemm if (segnum < 0 || segnum >= shmalloced) 1743d903220SDoug Rabson return NULL; 1753d903220SDoug Rabson shmseg = &shmsegs[segnum]; 1763d903220SDoug Rabson if ((shmseg->shm_perm.mode & (SHMSEG_ALLOCATED | SHMSEG_REMOVED)) 1773d903220SDoug Rabson != SHMSEG_ALLOCATED || 1783d903220SDoug Rabson shmseg->shm_perm.seq != IPCID_TO_SEQ(shmid)) 1793d903220SDoug Rabson return NULL; 1803d903220SDoug Rabson return shmseg; 1813d903220SDoug Rabson } 1823d903220SDoug Rabson 183491dec93SMichael Reifenberger static struct shmid_ds * 184491dec93SMichael Reifenberger shm_find_segment_by_shmidx(int segnum) 185491dec93SMichael Reifenberger { 186491dec93SMichael Reifenberger struct shmid_ds *shmseg; 187491dec93SMichael Reifenberger 188491dec93SMichael Reifenberger if (segnum < 0 || segnum >= shmalloced) 189491dec93SMichael Reifenberger return NULL; 190491dec93SMichael Reifenberger shmseg = &shmsegs[segnum]; 191491dec93SMichael Reifenberger if ((shmseg->shm_perm.mode & (SHMSEG_ALLOCATED | SHMSEG_REMOVED)) 192491dec93SMichael Reifenberger != SHMSEG_ALLOCATED ) 193491dec93SMichael Reifenberger return NULL; 194491dec93SMichael Reifenberger return shmseg; 195491dec93SMichael Reifenberger } 196491dec93SMichael Reifenberger 1973d903220SDoug Rabson static void 1983d903220SDoug Rabson shm_deallocate_segment(shmseg) 1993d903220SDoug Rabson struct shmid_ds *shmseg; 2003d903220SDoug Rabson { 2013d903220SDoug Rabson struct shm_handle *shm_handle; 2023d903220SDoug Rabson size_t size; 2033d903220SDoug Rabson 2040cddd8f0SMatthew Dillon GIANT_REQUIRED; 2050cddd8f0SMatthew Dillon 2063d903220SDoug Rabson shm_handle = shmseg->shm_internal; 207a51f7119SJohn Dyson vm_object_deallocate(shm_handle->shm_object); 2082cc593fdSAlfred Perlstein free(shm_handle, M_SHM); 2093d903220SDoug Rabson shmseg->shm_internal = NULL; 210a51f7119SJohn Dyson size = round_page(shmseg->shm_segsz); 2113d903220SDoug Rabson shm_committed -= btoc(size); 2123d903220SDoug Rabson shm_nused--; 2133d903220SDoug Rabson shmseg->shm_perm.mode = SHMSEG_FREE; 2143d903220SDoug Rabson } 2153d903220SDoug Rabson 2163d903220SDoug Rabson static int 2173d903220SDoug Rabson shm_delete_mapping(p, shmmap_s) 2183d903220SDoug Rabson struct proc *p; 2193d903220SDoug Rabson struct shmmap_state *shmmap_s; 2203d903220SDoug Rabson { 2213d903220SDoug Rabson struct shmid_ds *shmseg; 2223d903220SDoug Rabson int segnum, result; 2233d903220SDoug Rabson size_t size; 2243d903220SDoug Rabson 2250cddd8f0SMatthew Dillon GIANT_REQUIRED; 226028f979dSDima Dorfman 2273d903220SDoug Rabson segnum = IPCID_TO_IX(shmmap_s->shmid); 2283d903220SDoug Rabson shmseg = &shmsegs[segnum]; 229aa8de40aSPoul-Henning Kamp size = round_page(shmseg->shm_segsz); 230028f979dSDima Dorfman result = vm_map_remove(&p->p_vmspace->vm_map, shmmap_s->va, 231028f979dSDima Dorfman shmmap_s->va + size); 2323d903220SDoug Rabson if (result != KERN_SUCCESS) 2333d903220SDoug Rabson return EINVAL; 2343d903220SDoug Rabson shmmap_s->shmid = -1; 235227ee8a1SPoul-Henning Kamp shmseg->shm_dtime = time_second; 2363d903220SDoug Rabson if ((--shmseg->shm_nattch <= 0) && 2373d903220SDoug Rabson (shmseg->shm_perm.mode & SHMSEG_REMOVED)) { 2383d903220SDoug Rabson shm_deallocate_segment(shmseg); 2393d903220SDoug Rabson shm_last_free = segnum; 2403d903220SDoug Rabson } 2413d903220SDoug Rabson return 0; 2423d903220SDoug Rabson } 2433d903220SDoug Rabson 244b5d5c0c9SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 2453d903220SDoug Rabson struct shmdt_args { 2463d903220SDoug Rabson void *shmaddr; 2473d903220SDoug Rabson }; 248b5d5c0c9SPeter Wemm #endif 249b5d5c0c9SPeter Wemm 250b6a4b4f9SMatthew Dillon /* 251b6a4b4f9SMatthew Dillon * MPSAFE 252b6a4b4f9SMatthew Dillon */ 2533d903220SDoug Rabson int 254b40ce416SJulian Elischer shmdt(td, uap) 255b40ce416SJulian Elischer struct thread *td; 2563d903220SDoug Rabson struct shmdt_args *uap; 2573d903220SDoug Rabson { 258b40ce416SJulian Elischer struct proc *p = td->td_proc; 2593d903220SDoug Rabson struct shmmap_state *shmmap_s; 2603d903220SDoug Rabson int i; 261b6a4b4f9SMatthew Dillon int error = 0; 2623d903220SDoug Rabson 263c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 264c6f55f33SJohn Baldwin return (ENOSYS); 265b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 2663d903220SDoug Rabson shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 267b6a4b4f9SMatthew Dillon if (shmmap_s == NULL) { 268b6a4b4f9SMatthew Dillon error = EINVAL; 269b6a4b4f9SMatthew Dillon goto done2; 270b6a4b4f9SMatthew Dillon } 271b6a4b4f9SMatthew Dillon for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) { 2723d903220SDoug Rabson if (shmmap_s->shmid != -1 && 273b6a4b4f9SMatthew Dillon shmmap_s->va == (vm_offset_t)uap->shmaddr) { 2743d903220SDoug Rabson break; 275b6a4b4f9SMatthew Dillon } 276b6a4b4f9SMatthew Dillon } 277b6a4b4f9SMatthew Dillon if (i == shminfo.shmseg) { 278b6a4b4f9SMatthew Dillon error = EINVAL; 279b6a4b4f9SMatthew Dillon goto done2; 280b6a4b4f9SMatthew Dillon } 281a8dbafbeSDima Dorfman error = shm_delete_mapping(p, shmmap_s); 282b6a4b4f9SMatthew Dillon done2: 283b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 284b6a4b4f9SMatthew Dillon return (error); 2853d903220SDoug Rabson } 2863d903220SDoug Rabson 287b5d5c0c9SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 2883d903220SDoug Rabson struct shmat_args { 2893d903220SDoug Rabson int shmid; 2903d903220SDoug Rabson void *shmaddr; 2913d903220SDoug Rabson int shmflg; 2923d903220SDoug Rabson }; 293b5d5c0c9SPeter Wemm #endif 294b5d5c0c9SPeter Wemm 295b6a4b4f9SMatthew Dillon /* 296b6a4b4f9SMatthew Dillon * MPSAFE 297b6a4b4f9SMatthew Dillon */ 2983d903220SDoug Rabson int 299b40ce416SJulian Elischer shmat(td, uap) 300b40ce416SJulian Elischer struct thread *td; 3013d903220SDoug Rabson struct shmat_args *uap; 3023d903220SDoug Rabson { 303b40ce416SJulian Elischer struct proc *p = td->td_proc; 304b6a4b4f9SMatthew Dillon int i, flags; 3053d903220SDoug Rabson struct shmid_ds *shmseg; 3063d903220SDoug Rabson struct shmmap_state *shmmap_s = NULL; 307a51f7119SJohn Dyson struct shm_handle *shm_handle; 3083d903220SDoug Rabson vm_offset_t attach_va; 3093d903220SDoug Rabson vm_prot_t prot; 3103d903220SDoug Rabson vm_size_t size; 311a51f7119SJohn Dyson int rv; 312b6a4b4f9SMatthew Dillon int error = 0; 3133d903220SDoug Rabson 314c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 315c6f55f33SJohn Baldwin return (ENOSYS); 316b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 3173d903220SDoug Rabson shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 3183d903220SDoug Rabson if (shmmap_s == NULL) { 3193d903220SDoug Rabson size = shminfo.shmseg * sizeof(struct shmmap_state); 3203d903220SDoug Rabson shmmap_s = malloc(size, M_SHM, M_WAITOK); 3213d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++) 3223d903220SDoug Rabson shmmap_s[i].shmid = -1; 3232cc593fdSAlfred Perlstein p->p_vmspace->vm_shm = shmmap_s; 3243d903220SDoug Rabson } 3253d903220SDoug Rabson shmseg = shm_find_segment_by_shmid(uap->shmid); 326b6a4b4f9SMatthew Dillon if (shmseg == NULL) { 327b6a4b4f9SMatthew Dillon error = EINVAL; 328b6a4b4f9SMatthew Dillon goto done2; 329b6a4b4f9SMatthew Dillon } 330b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, 331797f2d22SPoul-Henning Kamp (uap->shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W); 332797f2d22SPoul-Henning Kamp if (error) 333b6a4b4f9SMatthew Dillon goto done2; 3343d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++) { 3353d903220SDoug Rabson if (shmmap_s->shmid == -1) 3363d903220SDoug Rabson break; 3373d903220SDoug Rabson shmmap_s++; 3383d903220SDoug Rabson } 339b6a4b4f9SMatthew Dillon if (i >= shminfo.shmseg) { 340b6a4b4f9SMatthew Dillon error = EMFILE; 341b6a4b4f9SMatthew Dillon goto done2; 342b6a4b4f9SMatthew Dillon } 343aa8de40aSPoul-Henning Kamp size = round_page(shmseg->shm_segsz); 344af25d10cSAlan Cox #ifdef VM_PROT_READ_IS_EXEC 345af25d10cSAlan Cox prot = VM_PROT_READ | VM_PROT_EXECUTE; 346af25d10cSAlan Cox #else 3473d903220SDoug Rabson prot = VM_PROT_READ; 348af25d10cSAlan Cox #endif 3493d903220SDoug Rabson if ((uap->shmflg & SHM_RDONLY) == 0) 3503d903220SDoug Rabson prot |= VM_PROT_WRITE; 3513d903220SDoug Rabson flags = MAP_ANON | MAP_SHARED; 3523d903220SDoug Rabson if (uap->shmaddr) { 3533d903220SDoug Rabson flags |= MAP_FIXED; 354b6a4b4f9SMatthew Dillon if (uap->shmflg & SHM_RND) { 3553d903220SDoug Rabson attach_va = (vm_offset_t)uap->shmaddr & ~(SHMLBA-1); 356b6a4b4f9SMatthew Dillon } else if (((vm_offset_t)uap->shmaddr & (SHMLBA-1)) == 0) { 3573d903220SDoug Rabson attach_va = (vm_offset_t)uap->shmaddr; 358b6a4b4f9SMatthew Dillon } else { 359b6a4b4f9SMatthew Dillon error = EINVAL; 360b6a4b4f9SMatthew Dillon goto done2; 361b6a4b4f9SMatthew Dillon } 3623d903220SDoug Rabson } else { 363028f979dSDima Dorfman /* 364028f979dSDima Dorfman * This is just a hint to vm_map_find() about where to 365028f979dSDima Dorfman * put it. 366028f979dSDima Dorfman */ 367028f979dSDima Dorfman attach_va = round_page((vm_offset_t)p->p_vmspace->vm_taddr 368cbc89bfbSPaul Saab + maxtsiz + maxdsiz); 3693d903220SDoug Rabson } 370a51f7119SJohn Dyson 371a51f7119SJohn Dyson shm_handle = shmseg->shm_internal; 372a51f7119SJohn Dyson vm_object_reference(shm_handle->shm_object); 373a51f7119SJohn Dyson rv = vm_map_find(&p->p_vmspace->vm_map, shm_handle->shm_object, 374a51f7119SJohn Dyson 0, &attach_va, size, (flags & MAP_FIXED)?0:1, prot, prot, 0); 375a51f7119SJohn Dyson if (rv != KERN_SUCCESS) { 376b6a4b4f9SMatthew Dillon error = ENOMEM; 377b6a4b4f9SMatthew Dillon goto done2; 378a51f7119SJohn Dyson } 3790463028cSJohn Dyson vm_map_inherit(&p->p_vmspace->vm_map, 3800463028cSJohn Dyson attach_va, attach_va + size, VM_INHERIT_SHARE); 3810463028cSJohn Dyson 3823d903220SDoug Rabson shmmap_s->va = attach_va; 3833d903220SDoug Rabson shmmap_s->shmid = uap->shmid; 3843d903220SDoug Rabson shmseg->shm_lpid = p->p_pid; 385227ee8a1SPoul-Henning Kamp shmseg->shm_atime = time_second; 3863d903220SDoug Rabson shmseg->shm_nattch++; 387b40ce416SJulian Elischer td->td_retval[0] = attach_va; 388b6a4b4f9SMatthew Dillon done2: 389b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 390b6a4b4f9SMatthew Dillon return (error); 3913d903220SDoug Rabson } 3923d903220SDoug Rabson 3938bec0921SDoug Rabson struct oshmid_ds { 3948bec0921SDoug Rabson struct ipc_perm shm_perm; /* operation perms */ 3958bec0921SDoug Rabson int shm_segsz; /* size of segment (bytes) */ 3968bec0921SDoug Rabson ushort shm_cpid; /* pid, creator */ 3978bec0921SDoug Rabson ushort shm_lpid; /* pid, last operation */ 3988bec0921SDoug Rabson short shm_nattch; /* no. of current attaches */ 3998bec0921SDoug Rabson time_t shm_atime; /* last attach time */ 4008bec0921SDoug Rabson time_t shm_dtime; /* last detach time */ 4018bec0921SDoug Rabson time_t shm_ctime; /* last change time */ 4028bec0921SDoug Rabson void *shm_handle; /* internal handle for shm segment */ 4038bec0921SDoug Rabson }; 4048bec0921SDoug Rabson 4058bec0921SDoug Rabson struct oshmctl_args { 4068bec0921SDoug Rabson int shmid; 4078bec0921SDoug Rabson int cmd; 4088bec0921SDoug Rabson struct oshmid_ds *ubuf; 4098bec0921SDoug Rabson }; 4108bec0921SDoug Rabson 411b6a4b4f9SMatthew Dillon /* 412b6a4b4f9SMatthew Dillon * MPSAFE 413b6a4b4f9SMatthew Dillon */ 41487b6de2bSPoul-Henning Kamp static int 415b40ce416SJulian Elischer oshmctl(td, uap) 416b40ce416SJulian Elischer struct thread *td; 4178bec0921SDoug Rabson struct oshmctl_args *uap; 4188bec0921SDoug Rabson { 4198bec0921SDoug Rabson #ifdef COMPAT_43 420b6a4b4f9SMatthew Dillon int error = 0; 4218bec0921SDoug Rabson struct shmid_ds *shmseg; 4228bec0921SDoug Rabson struct oshmid_ds outbuf; 4238bec0921SDoug Rabson 424c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 425c6f55f33SJohn Baldwin return (ENOSYS); 426b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 4278bec0921SDoug Rabson shmseg = shm_find_segment_by_shmid(uap->shmid); 428b6a4b4f9SMatthew Dillon if (shmseg == NULL) { 429b6a4b4f9SMatthew Dillon error = EINVAL; 430b6a4b4f9SMatthew Dillon goto done2; 431b6a4b4f9SMatthew Dillon } 4328bec0921SDoug Rabson switch (uap->cmd) { 4338bec0921SDoug Rabson case IPC_STAT: 434b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, IPC_R); 435797f2d22SPoul-Henning Kamp if (error) 436b6a4b4f9SMatthew Dillon goto done2; 4378bec0921SDoug Rabson outbuf.shm_perm = shmseg->shm_perm; 4388bec0921SDoug Rabson outbuf.shm_segsz = shmseg->shm_segsz; 4398bec0921SDoug Rabson outbuf.shm_cpid = shmseg->shm_cpid; 4408bec0921SDoug Rabson outbuf.shm_lpid = shmseg->shm_lpid; 4418bec0921SDoug Rabson outbuf.shm_nattch = shmseg->shm_nattch; 4428bec0921SDoug Rabson outbuf.shm_atime = shmseg->shm_atime; 4438bec0921SDoug Rabson outbuf.shm_dtime = shmseg->shm_dtime; 4448bec0921SDoug Rabson outbuf.shm_ctime = shmseg->shm_ctime; 4458bec0921SDoug Rabson outbuf.shm_handle = shmseg->shm_internal; 4462cc593fdSAlfred Perlstein error = copyout(&outbuf, uap->ubuf, sizeof(outbuf)); 447797f2d22SPoul-Henning Kamp if (error) 448b6a4b4f9SMatthew Dillon goto done2; 4498bec0921SDoug Rabson break; 4508bec0921SDoug Rabson default: 451725db531SBruce Evans /* XXX casting to (sy_call_t *) is bogus, as usual. */ 452b40ce416SJulian Elischer error = ((sy_call_t *)shmctl)(td, uap); 453b6a4b4f9SMatthew Dillon break; 4548bec0921SDoug Rabson } 455b6a4b4f9SMatthew Dillon done2: 456b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 457b6a4b4f9SMatthew Dillon return (error); 4588bec0921SDoug Rabson #else 4598bec0921SDoug Rabson return EINVAL; 4608bec0921SDoug Rabson #endif 4618bec0921SDoug Rabson } 4628bec0921SDoug Rabson 463b5d5c0c9SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 4643d903220SDoug Rabson struct shmctl_args { 4653d903220SDoug Rabson int shmid; 4663d903220SDoug Rabson int cmd; 467b5d5c0c9SPeter Wemm struct shmid_ds *buf; 4683d903220SDoug Rabson }; 469b5d5c0c9SPeter Wemm #endif 470b5d5c0c9SPeter Wemm 471b6a4b4f9SMatthew Dillon /* 472b6a4b4f9SMatthew Dillon * MPSAFE 473b6a4b4f9SMatthew Dillon */ 4743d903220SDoug Rabson int 475b40ce416SJulian Elischer shmctl(td, uap) 476b40ce416SJulian Elischer struct thread *td; 4773d903220SDoug Rabson struct shmctl_args *uap; 4783d903220SDoug Rabson { 479b6a4b4f9SMatthew Dillon int error = 0; 4803d903220SDoug Rabson struct shmid_ds inbuf; 4813d903220SDoug Rabson struct shmid_ds *shmseg; 4823d903220SDoug Rabson 483c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 484c6f55f33SJohn Baldwin return (ENOSYS); 485b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 486491dec93SMichael Reifenberger switch (uap->cmd) { 487491dec93SMichael Reifenberger case IPC_INFO: 4882cc593fdSAlfred Perlstein error = copyout(&shminfo, uap->buf, sizeof(shminfo)); 489491dec93SMichael Reifenberger if (error) 490491dec93SMichael Reifenberger goto done2; 491491dec93SMichael Reifenberger td->td_retval[0] = shmalloced; 492491dec93SMichael Reifenberger goto done2; 493491dec93SMichael Reifenberger case SHM_INFO: { 494491dec93SMichael Reifenberger struct shm_info shm_info; 495491dec93SMichael Reifenberger shm_info.used_ids = shm_nused; 496491dec93SMichael Reifenberger shm_info.shm_rss = 0; /*XXX where to get from ? */ 497491dec93SMichael Reifenberger shm_info.shm_tot = 0; /*XXX where to get from ? */ 498491dec93SMichael Reifenberger shm_info.shm_swp = 0; /*XXX where to get from ? */ 499491dec93SMichael Reifenberger shm_info.swap_attempts = 0; /*XXX where to get from ? */ 500491dec93SMichael Reifenberger shm_info.swap_successes = 0; /*XXX where to get from ? */ 5012cc593fdSAlfred Perlstein error = copyout(&shm_info, uap->buf, sizeof(shm_info)); 502491dec93SMichael Reifenberger if (error) 503491dec93SMichael Reifenberger goto done2; 504491dec93SMichael Reifenberger td->td_retval[0] = shmalloced; 505491dec93SMichael Reifenberger goto done2; 506491dec93SMichael Reifenberger } 507491dec93SMichael Reifenberger } 508491dec93SMichael Reifenberger if( (uap->cmd) == SHM_STAT ) 509491dec93SMichael Reifenberger shmseg = shm_find_segment_by_shmidx(uap->shmid); 510491dec93SMichael Reifenberger else 5113d903220SDoug Rabson shmseg = shm_find_segment_by_shmid(uap->shmid); 512b6a4b4f9SMatthew Dillon if (shmseg == NULL) { 513b6a4b4f9SMatthew Dillon error = EINVAL; 514b6a4b4f9SMatthew Dillon goto done2; 515b6a4b4f9SMatthew Dillon } 5163d903220SDoug Rabson switch (uap->cmd) { 517491dec93SMichael Reifenberger case SHM_STAT: 5183d903220SDoug Rabson case IPC_STAT: 519b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, IPC_R); 520797f2d22SPoul-Henning Kamp if (error) 521b6a4b4f9SMatthew Dillon goto done2; 5222cc593fdSAlfred Perlstein error = copyout(shmseg, uap->buf, sizeof(inbuf)); 523797f2d22SPoul-Henning Kamp if (error) 524b6a4b4f9SMatthew Dillon goto done2; 525491dec93SMichael Reifenberger else if( (uap->cmd) == SHM_STAT ) 526491dec93SMichael Reifenberger td->td_retval[0] = IXSEQ_TO_IPCID( uap->shmid, shmseg->shm_perm ); 5273d903220SDoug Rabson break; 5283d903220SDoug Rabson case IPC_SET: 529b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, IPC_M); 530797f2d22SPoul-Henning Kamp if (error) 531b6a4b4f9SMatthew Dillon goto done2; 5322cc593fdSAlfred Perlstein error = copyin(uap->buf, &inbuf, sizeof(inbuf)); 533797f2d22SPoul-Henning Kamp if (error) 534b6a4b4f9SMatthew Dillon goto done2; 5353d903220SDoug Rabson shmseg->shm_perm.uid = inbuf.shm_perm.uid; 5363d903220SDoug Rabson shmseg->shm_perm.gid = inbuf.shm_perm.gid; 5373d903220SDoug Rabson shmseg->shm_perm.mode = 5383d903220SDoug Rabson (shmseg->shm_perm.mode & ~ACCESSPERMS) | 5393d903220SDoug Rabson (inbuf.shm_perm.mode & ACCESSPERMS); 540227ee8a1SPoul-Henning Kamp shmseg->shm_ctime = time_second; 5413d903220SDoug Rabson break; 5423d903220SDoug Rabson case IPC_RMID: 543b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, IPC_M); 544797f2d22SPoul-Henning Kamp if (error) 545b6a4b4f9SMatthew Dillon goto done2; 5463d903220SDoug Rabson shmseg->shm_perm.key = IPC_PRIVATE; 5473d903220SDoug Rabson shmseg->shm_perm.mode |= SHMSEG_REMOVED; 5483d903220SDoug Rabson if (shmseg->shm_nattch <= 0) { 5493d903220SDoug Rabson shm_deallocate_segment(shmseg); 5503d903220SDoug Rabson shm_last_free = IPCID_TO_IX(uap->shmid); 5513d903220SDoug Rabson } 5523d903220SDoug Rabson break; 5533d903220SDoug Rabson #if 0 5543d903220SDoug Rabson case SHM_LOCK: 5553d903220SDoug Rabson case SHM_UNLOCK: 5563d903220SDoug Rabson #endif 5573d903220SDoug Rabson default: 558b6a4b4f9SMatthew Dillon error = EINVAL; 559b6a4b4f9SMatthew Dillon break; 5603d903220SDoug Rabson } 561b6a4b4f9SMatthew Dillon done2: 562b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 563b6a4b4f9SMatthew Dillon return (error); 5643d903220SDoug Rabson } 5653d903220SDoug Rabson 566b5d5c0c9SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 5673d903220SDoug Rabson struct shmget_args { 5683d903220SDoug Rabson key_t key; 5693d903220SDoug Rabson size_t size; 5703d903220SDoug Rabson int shmflg; 5713d903220SDoug Rabson }; 572b5d5c0c9SPeter Wemm #endif 573b5d5c0c9SPeter Wemm 5743d903220SDoug Rabson static int 575b40ce416SJulian Elischer shmget_existing(td, uap, mode, segnum) 576b40ce416SJulian Elischer struct thread *td; 5773d903220SDoug Rabson struct shmget_args *uap; 5783d903220SDoug Rabson int mode; 5793d903220SDoug Rabson int segnum; 5803d903220SDoug Rabson { 5813d903220SDoug Rabson struct shmid_ds *shmseg; 5823d903220SDoug Rabson int error; 5833d903220SDoug Rabson 5843d903220SDoug Rabson shmseg = &shmsegs[segnum]; 5853d903220SDoug Rabson if (shmseg->shm_perm.mode & SHMSEG_REMOVED) { 5863d903220SDoug Rabson /* 5873d903220SDoug Rabson * This segment is in the process of being allocated. Wait 5883d903220SDoug Rabson * until it's done, and look the key up again (in case the 5893d903220SDoug Rabson * allocation failed or it was freed). 5903d903220SDoug Rabson */ 5913d903220SDoug Rabson shmseg->shm_perm.mode |= SHMSEG_WANTED; 5922cc593fdSAlfred Perlstein error = tsleep(shmseg, PLOCK | PCATCH, "shmget", 0); 593797f2d22SPoul-Henning Kamp if (error) 5943d903220SDoug Rabson return error; 5953d903220SDoug Rabson return EAGAIN; 5963d903220SDoug Rabson } 597dc92aa57SAlan Cox if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL)) 598dc92aa57SAlan Cox return EEXIST; 599b40ce416SJulian Elischer error = ipcperm(td, &shmseg->shm_perm, mode); 600797f2d22SPoul-Henning Kamp if (error) 6013d903220SDoug Rabson return error; 6023d903220SDoug Rabson if (uap->size && uap->size > shmseg->shm_segsz) 6033d903220SDoug Rabson return EINVAL; 604b40ce416SJulian Elischer td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); 6053d903220SDoug Rabson return 0; 6063d903220SDoug Rabson } 6073d903220SDoug Rabson 6083d903220SDoug Rabson static int 609b40ce416SJulian Elischer shmget_allocate_segment(td, uap, mode) 610b40ce416SJulian Elischer struct thread *td; 6113d903220SDoug Rabson struct shmget_args *uap; 6123d903220SDoug Rabson int mode; 6133d903220SDoug Rabson { 614a51f7119SJohn Dyson int i, segnum, shmid, size; 615a854ed98SJohn Baldwin struct ucred *cred = td->td_ucred; 6163d903220SDoug Rabson struct shmid_ds *shmseg; 6173d903220SDoug Rabson struct shm_handle *shm_handle; 6183d903220SDoug Rabson 6190cddd8f0SMatthew Dillon GIANT_REQUIRED; 6200cddd8f0SMatthew Dillon 6213d903220SDoug Rabson if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax) 6223d903220SDoug Rabson return EINVAL; 623028f979dSDima Dorfman if (shm_nused >= shminfo.shmmni) /* Any shmids left? */ 6243d903220SDoug Rabson return ENOSPC; 6259e609ddeSJoerg Wunsch size = round_page(uap->size); 6263d903220SDoug Rabson if (shm_committed + btoc(size) > shminfo.shmall) 6273d903220SDoug Rabson return ENOMEM; 6283d903220SDoug Rabson if (shm_last_free < 0) { 629028f979dSDima Dorfman shmrealloc(); /* Maybe expand the shmsegs[] array. */ 630255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 6313d903220SDoug Rabson if (shmsegs[i].shm_perm.mode & SHMSEG_FREE) 6323d903220SDoug Rabson break; 633255108f3SPeter Wemm if (i == shmalloced) 634255108f3SPeter Wemm return ENOSPC; 6353d903220SDoug Rabson segnum = i; 6363d903220SDoug Rabson } else { 6373d903220SDoug Rabson segnum = shm_last_free; 6383d903220SDoug Rabson shm_last_free = -1; 6393d903220SDoug Rabson } 6403d903220SDoug Rabson shmseg = &shmsegs[segnum]; 6413d903220SDoug Rabson /* 6423d903220SDoug Rabson * In case we sleep in malloc(), mark the segment present but deleted 6433d903220SDoug Rabson * so that noone else tries to create the same key. 6443d903220SDoug Rabson */ 6453d903220SDoug Rabson shmseg->shm_perm.mode = SHMSEG_ALLOCATED | SHMSEG_REMOVED; 6463d903220SDoug Rabson shmseg->shm_perm.key = uap->key; 6473d903220SDoug Rabson shmseg->shm_perm.seq = (shmseg->shm_perm.seq + 1) & 0x7fff; 6483d903220SDoug Rabson shm_handle = (struct shm_handle *) 6493d903220SDoug Rabson malloc(sizeof(struct shm_handle), M_SHM, M_WAITOK); 6503d903220SDoug Rabson shmid = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); 651a51f7119SJohn Dyson 652ae9b8c3aSJohn Dyson /* 653ae9b8c3aSJohn Dyson * We make sure that we have allocated a pager before we need 654ae9b8c3aSJohn Dyson * to. 655ae9b8c3aSJohn Dyson */ 6568b03c8edSMatthew Dillon if (shm_use_phys) { 65724488c74SPeter Wemm shm_handle->shm_object = 65824488c74SPeter Wemm vm_pager_allocate(OBJT_PHYS, 0, size, VM_PROT_DEFAULT, 0); 6598b03c8edSMatthew Dillon } else { 660a51f7119SJohn Dyson shm_handle->shm_object = 6616cde7a16SDavid Greenman vm_pager_allocate(OBJT_SWAP, 0, size, VM_PROT_DEFAULT, 0); 6628b03c8edSMatthew Dillon } 663069e9bc1SDoug Rabson vm_object_clear_flag(shm_handle->shm_object, OBJ_ONEMAPPING); 664069e9bc1SDoug Rabson vm_object_set_flag(shm_handle->shm_object, OBJ_NOSPLIT); 665cbd8ec09SJohn Dyson 6663d903220SDoug Rabson shmseg->shm_internal = shm_handle; 6673d903220SDoug Rabson shmseg->shm_perm.cuid = shmseg->shm_perm.uid = cred->cr_uid; 6683d903220SDoug Rabson shmseg->shm_perm.cgid = shmseg->shm_perm.gid = cred->cr_gid; 6693d903220SDoug Rabson shmseg->shm_perm.mode = (shmseg->shm_perm.mode & SHMSEG_WANTED) | 6703d903220SDoug Rabson (mode & ACCESSPERMS) | SHMSEG_ALLOCATED; 6713d903220SDoug Rabson shmseg->shm_segsz = uap->size; 672b40ce416SJulian Elischer shmseg->shm_cpid = td->td_proc->p_pid; 6733d903220SDoug Rabson shmseg->shm_lpid = shmseg->shm_nattch = 0; 6743d903220SDoug Rabson shmseg->shm_atime = shmseg->shm_dtime = 0; 675227ee8a1SPoul-Henning Kamp shmseg->shm_ctime = time_second; 6763d903220SDoug Rabson shm_committed += btoc(size); 6773d903220SDoug Rabson shm_nused++; 6783d903220SDoug Rabson if (shmseg->shm_perm.mode & SHMSEG_WANTED) { 6793d903220SDoug Rabson /* 6803d903220SDoug Rabson * Somebody else wanted this key while we were asleep. Wake 6813d903220SDoug Rabson * them up now. 6823d903220SDoug Rabson */ 6833d903220SDoug Rabson shmseg->shm_perm.mode &= ~SHMSEG_WANTED; 6842cc593fdSAlfred Perlstein wakeup(shmseg); 6853d903220SDoug Rabson } 686b40ce416SJulian Elischer td->td_retval[0] = shmid; 6873d903220SDoug Rabson return 0; 6883d903220SDoug Rabson } 6893d903220SDoug Rabson 690b6a4b4f9SMatthew Dillon /* 691b6a4b4f9SMatthew Dillon * MPSAFE 692b6a4b4f9SMatthew Dillon */ 6933d903220SDoug Rabson int 694b40ce416SJulian Elischer shmget(td, uap) 695b40ce416SJulian Elischer struct thread *td; 6963d903220SDoug Rabson struct shmget_args *uap; 6973d903220SDoug Rabson { 698b6a4b4f9SMatthew Dillon int segnum, mode; 699b6a4b4f9SMatthew Dillon int error; 7003d903220SDoug Rabson 701c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 702c6f55f33SJohn Baldwin return (ENOSYS); 703b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 7043d903220SDoug Rabson mode = uap->shmflg & ACCESSPERMS; 7053d903220SDoug Rabson if (uap->key != IPC_PRIVATE) { 7063d903220SDoug Rabson again: 7073d903220SDoug Rabson segnum = shm_find_segment_by_key(uap->key); 7083d903220SDoug Rabson if (segnum >= 0) { 709b40ce416SJulian Elischer error = shmget_existing(td, uap, mode, segnum); 7103d903220SDoug Rabson if (error == EAGAIN) 7113d903220SDoug Rabson goto again; 712b6a4b4f9SMatthew Dillon goto done2; 7133d903220SDoug Rabson } 714b6a4b4f9SMatthew Dillon if ((uap->shmflg & IPC_CREAT) == 0) { 715b6a4b4f9SMatthew Dillon error = ENOENT; 716b6a4b4f9SMatthew Dillon goto done2; 7173d903220SDoug Rabson } 718b6a4b4f9SMatthew Dillon } 719b40ce416SJulian Elischer error = shmget_allocate_segment(td, uap, mode); 720b6a4b4f9SMatthew Dillon done2: 721b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 722b6a4b4f9SMatthew Dillon return (error); 7233d903220SDoug Rabson } 7243d903220SDoug Rabson 725b6a4b4f9SMatthew Dillon /* 726b6a4b4f9SMatthew Dillon * MPSAFE 727b6a4b4f9SMatthew Dillon */ 7283d903220SDoug Rabson int 729b40ce416SJulian Elischer shmsys(td, uap) 730b40ce416SJulian Elischer struct thread *td; 731725db531SBruce Evans /* XXX actually varargs. */ 732725db531SBruce Evans struct shmsys_args /* { 733725db531SBruce Evans u_int which; 734725db531SBruce Evans int a2; 735725db531SBruce Evans int a3; 736725db531SBruce Evans int a4; 737725db531SBruce Evans } */ *uap; 7383d903220SDoug Rabson { 739b6a4b4f9SMatthew Dillon int error; 7403d903220SDoug Rabson 741c6f55f33SJohn Baldwin if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 742c6f55f33SJohn Baldwin return (ENOSYS); 743c6f55f33SJohn Baldwin if (uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0])) 744c6f55f33SJohn Baldwin return (EINVAL); 745b6a4b4f9SMatthew Dillon mtx_lock(&Giant); 746b40ce416SJulian Elischer error = (*shmcalls[uap->which])(td, &uap->a2); 747b6a4b4f9SMatthew Dillon mtx_unlock(&Giant); 748b6a4b4f9SMatthew Dillon return (error); 7493d903220SDoug Rabson } 7503d903220SDoug Rabson 75178525ce3SAlfred Perlstein static void 75278525ce3SAlfred Perlstein shmfork_myhook(p1, p2) 7533d903220SDoug Rabson struct proc *p1, *p2; 7543d903220SDoug Rabson { 7553d903220SDoug Rabson struct shmmap_state *shmmap_s; 7563d903220SDoug Rabson size_t size; 7573d903220SDoug Rabson int i; 7583d903220SDoug Rabson 7593d903220SDoug Rabson size = shminfo.shmseg * sizeof(struct shmmap_state); 7603d903220SDoug Rabson shmmap_s = malloc(size, M_SHM, M_WAITOK); 7612cc593fdSAlfred Perlstein bcopy(p1->p_vmspace->vm_shm, shmmap_s, size); 7622cc593fdSAlfred Perlstein p2->p_vmspace->vm_shm = shmmap_s; 7633d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) 7643d903220SDoug Rabson if (shmmap_s->shmid != -1) 7653d903220SDoug Rabson shmsegs[IPCID_TO_IX(shmmap_s->shmid)].shm_nattch++; 7663d903220SDoug Rabson } 7673d903220SDoug Rabson 76878525ce3SAlfred Perlstein static void 76978525ce3SAlfred Perlstein shmexit_myhook(p) 7703d903220SDoug Rabson struct proc *p; 7713d903220SDoug Rabson { 7723d903220SDoug Rabson struct shmmap_state *shmmap_s; 7733d903220SDoug Rabson int i; 7743d903220SDoug Rabson 7750cddd8f0SMatthew Dillon GIANT_REQUIRED; 7760cddd8f0SMatthew Dillon 7773d903220SDoug Rabson shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; 7783d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) 7793d903220SDoug Rabson if (shmmap_s->shmid != -1) 7803d903220SDoug Rabson shm_delete_mapping(p, shmmap_s); 7812cc593fdSAlfred Perlstein free(p->p_vmspace->vm_shm, M_SHM); 7823d903220SDoug Rabson p->p_vmspace->vm_shm = NULL; 7833d903220SDoug Rabson } 7843d903220SDoug Rabson 785255108f3SPeter Wemm static void 786255108f3SPeter Wemm shmrealloc(void) 787255108f3SPeter Wemm { 788255108f3SPeter Wemm int i; 789255108f3SPeter Wemm struct shmid_ds *newsegs; 790255108f3SPeter Wemm 791255108f3SPeter Wemm if (shmalloced >= shminfo.shmmni) 792255108f3SPeter Wemm return; 793255108f3SPeter Wemm 794255108f3SPeter Wemm newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK); 795255108f3SPeter Wemm if (newsegs == NULL) 796255108f3SPeter Wemm return; 797255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 798255108f3SPeter Wemm bcopy(&shmsegs[i], &newsegs[i], sizeof(newsegs[0])); 799255108f3SPeter Wemm for (; i < shminfo.shmmni; i++) { 800255108f3SPeter Wemm shmsegs[i].shm_perm.mode = SHMSEG_FREE; 801255108f3SPeter Wemm shmsegs[i].shm_perm.seq = 0; 802255108f3SPeter Wemm } 803255108f3SPeter Wemm free(shmsegs, M_SHM); 804255108f3SPeter Wemm shmsegs = newsegs; 805255108f3SPeter Wemm shmalloced = shminfo.shmmni; 806255108f3SPeter Wemm } 807255108f3SPeter Wemm 808255108f3SPeter Wemm static void 80978525ce3SAlfred Perlstein shminit() 8103d903220SDoug Rabson { 8113d903220SDoug Rabson int i; 812255108f3SPeter Wemm 813b3a4bc42SMichael Reifenberger TUNABLE_INT_FETCH("kern.ipc.shmmaxpgs", &shminfo.shmall); 814b3a4bc42SMichael Reifenberger shminfo.shmmax = shminfo.shmall * PAGE_SIZE; 815b3a4bc42SMichael Reifenberger TUNABLE_INT_FETCH("kern.ipc.shmmin", &shminfo.shmmin); 816b3a4bc42SMichael Reifenberger TUNABLE_INT_FETCH("kern.ipc.shmmni", &shminfo.shmmni); 817b3a4bc42SMichael Reifenberger TUNABLE_INT_FETCH("kern.ipc.shmseg", &shminfo.shmseg); 818b3a4bc42SMichael Reifenberger TUNABLE_INT_FETCH("kern.ipc.shm_use_phys", &shm_use_phys); 819b3a4bc42SMichael Reifenberger 820255108f3SPeter Wemm shmalloced = shminfo.shmmni; 821255108f3SPeter Wemm shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK); 822255108f3SPeter Wemm if (shmsegs == NULL) 823255108f3SPeter Wemm panic("cannot allocate initial memory for sysvshm"); 824255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) { 8253d903220SDoug Rabson shmsegs[i].shm_perm.mode = SHMSEG_FREE; 8263d903220SDoug Rabson shmsegs[i].shm_perm.seq = 0; 8273d903220SDoug Rabson } 8283d903220SDoug Rabson shm_last_free = 0; 8293d903220SDoug Rabson shm_nused = 0; 8303d903220SDoug Rabson shm_committed = 0; 83178525ce3SAlfred Perlstein shmexit_hook = &shmexit_myhook; 83278525ce3SAlfred Perlstein shmfork_hook = &shmfork_myhook; 8333d903220SDoug Rabson } 83478525ce3SAlfred Perlstein 83578525ce3SAlfred Perlstein static int 83678525ce3SAlfred Perlstein shmunload() 83778525ce3SAlfred Perlstein { 83878525ce3SAlfred Perlstein 83978525ce3SAlfred Perlstein if (shm_nused > 0) 84078525ce3SAlfred Perlstein return (EBUSY); 84178525ce3SAlfred Perlstein 84278525ce3SAlfred Perlstein free(shmsegs, M_SHM); 84378525ce3SAlfred Perlstein shmexit_hook = NULL; 84478525ce3SAlfred Perlstein shmfork_hook = NULL; 84578525ce3SAlfred Perlstein return (0); 84678525ce3SAlfred Perlstein } 84778525ce3SAlfred Perlstein 84878525ce3SAlfred Perlstein static int 849a723c4e1SDima Dorfman sysctl_shmsegs(SYSCTL_HANDLER_ARGS) 850a723c4e1SDima Dorfman { 851a723c4e1SDima Dorfman 852a723c4e1SDima Dorfman return (SYSCTL_OUT(req, shmsegs, shmalloced * sizeof(shmsegs[0]))); 853a723c4e1SDima Dorfman } 854a723c4e1SDima Dorfman 855a723c4e1SDima Dorfman static int 85678525ce3SAlfred Perlstein sysvshm_modload(struct module *module, int cmd, void *arg) 85778525ce3SAlfred Perlstein { 85878525ce3SAlfred Perlstein int error = 0; 85978525ce3SAlfred Perlstein 86078525ce3SAlfred Perlstein switch (cmd) { 86178525ce3SAlfred Perlstein case MOD_LOAD: 86278525ce3SAlfred Perlstein shminit(); 86378525ce3SAlfred Perlstein break; 86478525ce3SAlfred Perlstein case MOD_UNLOAD: 86578525ce3SAlfred Perlstein error = shmunload(); 86678525ce3SAlfred Perlstein break; 86778525ce3SAlfred Perlstein case MOD_SHUTDOWN: 86878525ce3SAlfred Perlstein break; 86978525ce3SAlfred Perlstein default: 87078525ce3SAlfred Perlstein error = EINVAL; 87178525ce3SAlfred Perlstein break; 87278525ce3SAlfred Perlstein } 87378525ce3SAlfred Perlstein return (error); 87478525ce3SAlfred Perlstein } 87578525ce3SAlfred Perlstein 876faa784b7SDag-Erling Smørgrav static moduledata_t sysvshm_mod = { 877faa784b7SDag-Erling Smørgrav "sysvshm", 87878525ce3SAlfred Perlstein &sysvshm_modload, 87978525ce3SAlfred Perlstein NULL 88078525ce3SAlfred Perlstein }; 88178525ce3SAlfred Perlstein 88221d56e9cSAlfred Perlstein SYSCALL_MODULE_HELPER(shmsys); 88321d56e9cSAlfred Perlstein SYSCALL_MODULE_HELPER(shmat); 88421d56e9cSAlfred Perlstein SYSCALL_MODULE_HELPER(shmctl); 88521d56e9cSAlfred Perlstein SYSCALL_MODULE_HELPER(shmdt); 88621d56e9cSAlfred Perlstein SYSCALL_MODULE_HELPER(shmget); 88778525ce3SAlfred Perlstein 888faa784b7SDag-Erling Smørgrav DECLARE_MODULE(sysvshm, sysvshm_mod, 88978525ce3SAlfred Perlstein SI_SUB_SYSV_SHM, SI_ORDER_FIRST); 890faa784b7SDag-Erling Smørgrav MODULE_VERSION(sysvshm, 1); 891