13d903220SDoug Rabson /* $NetBSD: sysv_shm.c,v 1.23 1994/07/04 23:25:12 glass Exp $ */ 29454b2d8SWarner Losh /*- 33d903220SDoug Rabson * Copyright (c) 1994 Adam Glass and Charles Hannum. All rights reserved. 43d903220SDoug Rabson * 53d903220SDoug Rabson * Redistribution and use in source and binary forms, with or without 63d903220SDoug Rabson * modification, are permitted provided that the following conditions 73d903220SDoug Rabson * are met: 83d903220SDoug Rabson * 1. Redistributions of source code must retain the above copyright 93d903220SDoug Rabson * notice, this list of conditions and the following disclaimer. 103d903220SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 113d903220SDoug Rabson * notice, this list of conditions and the following disclaimer in the 123d903220SDoug Rabson * documentation and/or other materials provided with the distribution. 133d903220SDoug Rabson * 3. All advertising materials mentioning features or use of this software 143d903220SDoug Rabson * must display the following acknowledgement: 153d903220SDoug Rabson * This product includes software developed by Adam Glass and Charles 163d903220SDoug Rabson * Hannum. 173d903220SDoug Rabson * 4. The names of the authors may not be used to endorse or promote products 183d903220SDoug Rabson * derived from this software without specific prior written permission. 193d903220SDoug Rabson * 203d903220SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 213d903220SDoug Rabson * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 223d903220SDoug Rabson * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 233d903220SDoug Rabson * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 243d903220SDoug Rabson * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 253d903220SDoug Rabson * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 263d903220SDoug Rabson * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 273d903220SDoug Rabson * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 283d903220SDoug Rabson * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 293d903220SDoug Rabson * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 303d903220SDoug Rabson */ 3114cedfc8SRobert Watson /*- 3214cedfc8SRobert Watson * Copyright (c) 2003-2005 McAfee, Inc. 3314cedfc8SRobert Watson * All rights reserved. 3414cedfc8SRobert Watson * 3514cedfc8SRobert Watson * This software was developed for the FreeBSD Project in part by McAfee 3614cedfc8SRobert Watson * Research, the Security Research Division of McAfee, Inc under DARPA/SPAWAR 3714cedfc8SRobert Watson * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS research 3814cedfc8SRobert Watson * program. 3914cedfc8SRobert Watson * 4014cedfc8SRobert Watson * Redistribution and use in source and binary forms, with or without 4114cedfc8SRobert Watson * modification, are permitted provided that the following conditions 4214cedfc8SRobert Watson * are met: 4314cedfc8SRobert Watson * 1. Redistributions of source code must retain the above copyright 4414cedfc8SRobert Watson * notice, this list of conditions and the following disclaimer. 4514cedfc8SRobert Watson * 2. Redistributions in binary form must reproduce the above copyright 4614cedfc8SRobert Watson * notice, this list of conditions and the following disclaimer in the 4714cedfc8SRobert Watson * documentation and/or other materials provided with the distribution. 4814cedfc8SRobert Watson * 4914cedfc8SRobert Watson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 5014cedfc8SRobert Watson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 5114cedfc8SRobert Watson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 5214cedfc8SRobert Watson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 5314cedfc8SRobert Watson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 5414cedfc8SRobert Watson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 5514cedfc8SRobert Watson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 5614cedfc8SRobert Watson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 5714cedfc8SRobert Watson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5814cedfc8SRobert Watson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5914cedfc8SRobert Watson * SUCH DAMAGE. 6014cedfc8SRobert Watson */ 613d903220SDoug Rabson 62677b542eSDavid E. O'Brien #include <sys/cdefs.h> 63677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 64677b542eSDavid E. O'Brien 655591b823SEivind Eklund #include "opt_compat.h" 66255108f3SPeter Wemm #include "opt_sysvipc.h" 67511b67b7SGarrett Wollman 683d903220SDoug Rabson #include <sys/param.h> 69725db531SBruce Evans #include <sys/systm.h> 703d903220SDoug Rabson #include <sys/kernel.h> 71b648d480SJohn Baldwin #include <sys/limits.h> 72fb919e4dSMark Murray #include <sys/lock.h> 73255108f3SPeter Wemm #include <sys/sysctl.h> 743d903220SDoug Rabson #include <sys/shm.h> 753d903220SDoug Rabson #include <sys/proc.h> 763d903220SDoug Rabson #include <sys/malloc.h> 773d903220SDoug Rabson #include <sys/mman.h> 7877409fe1SPoul-Henning Kamp #include <sys/module.h> 799dceb26bSJohn Baldwin #include <sys/mutex.h> 803bcf7445SEdward Tomasz Napierala #include <sys/racct.h> 8168ba7a1dSTim J. Robbins #include <sys/resourcevar.h> 8289f6b863SAttilio Rao #include <sys/rwlock.h> 833d903220SDoug Rabson #include <sys/stat.h> 8478525ce3SAlfred Perlstein #include <sys/syscall.h> 85f130dcf2SMartin Blapp #include <sys/syscallsubr.h> 86725db531SBruce Evans #include <sys/sysent.h> 87fb919e4dSMark Murray #include <sys/sysproto.h> 88cb1f0db9SRobert Watson #include <sys/jail.h> 89aed55708SRobert Watson 90aed55708SRobert Watson #include <security/mac/mac_framework.h> 913d903220SDoug Rabson 923d903220SDoug Rabson #include <vm/vm.h> 93efeaf95aSDavid Greenman #include <vm/vm_param.h> 94efeaf95aSDavid Greenman #include <vm/pmap.h> 95a51f7119SJohn Dyson #include <vm/vm_object.h> 963d903220SDoug Rabson #include <vm/vm_map.h> 971c7c3c6aSMatthew Dillon #include <vm/vm_page.h> 98ae9b8c3aSJohn Dyson #include <vm/vm_pager.h> 993d903220SDoug Rabson 100de5b1952SAlexander Leidinger FEATURE(sysv_shm, "System V shared memory segments support"); 101de5b1952SAlexander Leidinger 102a1c995b6SPoul-Henning Kamp static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments"); 10355166637SPoul-Henning Kamp 1044d77a549SAlfred Perlstein static int shmget_allocate_segment(struct thread *td, 1054d77a549SAlfred Perlstein struct shmget_args *uap, int mode); 1064d77a549SAlfred Perlstein static int shmget_existing(struct thread *td, struct shmget_args *uap, 1074d77a549SAlfred Perlstein int mode, int segnum); 108725db531SBruce Evans 1093d903220SDoug Rabson #define SHMSEG_FREE 0x0200 1103d903220SDoug Rabson #define SHMSEG_REMOVED 0x0400 1113d903220SDoug Rabson #define SHMSEG_ALLOCATED 0x0800 1123d903220SDoug Rabson 11365067cc8SKonstantin Belousov static int shm_last_free, shm_nused, shmalloced; 11445329b60SKonstantin Belousov vm_size_t shm_committed; 115921d05b9SRobert Watson static struct shmid_kernel *shmsegs; 1163d903220SDoug Rabson 1173d903220SDoug Rabson struct shmmap_state { 1183d903220SDoug Rabson vm_offset_t va; 1193d903220SDoug Rabson int shmid; 1203d903220SDoug Rabson }; 1213d903220SDoug Rabson 122921d05b9SRobert Watson static void shm_deallocate_segment(struct shmid_kernel *); 1234d77a549SAlfred Perlstein static int shm_find_segment_by_key(key_t); 1240555fb35SKonstantin Belousov static struct shmid_kernel *shm_find_segment(int, bool); 1253db161e0SMatthew Dillon static int shm_delete_mapping(struct vmspace *vm, struct shmmap_state *); 1264d77a549SAlfred Perlstein static void shmrealloc(void); 12775d633cbSKonstantin Belousov static int shminit(void); 1284d77a549SAlfred Perlstein static int sysvshm_modload(struct module *, int, void *); 1294d77a549SAlfred Perlstein static int shmunload(void); 1303db161e0SMatthew Dillon static void shmexit_myhook(struct vmspace *vm); 1314d77a549SAlfred Perlstein static void shmfork_myhook(struct proc *p1, struct proc *p2); 1324d77a549SAlfred Perlstein static int sysctl_shmsegs(SYSCTL_HANDLER_ARGS); 133255108f3SPeter Wemm 134255108f3SPeter Wemm /* 135028f979dSDima Dorfman * Tuneable values. 136255108f3SPeter Wemm */ 137255108f3SPeter Wemm #ifndef SHMMAXPGS 138c1e34abfSIvan Voras #define SHMMAXPGS 131072 /* Note: sysv shared memory is swap backed. */ 139255108f3SPeter Wemm #endif 140255108f3SPeter Wemm #ifndef SHMMAX 141255108f3SPeter Wemm #define SHMMAX (SHMMAXPGS*PAGE_SIZE) 142255108f3SPeter Wemm #endif 143255108f3SPeter Wemm #ifndef SHMMIN 144255108f3SPeter Wemm #define SHMMIN 1 145255108f3SPeter Wemm #endif 146255108f3SPeter Wemm #ifndef SHMMNI 1471766b2e5SMatthew Dillon #define SHMMNI 192 148255108f3SPeter Wemm #endif 149255108f3SPeter Wemm #ifndef SHMSEG 1501766b2e5SMatthew Dillon #define SHMSEG 128 151255108f3SPeter Wemm #endif 152255108f3SPeter Wemm #ifndef SHMALL 153255108f3SPeter Wemm #define SHMALL (SHMMAXPGS) 154255108f3SPeter Wemm #endif 155255108f3SPeter Wemm 156255108f3SPeter Wemm struct shminfo shminfo = { 157af3b2549SHans Petter Selasky .shmmax = SHMMAX, 158af3b2549SHans Petter Selasky .shmmin = SHMMIN, 159af3b2549SHans Petter Selasky .shmmni = SHMMNI, 160af3b2549SHans Petter Selasky .shmseg = SHMSEG, 161af3b2549SHans Petter Selasky .shmall = SHMALL 162255108f3SPeter Wemm }; 163255108f3SPeter Wemm 1648b03c8edSMatthew Dillon static int shm_use_phys; 16592001b94SEdward Tomasz Napierala static int shm_allow_removed = 1; 1668b03c8edSMatthew Dillon 167af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RWTUN, &shminfo.shmmax, 0, 16884f85aedSChristian S.J. Peron "Maximum shared memory segment size"); 169af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RWTUN, &shminfo.shmmin, 0, 17084f85aedSChristian S.J. Peron "Minimum shared memory segment size"); 1719baea4b4SChristian S.J. Peron SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RDTUN, &shminfo.shmmni, 0, 17284f85aedSChristian S.J. Peron "Number of shared memory identifiers"); 1739baea4b4SChristian S.J. Peron SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RDTUN, &shminfo.shmseg, 0, 17484f85aedSChristian S.J. Peron "Number of segments per process"); 175af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RWTUN, &shminfo.shmall, 0, 17684f85aedSChristian S.J. Peron "Maximum number of pages available for shared memory"); 177af3b2549SHans Petter Selasky SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RWTUN, 17884f85aedSChristian S.J. Peron &shm_use_phys, 0, "Enable/Disable locking of shared memory pages in core"); 179af3b2549SHans Petter Selasky SYSCTL_INT(_kern_ipc, OID_AUTO, shm_allow_removed, CTLFLAG_RWTUN, 18084f85aedSChristian S.J. Peron &shm_allow_removed, 0, 18184f85aedSChristian S.J. Peron "Enable/Disable attachment to attached segments marked for removal"); 1820555fb35SKonstantin Belousov SYSCTL_PROC(_kern_ipc, OID_AUTO, shmsegs, CTLTYPE_OPAQUE | CTLFLAG_RD | 1830555fb35SKonstantin Belousov CTLFLAG_MPSAFE, NULL, 0, sysctl_shmsegs, "", 18484f85aedSChristian S.J. Peron "Current number of shared memory segments allocated"); 1853d903220SDoug Rabson 1860555fb35SKonstantin Belousov static struct sx sysvshmsx; 1870555fb35SKonstantin Belousov #define SYSVSHM_LOCK() sx_xlock(&sysvshmsx) 1880555fb35SKonstantin Belousov #define SYSVSHM_UNLOCK() sx_xunlock(&sysvshmsx) 1890555fb35SKonstantin Belousov #define SYSVSHM_ASSERT_LOCKED() sx_assert(&sysvshmsx, SA_XLOCKED) 1900555fb35SKonstantin Belousov 1913d903220SDoug Rabson static int 1920555fb35SKonstantin Belousov shm_find_segment_by_key(key_t key) 1933d903220SDoug Rabson { 1943d903220SDoug Rabson int i; 1953d903220SDoug Rabson 196255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 197921d05b9SRobert Watson if ((shmsegs[i].u.shm_perm.mode & SHMSEG_ALLOCATED) && 198921d05b9SRobert Watson shmsegs[i].u.shm_perm.key == key) 199b618bb96SAlfred Perlstein return (i); 200b618bb96SAlfred Perlstein return (-1); 2013d903220SDoug Rabson } 2023d903220SDoug Rabson 2030555fb35SKonstantin Belousov /* 2040555fb35SKonstantin Belousov * Finds segment either by shmid if is_shmid is true, or by segnum if 2050555fb35SKonstantin Belousov * is_shmid is false. 2060555fb35SKonstantin Belousov */ 207921d05b9SRobert Watson static struct shmid_kernel * 2080555fb35SKonstantin Belousov shm_find_segment(int arg, bool is_shmid) 2093d903220SDoug Rabson { 210921d05b9SRobert Watson struct shmid_kernel *shmseg; 2110555fb35SKonstantin Belousov int segnum; 2123d903220SDoug Rabson 2130555fb35SKonstantin Belousov segnum = is_shmid ? IPCID_TO_IX(arg) : arg; 214255108f3SPeter Wemm if (segnum < 0 || segnum >= shmalloced) 215b618bb96SAlfred Perlstein return (NULL); 2163d903220SDoug Rabson shmseg = &shmsegs[segnum]; 217921d05b9SRobert Watson if ((shmseg->u.shm_perm.mode & SHMSEG_ALLOCATED) == 0 || 2182332251cSMax Khon (!shm_allow_removed && 219921d05b9SRobert Watson (shmseg->u.shm_perm.mode & SHMSEG_REMOVED) != 0) || 2200555fb35SKonstantin Belousov (is_shmid && shmseg->u.shm_perm.seq != IPCID_TO_SEQ(arg))) 221b618bb96SAlfred Perlstein return (NULL); 222b618bb96SAlfred Perlstein return (shmseg); 223491dec93SMichael Reifenberger } 224491dec93SMichael Reifenberger 2253d903220SDoug Rabson static void 2260555fb35SKonstantin Belousov shm_deallocate_segment(struct shmid_kernel *shmseg) 2273d903220SDoug Rabson { 22845329b60SKonstantin Belousov vm_size_t size; 2293d903220SDoug Rabson 2300555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 2310cddd8f0SMatthew Dillon 232b648d480SJohn Baldwin vm_object_deallocate(shmseg->object); 233b648d480SJohn Baldwin shmseg->object = NULL; 234b648d480SJohn Baldwin size = round_page(shmseg->u.shm_segsz); 2353d903220SDoug Rabson shm_committed -= btoc(size); 2363d903220SDoug Rabson shm_nused--; 237921d05b9SRobert Watson shmseg->u.shm_perm.mode = SHMSEG_FREE; 23814cedfc8SRobert Watson #ifdef MAC 23930d239bcSRobert Watson mac_sysvshm_cleanup(shmseg); 24014cedfc8SRobert Watson #endif 2413bcf7445SEdward Tomasz Napierala racct_sub_cred(shmseg->cred, RACCT_NSHM, 1); 2423bcf7445SEdward Tomasz Napierala racct_sub_cred(shmseg->cred, RACCT_SHMSIZE, size); 2438caddd81SEdward Tomasz Napierala crfree(shmseg->cred); 2448caddd81SEdward Tomasz Napierala shmseg->cred = NULL; 2453d903220SDoug Rabson } 2463d903220SDoug Rabson 2473d903220SDoug Rabson static int 2483db161e0SMatthew Dillon shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s) 2493d903220SDoug Rabson { 250921d05b9SRobert Watson struct shmid_kernel *shmseg; 2513d903220SDoug Rabson int segnum, result; 25245329b60SKonstantin Belousov vm_size_t size; 2533d903220SDoug Rabson 2540555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 2553d903220SDoug Rabson segnum = IPCID_TO_IX(shmmap_s->shmid); 2560555fb35SKonstantin Belousov KASSERT(segnum >= 0 && segnum < shmalloced, 2570555fb35SKonstantin Belousov ("segnum %d shmalloced %d", segnum, shmalloced)); 2580555fb35SKonstantin Belousov 2593d903220SDoug Rabson shmseg = &shmsegs[segnum]; 260b648d480SJohn Baldwin size = round_page(shmseg->u.shm_segsz); 2613db161e0SMatthew Dillon result = vm_map_remove(&vm->vm_map, shmmap_s->va, shmmap_s->va + size); 2623d903220SDoug Rabson if (result != KERN_SUCCESS) 263b618bb96SAlfred Perlstein return (EINVAL); 2643d903220SDoug Rabson shmmap_s->shmid = -1; 265921d05b9SRobert Watson shmseg->u.shm_dtime = time_second; 266921d05b9SRobert Watson if ((--shmseg->u.shm_nattch <= 0) && 267921d05b9SRobert Watson (shmseg->u.shm_perm.mode & SHMSEG_REMOVED)) { 2683d903220SDoug Rabson shm_deallocate_segment(shmseg); 2693d903220SDoug Rabson shm_last_free = segnum; 2703d903220SDoug Rabson } 271b618bb96SAlfred Perlstein return (0); 2723d903220SDoug Rabson } 2733d903220SDoug Rabson 2740555fb35SKonstantin Belousov static int 2750555fb35SKonstantin Belousov kern_shmdt_locked(struct thread *td, const void *shmaddr) 2763d903220SDoug Rabson { 277b40ce416SJulian Elischer struct proc *p = td->td_proc; 2783d903220SDoug Rabson struct shmmap_state *shmmap_s; 27914cedfc8SRobert Watson #ifdef MAC 28014cedfc8SRobert Watson struct shmid_kernel *shmsegptr; 281e2f5418eSMateusz Guzik int error; 28214cedfc8SRobert Watson #endif 283e2f5418eSMateusz Guzik int i; 2843d903220SDoug Rabson 2850555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 2860304c731SJamie Gritton if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 287c6f55f33SJohn Baldwin return (ENOSYS); 2888209f090SAlfred Perlstein shmmap_s = p->p_vmspace->vm_shm; 2890555fb35SKonstantin Belousov if (shmmap_s == NULL) 2900555fb35SKonstantin Belousov return (EINVAL); 291b6a4b4f9SMatthew Dillon for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) { 2923d903220SDoug Rabson if (shmmap_s->shmid != -1 && 2930555fb35SKonstantin Belousov shmmap_s->va == (vm_offset_t)shmaddr) { 2943d903220SDoug Rabson break; 295b6a4b4f9SMatthew Dillon } 296b6a4b4f9SMatthew Dillon } 2970555fb35SKonstantin Belousov if (i == shminfo.shmseg) 2980555fb35SKonstantin Belousov return (EINVAL); 29914cedfc8SRobert Watson #ifdef MAC 30014cedfc8SRobert Watson shmsegptr = &shmsegs[IPCID_TO_IX(shmmap_s->shmid)]; 30130d239bcSRobert Watson error = mac_sysvshm_check_shmdt(td->td_ucred, shmsegptr); 302f50c4fd8SRobert Watson if (error != 0) 3030555fb35SKonstantin Belousov return (error); 30414cedfc8SRobert Watson #endif 305e2f5418eSMateusz Guzik return (shm_delete_mapping(p->p_vmspace, shmmap_s)); 3063d903220SDoug Rabson } 3073d903220SDoug Rabson 308b5d5c0c9SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 3090555fb35SKonstantin Belousov struct shmdt_args { 310e1d7d0bbSAlfred Perlstein const void *shmaddr; 3113d903220SDoug Rabson }; 312b5d5c0c9SPeter Wemm #endif 3133d903220SDoug Rabson int 3140555fb35SKonstantin Belousov sys_shmdt(struct thread *td, struct shmdt_args *uap) 3150555fb35SKonstantin Belousov { 3160555fb35SKonstantin Belousov int error; 3170555fb35SKonstantin Belousov 3180555fb35SKonstantin Belousov SYSVSHM_LOCK(); 3190555fb35SKonstantin Belousov error = kern_shmdt_locked(td, uap->shmaddr); 3200555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 3210555fb35SKonstantin Belousov return (error); 3220555fb35SKonstantin Belousov } 3230555fb35SKonstantin Belousov 3240555fb35SKonstantin Belousov static int 3250555fb35SKonstantin Belousov kern_shmat_locked(struct thread *td, int shmid, const void *shmaddr, 3260555fb35SKonstantin Belousov int shmflg) 3273d903220SDoug Rabson { 328b40ce416SJulian Elischer struct proc *p = td->td_proc; 329921d05b9SRobert Watson struct shmid_kernel *shmseg; 3300122d251SKonstantin Belousov struct shmmap_state *shmmap_s; 3313d903220SDoug Rabson vm_offset_t attach_va; 3323d903220SDoug Rabson vm_prot_t prot; 3333d903220SDoug Rabson vm_size_t size; 3340555fb35SKonstantin Belousov int error, i, rv; 3353d903220SDoug Rabson 3360555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 3370304c731SJamie Gritton if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 338c6f55f33SJohn Baldwin return (ENOSYS); 3398209f090SAlfred Perlstein shmmap_s = p->p_vmspace->vm_shm; 3403d903220SDoug Rabson if (shmmap_s == NULL) { 34145329b60SKonstantin Belousov shmmap_s = malloc(shminfo.shmseg * sizeof(struct shmmap_state), 34245329b60SKonstantin Belousov M_SHM, M_WAITOK); 3433d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++) 3443d903220SDoug Rabson shmmap_s[i].shmid = -1; 3450555fb35SKonstantin Belousov KASSERT(p->p_vmspace->vm_shm == NULL, ("raced")); 3462cc593fdSAlfred Perlstein p->p_vmspace->vm_shm = shmmap_s; 3473d903220SDoug Rabson } 3480555fb35SKonstantin Belousov shmseg = shm_find_segment(shmid, true); 3490555fb35SKonstantin Belousov if (shmseg == NULL) 3500555fb35SKonstantin Belousov return (EINVAL); 351921d05b9SRobert Watson error = ipcperm(td, &shmseg->u.shm_perm, 352f130dcf2SMartin Blapp (shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W); 3530555fb35SKonstantin Belousov if (error != 0) 3540555fb35SKonstantin Belousov return (error); 35514cedfc8SRobert Watson #ifdef MAC 35630d239bcSRobert Watson error = mac_sysvshm_check_shmat(td->td_ucred, shmseg, shmflg); 357f50c4fd8SRobert Watson if (error != 0) 3580555fb35SKonstantin Belousov return (error); 35914cedfc8SRobert Watson #endif 3603d903220SDoug Rabson for (i = 0; i < shminfo.shmseg; i++) { 3613d903220SDoug Rabson if (shmmap_s->shmid == -1) 3623d903220SDoug Rabson break; 3633d903220SDoug Rabson shmmap_s++; 3643d903220SDoug Rabson } 3650555fb35SKonstantin Belousov if (i >= shminfo.shmseg) 3660555fb35SKonstantin Belousov return (EMFILE); 367b648d480SJohn Baldwin size = round_page(shmseg->u.shm_segsz); 3683d903220SDoug Rabson prot = VM_PROT_READ; 369f130dcf2SMartin Blapp if ((shmflg & SHM_RDONLY) == 0) 3703d903220SDoug Rabson prot |= VM_PROT_WRITE; 3710555fb35SKonstantin Belousov if (shmaddr != NULL) { 3720555fb35SKonstantin Belousov if ((shmflg & SHM_RND) != 0) 373*d9c9c81cSPedro F. Giffuni attach_va = rounddown2((vm_offset_t)shmaddr, SHMLBA); 3740555fb35SKonstantin Belousov else if (((vm_offset_t)shmaddr & (SHMLBA-1)) == 0) 375f130dcf2SMartin Blapp attach_va = (vm_offset_t)shmaddr; 3760555fb35SKonstantin Belousov else 3770555fb35SKonstantin Belousov return (EINVAL); 3783d903220SDoug Rabson } else { 379028f979dSDima Dorfman /* 380028f979dSDima Dorfman * This is just a hint to vm_map_find() about where to 381028f979dSDima Dorfman * put it. 382028f979dSDima Dorfman */ 38368ba7a1dSTim J. Robbins attach_va = round_page((vm_offset_t)p->p_vmspace->vm_daddr + 38477a26248SMateusz Guzik lim_max(td, RLIMIT_DATA)); 3853d903220SDoug Rabson } 386a51f7119SJohn Dyson 387b648d480SJohn Baldwin vm_object_reference(shmseg->object); 38801a8fb7dSAlan Cox rv = vm_map_find(&p->p_vmspace->vm_map, shmseg->object, 0, &attach_va, 38901a8fb7dSAlan Cox size, 0, shmaddr != NULL ? VMFS_NO_SPACE : VMFS_OPTIMAL_SPACE, 39001a8fb7dSAlan Cox prot, prot, MAP_INHERIT_SHARE | MAP_PREFAULT_PARTIAL); 391a51f7119SJohn Dyson if (rv != KERN_SUCCESS) { 392b648d480SJohn Baldwin vm_object_deallocate(shmseg->object); 3930555fb35SKonstantin Belousov return (ENOMEM); 394a51f7119SJohn Dyson } 3950463028cSJohn Dyson 3963d903220SDoug Rabson shmmap_s->va = attach_va; 397f130dcf2SMartin Blapp shmmap_s->shmid = shmid; 398921d05b9SRobert Watson shmseg->u.shm_lpid = p->p_pid; 399921d05b9SRobert Watson shmseg->u.shm_atime = time_second; 400921d05b9SRobert Watson shmseg->u.shm_nattch++; 401b40ce416SJulian Elischer td->td_retval[0] = attach_va; 402b6a4b4f9SMatthew Dillon return (error); 4033d903220SDoug Rabson } 4043d903220SDoug Rabson 405f130dcf2SMartin Blapp int 4060555fb35SKonstantin Belousov kern_shmat(struct thread *td, int shmid, const void *shmaddr, int shmflg) 407f130dcf2SMartin Blapp { 4080555fb35SKonstantin Belousov int error; 4090555fb35SKonstantin Belousov 4100555fb35SKonstantin Belousov SYSVSHM_LOCK(); 4110555fb35SKonstantin Belousov error = kern_shmat_locked(td, shmid, shmaddr, shmflg); 4120555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 4130555fb35SKonstantin Belousov return (error); 414f130dcf2SMartin Blapp } 415f130dcf2SMartin Blapp 4160555fb35SKonstantin Belousov #ifndef _SYS_SYSPROTO_H_ 4170555fb35SKonstantin Belousov struct shmat_args { 418f130dcf2SMartin Blapp int shmid; 4190555fb35SKonstantin Belousov const void *shmaddr; 4200555fb35SKonstantin Belousov int shmflg; 4210555fb35SKonstantin Belousov }; 4220555fb35SKonstantin Belousov #endif 4230555fb35SKonstantin Belousov int 4240555fb35SKonstantin Belousov sys_shmat(struct thread *td, struct shmat_args *uap) 4253d903220SDoug Rabson { 4260555fb35SKonstantin Belousov 4270555fb35SKonstantin Belousov return (kern_shmat(td, uap->shmid, uap->shmaddr, uap->shmflg)); 4280555fb35SKonstantin Belousov } 4290555fb35SKonstantin Belousov 4300555fb35SKonstantin Belousov static int 4310555fb35SKonstantin Belousov kern_shmctl_locked(struct thread *td, int shmid, int cmd, void *buf, 4320555fb35SKonstantin Belousov size_t *bufsz) 4330555fb35SKonstantin Belousov { 434921d05b9SRobert Watson struct shmid_kernel *shmseg; 4350555fb35SKonstantin Belousov struct shmid_ds *shmidp; 4360555fb35SKonstantin Belousov struct shm_info shm_info; 4370555fb35SKonstantin Belousov int error; 4380555fb35SKonstantin Belousov 4390555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 4403d903220SDoug Rabson 4410304c731SJamie Gritton if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 442c6f55f33SJohn Baldwin return (ENOSYS); 443f130dcf2SMartin Blapp 444f130dcf2SMartin Blapp switch (cmd) { 4454f18813fSChristian S.J. Peron /* 4464f18813fSChristian S.J. Peron * It is possible that kern_shmctl is being called from the Linux ABI 4474f18813fSChristian S.J. Peron * layer, in which case, we will need to implement IPC_INFO. It should 4484f18813fSChristian S.J. Peron * be noted that other shmctl calls will be funneled through here for 4494f18813fSChristian S.J. Peron * Linix binaries as well. 4504f18813fSChristian S.J. Peron * 4514f18813fSChristian S.J. Peron * NB: The Linux ABI layer will convert this data to structure(s) more 4524f18813fSChristian S.J. Peron * consistent with the Linux ABI. 4534f18813fSChristian S.J. Peron */ 454491dec93SMichael Reifenberger case IPC_INFO: 455f130dcf2SMartin Blapp memcpy(buf, &shminfo, sizeof(shminfo)); 456f130dcf2SMartin Blapp if (bufsz) 457f130dcf2SMartin Blapp *bufsz = sizeof(shminfo); 458491dec93SMichael Reifenberger td->td_retval[0] = shmalloced; 4590555fb35SKonstantin Belousov return (0); 460491dec93SMichael Reifenberger case SHM_INFO: { 461491dec93SMichael Reifenberger shm_info.used_ids = shm_nused; 462491dec93SMichael Reifenberger shm_info.shm_rss = 0; /*XXX where to get from ? */ 463491dec93SMichael Reifenberger shm_info.shm_tot = 0; /*XXX where to get from ? */ 464491dec93SMichael Reifenberger shm_info.shm_swp = 0; /*XXX where to get from ? */ 465491dec93SMichael Reifenberger shm_info.swap_attempts = 0; /*XXX where to get from ? */ 466491dec93SMichael Reifenberger shm_info.swap_successes = 0; /*XXX where to get from ? */ 467f130dcf2SMartin Blapp memcpy(buf, &shm_info, sizeof(shm_info)); 4680555fb35SKonstantin Belousov if (bufsz != NULL) 469f130dcf2SMartin Blapp *bufsz = sizeof(shm_info); 470491dec93SMichael Reifenberger td->td_retval[0] = shmalloced; 4710555fb35SKonstantin Belousov return (0); 472491dec93SMichael Reifenberger } 473491dec93SMichael Reifenberger } 4740555fb35SKonstantin Belousov shmseg = shm_find_segment(shmid, cmd != SHM_STAT); 4750555fb35SKonstantin Belousov if (shmseg == NULL) 4760555fb35SKonstantin Belousov return (EINVAL); 47714cedfc8SRobert Watson #ifdef MAC 47830d239bcSRobert Watson error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, cmd); 479f50c4fd8SRobert Watson if (error != 0) 4800555fb35SKonstantin Belousov return (error); 48114cedfc8SRobert Watson #endif 482f130dcf2SMartin Blapp switch (cmd) { 483491dec93SMichael Reifenberger case SHM_STAT: 4843d903220SDoug Rabson case IPC_STAT: 485921d05b9SRobert Watson error = ipcperm(td, &shmseg->u.shm_perm, IPC_R); 4860555fb35SKonstantin Belousov if (error != 0) 4870555fb35SKonstantin Belousov return (error); 488921d05b9SRobert Watson memcpy(buf, &shmseg->u, sizeof(struct shmid_ds)); 4890555fb35SKonstantin Belousov if (bufsz != NULL) 490f130dcf2SMartin Blapp *bufsz = sizeof(struct shmid_ds); 4910555fb35SKonstantin Belousov if (cmd == SHM_STAT) { 4920555fb35SKonstantin Belousov td->td_retval[0] = IXSEQ_TO_IPCID(shmid, 4930555fb35SKonstantin Belousov shmseg->u.shm_perm); 4940555fb35SKonstantin Belousov } 4953d903220SDoug Rabson break; 4960555fb35SKonstantin Belousov case IPC_SET: 4970555fb35SKonstantin Belousov shmidp = (struct shmid_ds *)buf; 498921d05b9SRobert Watson error = ipcperm(td, &shmseg->u.shm_perm, IPC_M); 4990555fb35SKonstantin Belousov if (error != 0) 5000555fb35SKonstantin Belousov return (error); 5010555fb35SKonstantin Belousov shmseg->u.shm_perm.uid = shmidp->shm_perm.uid; 5020555fb35SKonstantin Belousov shmseg->u.shm_perm.gid = shmidp->shm_perm.gid; 503921d05b9SRobert Watson shmseg->u.shm_perm.mode = 504921d05b9SRobert Watson (shmseg->u.shm_perm.mode & ~ACCESSPERMS) | 5050555fb35SKonstantin Belousov (shmidp->shm_perm.mode & ACCESSPERMS); 506921d05b9SRobert Watson shmseg->u.shm_ctime = time_second; 5073d903220SDoug Rabson break; 5083d903220SDoug Rabson case IPC_RMID: 509921d05b9SRobert Watson error = ipcperm(td, &shmseg->u.shm_perm, IPC_M); 5100555fb35SKonstantin Belousov if (error != 0) 5110555fb35SKonstantin Belousov return (error); 512921d05b9SRobert Watson shmseg->u.shm_perm.key = IPC_PRIVATE; 513921d05b9SRobert Watson shmseg->u.shm_perm.mode |= SHMSEG_REMOVED; 514921d05b9SRobert Watson if (shmseg->u.shm_nattch <= 0) { 5153d903220SDoug Rabson shm_deallocate_segment(shmseg); 516f130dcf2SMartin Blapp shm_last_free = IPCID_TO_IX(shmid); 5173d903220SDoug Rabson } 5183d903220SDoug Rabson break; 5193d903220SDoug Rabson #if 0 5203d903220SDoug Rabson case SHM_LOCK: 5213d903220SDoug Rabson case SHM_UNLOCK: 5223d903220SDoug Rabson #endif 5233d903220SDoug Rabson default: 524b6a4b4f9SMatthew Dillon error = EINVAL; 525b6a4b4f9SMatthew Dillon break; 5263d903220SDoug Rabson } 527b6a4b4f9SMatthew Dillon return (error); 5283d903220SDoug Rabson } 5293d903220SDoug Rabson 5300555fb35SKonstantin Belousov int 5310555fb35SKonstantin Belousov kern_shmctl(struct thread *td, int shmid, int cmd, void *buf, size_t *bufsz) 5320555fb35SKonstantin Belousov { 5330555fb35SKonstantin Belousov int error; 5340555fb35SKonstantin Belousov 5350555fb35SKonstantin Belousov SYSVSHM_LOCK(); 5360555fb35SKonstantin Belousov error = kern_shmctl_locked(td, shmid, cmd, buf, bufsz); 5370555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 5380555fb35SKonstantin Belousov return (error); 5390555fb35SKonstantin Belousov } 5400555fb35SKonstantin Belousov 5410555fb35SKonstantin Belousov 54271361470SJohn Baldwin #ifndef _SYS_SYSPROTO_H_ 54371361470SJohn Baldwin struct shmctl_args { 54471361470SJohn Baldwin int shmid; 54571361470SJohn Baldwin int cmd; 54671361470SJohn Baldwin struct shmid_ds *buf; 54771361470SJohn Baldwin }; 54871361470SJohn Baldwin #endif 549f130dcf2SMartin Blapp int 5500555fb35SKonstantin Belousov sys_shmctl(struct thread *td, struct shmctl_args *uap) 551f130dcf2SMartin Blapp { 552e2f5418eSMateusz Guzik int error; 553f130dcf2SMartin Blapp struct shmid_ds buf; 554f130dcf2SMartin Blapp size_t bufsz; 555f130dcf2SMartin Blapp 5564f18813fSChristian S.J. Peron /* 5574f18813fSChristian S.J. Peron * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support 5584f18813fSChristian S.J. Peron * Linux binaries. If we see the call come through the FreeBSD ABI, 5594f18813fSChristian S.J. Peron * return an error back to the user since we do not to support this. 5604f18813fSChristian S.J. Peron */ 5614f18813fSChristian S.J. Peron if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO || 5624f18813fSChristian S.J. Peron uap->cmd == SHM_STAT) 5634f18813fSChristian S.J. Peron return (EINVAL); 5644f18813fSChristian S.J. Peron 565f130dcf2SMartin Blapp /* IPC_SET needs to copyin the buffer before calling kern_shmctl */ 566f130dcf2SMartin Blapp if (uap->cmd == IPC_SET) { 567f130dcf2SMartin Blapp if ((error = copyin(uap->buf, &buf, sizeof(struct shmid_ds)))) 568f130dcf2SMartin Blapp goto done; 569f130dcf2SMartin Blapp } 570f130dcf2SMartin Blapp 5712332251cSMax Khon error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz); 572f130dcf2SMartin Blapp if (error) 573f130dcf2SMartin Blapp goto done; 574f130dcf2SMartin Blapp 575f130dcf2SMartin Blapp /* Cases in which we need to copyout */ 576f130dcf2SMartin Blapp switch (uap->cmd) { 577f130dcf2SMartin Blapp case IPC_STAT: 578f130dcf2SMartin Blapp error = copyout(&buf, uap->buf, bufsz); 579f130dcf2SMartin Blapp break; 580f130dcf2SMartin Blapp } 581f130dcf2SMartin Blapp 582f130dcf2SMartin Blapp done: 583f130dcf2SMartin Blapp if (error) { 584f130dcf2SMartin Blapp /* Invalidate the return value */ 585f130dcf2SMartin Blapp td->td_retval[0] = -1; 586f130dcf2SMartin Blapp } 587f130dcf2SMartin Blapp return (error); 588f130dcf2SMartin Blapp } 589f130dcf2SMartin Blapp 590f130dcf2SMartin Blapp 5913d903220SDoug Rabson static int 5920555fb35SKonstantin Belousov shmget_existing(struct thread *td, struct shmget_args *uap, int mode, 5930555fb35SKonstantin Belousov int segnum) 5943d903220SDoug Rabson { 595921d05b9SRobert Watson struct shmid_kernel *shmseg; 596d8d2f476SOlivier Houchard #ifdef MAC 5973d903220SDoug Rabson int error; 598d8d2f476SOlivier Houchard #endif 5993d903220SDoug Rabson 6000555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 6010555fb35SKonstantin Belousov KASSERT(segnum >= 0 && segnum < shmalloced, 6020555fb35SKonstantin Belousov ("segnum %d shmalloced %d", segnum, shmalloced)); 6033d903220SDoug Rabson shmseg = &shmsegs[segnum]; 604dc92aa57SAlan Cox if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL)) 605b618bb96SAlfred Perlstein return (EEXIST); 60614cedfc8SRobert Watson #ifdef MAC 60730d239bcSRobert Watson error = mac_sysvshm_check_shmget(td->td_ucred, shmseg, uap->shmflg); 608f50c4fd8SRobert Watson if (error != 0) 6097723d5edSRobert Watson return (error); 61014cedfc8SRobert Watson #endif 611b648d480SJohn Baldwin if (uap->size != 0 && uap->size > shmseg->u.shm_segsz) 612b618bb96SAlfred Perlstein return (EINVAL); 613921d05b9SRobert Watson td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm); 614b618bb96SAlfred Perlstein return (0); 6153d903220SDoug Rabson } 6163d903220SDoug Rabson 6173d903220SDoug Rabson static int 6180555fb35SKonstantin Belousov shmget_allocate_segment(struct thread *td, struct shmget_args *uap, int mode) 6193d903220SDoug Rabson { 620a854ed98SJohn Baldwin struct ucred *cred = td->td_ucred; 621921d05b9SRobert Watson struct shmid_kernel *shmseg; 6220049f8b2SAlan Cox vm_object_t shm_object; 6230555fb35SKonstantin Belousov int i, segnum; 6240555fb35SKonstantin Belousov size_t size; 6253d903220SDoug Rabson 6260555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 6270cddd8f0SMatthew Dillon 6283d903220SDoug Rabson if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax) 629b618bb96SAlfred Perlstein return (EINVAL); 630028f979dSDima Dorfman if (shm_nused >= shminfo.shmmni) /* Any shmids left? */ 631b618bb96SAlfred Perlstein return (ENOSPC); 6329e609ddeSJoerg Wunsch size = round_page(uap->size); 6333d903220SDoug Rabson if (shm_committed + btoc(size) > shminfo.shmall) 634b618bb96SAlfred Perlstein return (ENOMEM); 6353d903220SDoug Rabson if (shm_last_free < 0) { 636028f979dSDima Dorfman shmrealloc(); /* Maybe expand the shmsegs[] array. */ 637255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 638921d05b9SRobert Watson if (shmsegs[i].u.shm_perm.mode & SHMSEG_FREE) 6393d903220SDoug Rabson break; 640255108f3SPeter Wemm if (i == shmalloced) 641b618bb96SAlfred Perlstein return (ENOSPC); 6423d903220SDoug Rabson segnum = i; 6433d903220SDoug Rabson } else { 6443d903220SDoug Rabson segnum = shm_last_free; 6453d903220SDoug Rabson shm_last_free = -1; 6463d903220SDoug Rabson } 6470555fb35SKonstantin Belousov KASSERT(segnum >= 0 && segnum < shmalloced, 6480555fb35SKonstantin Belousov ("segnum %d shmalloced %d", segnum, shmalloced)); 6493d903220SDoug Rabson shmseg = &shmsegs[segnum]; 650afcc55f3SEdward Tomasz Napierala #ifdef RACCT 6514b5c9cf6SEdward Tomasz Napierala if (racct_enable) { 6523bcf7445SEdward Tomasz Napierala PROC_LOCK(td->td_proc); 6533bcf7445SEdward Tomasz Napierala if (racct_add(td->td_proc, RACCT_NSHM, 1)) { 6543bcf7445SEdward Tomasz Napierala PROC_UNLOCK(td->td_proc); 6553bcf7445SEdward Tomasz Napierala return (ENOSPC); 6563bcf7445SEdward Tomasz Napierala } 6573bcf7445SEdward Tomasz Napierala if (racct_add(td->td_proc, RACCT_SHMSIZE, size)) { 6583bcf7445SEdward Tomasz Napierala racct_sub(td->td_proc, RACCT_NSHM, 1); 6593bcf7445SEdward Tomasz Napierala PROC_UNLOCK(td->td_proc); 6603bcf7445SEdward Tomasz Napierala return (ENOMEM); 6613bcf7445SEdward Tomasz Napierala } 6623bcf7445SEdward Tomasz Napierala PROC_UNLOCK(td->td_proc); 6634b5c9cf6SEdward Tomasz Napierala } 664afcc55f3SEdward Tomasz Napierala #endif 665a51f7119SJohn Dyson 666ae9b8c3aSJohn Dyson /* 667ae9b8c3aSJohn Dyson * We make sure that we have allocated a pager before we need 668ae9b8c3aSJohn Dyson * to. 669ae9b8c3aSJohn Dyson */ 6703364c323SKonstantin Belousov shm_object = vm_pager_allocate(shm_use_phys ? OBJT_PHYS : OBJT_SWAP, 6713364c323SKonstantin Belousov 0, size, VM_PROT_DEFAULT, 0, cred); 6723bcf7445SEdward Tomasz Napierala if (shm_object == NULL) { 673afcc55f3SEdward Tomasz Napierala #ifdef RACCT 6744b5c9cf6SEdward Tomasz Napierala if (racct_enable) { 6753bcf7445SEdward Tomasz Napierala PROC_LOCK(td->td_proc); 6763bcf7445SEdward Tomasz Napierala racct_sub(td->td_proc, RACCT_NSHM, 1); 6773bcf7445SEdward Tomasz Napierala racct_sub(td->td_proc, RACCT_SHMSIZE, size); 6783bcf7445SEdward Tomasz Napierala PROC_UNLOCK(td->td_proc); 6794b5c9cf6SEdward Tomasz Napierala } 680afcc55f3SEdward Tomasz Napierala #endif 6813364c323SKonstantin Belousov return (ENOMEM); 6823bcf7445SEdward Tomasz Napierala } 683c2d5d3eeSAlan Cox shm_object->pg_color = 0; 68489f6b863SAttilio Rao VM_OBJECT_WLOCK(shm_object); 6850049f8b2SAlan Cox vm_object_clear_flag(shm_object, OBJ_ONEMAPPING); 686c2d5d3eeSAlan Cox vm_object_set_flag(shm_object, OBJ_COLORED | OBJ_NOSPLIT); 68789f6b863SAttilio Rao VM_OBJECT_WUNLOCK(shm_object); 688cbd8ec09SJohn Dyson 689b648d480SJohn Baldwin shmseg->object = shm_object; 690921d05b9SRobert Watson shmseg->u.shm_perm.cuid = shmseg->u.shm_perm.uid = cred->cr_uid; 691921d05b9SRobert Watson shmseg->u.shm_perm.cgid = shmseg->u.shm_perm.gid = cred->cr_gid; 6920555fb35SKonstantin Belousov shmseg->u.shm_perm.mode = (mode & ACCESSPERMS) | SHMSEG_ALLOCATED; 6930555fb35SKonstantin Belousov shmseg->u.shm_perm.key = uap->key; 6940555fb35SKonstantin Belousov shmseg->u.shm_perm.seq = (shmseg->u.shm_perm.seq + 1) & 0x7fff; 695b1fb5f9cSEdward Tomasz Napierala shmseg->cred = crhold(cred); 696921d05b9SRobert Watson shmseg->u.shm_segsz = uap->size; 697921d05b9SRobert Watson shmseg->u.shm_cpid = td->td_proc->p_pid; 698921d05b9SRobert Watson shmseg->u.shm_lpid = shmseg->u.shm_nattch = 0; 699921d05b9SRobert Watson shmseg->u.shm_atime = shmseg->u.shm_dtime = 0; 70014cedfc8SRobert Watson #ifdef MAC 70130d239bcSRobert Watson mac_sysvshm_create(cred, shmseg); 70214cedfc8SRobert Watson #endif 703921d05b9SRobert Watson shmseg->u.shm_ctime = time_second; 7043d903220SDoug Rabson shm_committed += btoc(size); 7053d903220SDoug Rabson shm_nused++; 7060555fb35SKonstantin Belousov td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm); 7070555fb35SKonstantin Belousov 708b618bb96SAlfred Perlstein return (0); 7093d903220SDoug Rabson } 7103d903220SDoug Rabson 71171361470SJohn Baldwin #ifndef _SYS_SYSPROTO_H_ 71271361470SJohn Baldwin struct shmget_args { 71371361470SJohn Baldwin key_t key; 71471361470SJohn Baldwin size_t size; 71571361470SJohn Baldwin int shmflg; 71671361470SJohn Baldwin }; 71771361470SJohn Baldwin #endif 7183d903220SDoug Rabson int 7190555fb35SKonstantin Belousov sys_shmget(struct thread *td, struct shmget_args *uap) 7203d903220SDoug Rabson { 721b6a4b4f9SMatthew Dillon int segnum, mode; 722b6a4b4f9SMatthew Dillon int error; 7233d903220SDoug Rabson 7240304c731SJamie Gritton if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 725c6f55f33SJohn Baldwin return (ENOSYS); 7263d903220SDoug Rabson mode = uap->shmflg & ACCESSPERMS; 7270555fb35SKonstantin Belousov SYSVSHM_LOCK(); 7280555fb35SKonstantin Belousov if (uap->key == IPC_PRIVATE) { 729b40ce416SJulian Elischer error = shmget_allocate_segment(td, uap, mode); 7300555fb35SKonstantin Belousov } else { 7310555fb35SKonstantin Belousov segnum = shm_find_segment_by_key(uap->key); 7320555fb35SKonstantin Belousov if (segnum >= 0) 7330555fb35SKonstantin Belousov error = shmget_existing(td, uap, mode, segnum); 7340555fb35SKonstantin Belousov else if ((uap->shmflg & IPC_CREAT) == 0) 7350555fb35SKonstantin Belousov error = ENOENT; 7360555fb35SKonstantin Belousov else 7370555fb35SKonstantin Belousov error = shmget_allocate_segment(td, uap, mode); 7380555fb35SKonstantin Belousov } 7390555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 740b6a4b4f9SMatthew Dillon return (error); 7413d903220SDoug Rabson } 7423d903220SDoug Rabson 74378525ce3SAlfred Perlstein static void 7440555fb35SKonstantin Belousov shmfork_myhook(struct proc *p1, struct proc *p2) 7453d903220SDoug Rabson { 7463d903220SDoug Rabson struct shmmap_state *shmmap_s; 7473d903220SDoug Rabson size_t size; 7483d903220SDoug Rabson int i; 7493d903220SDoug Rabson 7500555fb35SKonstantin Belousov SYSVSHM_LOCK(); 7513d903220SDoug Rabson size = shminfo.shmseg * sizeof(struct shmmap_state); 752a163d034SWarner Losh shmmap_s = malloc(size, M_SHM, M_WAITOK); 7532cc593fdSAlfred Perlstein bcopy(p1->p_vmspace->vm_shm, shmmap_s, size); 7542cc593fdSAlfred Perlstein p2->p_vmspace->vm_shm = shmmap_s; 7550555fb35SKonstantin Belousov for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) { 7560555fb35SKonstantin Belousov if (shmmap_s->shmid != -1) { 7570555fb35SKonstantin Belousov KASSERT(IPCID_TO_IX(shmmap_s->shmid) >= 0 && 7580555fb35SKonstantin Belousov IPCID_TO_IX(shmmap_s->shmid) < shmalloced, 7590555fb35SKonstantin Belousov ("segnum %d shmalloced %d", 7600555fb35SKonstantin Belousov IPCID_TO_IX(shmmap_s->shmid), shmalloced)); 761921d05b9SRobert Watson shmsegs[IPCID_TO_IX(shmmap_s->shmid)].u.shm_nattch++; 7620555fb35SKonstantin Belousov } 7630555fb35SKonstantin Belousov } 7640555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 7653d903220SDoug Rabson } 7663d903220SDoug Rabson 76778525ce3SAlfred Perlstein static void 7683db161e0SMatthew Dillon shmexit_myhook(struct vmspace *vm) 7693d903220SDoug Rabson { 7703db161e0SMatthew Dillon struct shmmap_state *base, *shm; 7713d903220SDoug Rabson int i; 7723d903220SDoug Rabson 7730555fb35SKonstantin Belousov base = vm->vm_shm; 7740555fb35SKonstantin Belousov if (base != NULL) { 7753db161e0SMatthew Dillon vm->vm_shm = NULL; 7760555fb35SKonstantin Belousov SYSVSHM_LOCK(); 7773db161e0SMatthew Dillon for (i = 0, shm = base; i < shminfo.shmseg; i++, shm++) { 7783db161e0SMatthew Dillon if (shm->shmid != -1) 7793db161e0SMatthew Dillon shm_delete_mapping(vm, shm); 7803db161e0SMatthew Dillon } 7810555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 7823db161e0SMatthew Dillon free(base, M_SHM); 7833db161e0SMatthew Dillon } 7843d903220SDoug Rabson } 7853d903220SDoug Rabson 786255108f3SPeter Wemm static void 787255108f3SPeter Wemm shmrealloc(void) 788255108f3SPeter Wemm { 789921d05b9SRobert Watson struct shmid_kernel *newsegs; 7900555fb35SKonstantin Belousov int i; 7910555fb35SKonstantin Belousov 7920555fb35SKonstantin Belousov SYSVSHM_ASSERT_LOCKED(); 793255108f3SPeter Wemm 794255108f3SPeter Wemm if (shmalloced >= shminfo.shmmni) 795255108f3SPeter Wemm return; 796255108f3SPeter Wemm 797a163d034SWarner Losh newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK); 798255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) 799255108f3SPeter Wemm bcopy(&shmsegs[i], &newsegs[i], sizeof(newsegs[0])); 800255108f3SPeter Wemm for (; i < shminfo.shmmni; i++) { 8010be3a191SMateusz Guzik newsegs[i].u.shm_perm.mode = SHMSEG_FREE; 8020be3a191SMateusz Guzik newsegs[i].u.shm_perm.seq = 0; 80314cedfc8SRobert Watson #ifdef MAC 8040be3a191SMateusz Guzik mac_sysvshm_init(&newsegs[i]); 80514cedfc8SRobert Watson #endif 806255108f3SPeter Wemm } 807255108f3SPeter Wemm free(shmsegs, M_SHM); 808255108f3SPeter Wemm shmsegs = newsegs; 809255108f3SPeter Wemm shmalloced = shminfo.shmmni; 810255108f3SPeter Wemm } 811255108f3SPeter Wemm 81275d633cbSKonstantin Belousov static struct syscall_helper_data shm_syscalls[] = { 81375d633cbSKonstantin Belousov SYSCALL_INIT_HELPER(shmat), 81475d633cbSKonstantin Belousov SYSCALL_INIT_HELPER(shmctl), 81575d633cbSKonstantin Belousov SYSCALL_INIT_HELPER(shmdt), 81675d633cbSKonstantin Belousov SYSCALL_INIT_HELPER(shmget), 81775d633cbSKonstantin Belousov #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \ 81875d633cbSKonstantin Belousov defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7) 8198451d0ddSKip Macy SYSCALL_INIT_HELPER_COMPAT(freebsd7_shmctl), 82075d633cbSKonstantin Belousov #endif 82175d633cbSKonstantin Belousov #if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43)) 82275d633cbSKonstantin Belousov SYSCALL_INIT_HELPER(shmsys), 82375d633cbSKonstantin Belousov #endif 82475d633cbSKonstantin Belousov SYSCALL_INIT_LAST 82575d633cbSKonstantin Belousov }; 82675d633cbSKonstantin Belousov 82775d633cbSKonstantin Belousov #ifdef COMPAT_FREEBSD32 82875d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32.h> 82975d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32_ipc.h> 83075d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32_proto.h> 83175d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32_signal.h> 83275d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32_syscall.h> 83375d633cbSKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h> 83475d633cbSKonstantin Belousov 83575d633cbSKonstantin Belousov static struct syscall_helper_data shm32_syscalls[] = { 8368451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(shmat), 8378451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(shmdt), 8388451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(shmget), 83975d633cbSKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd32_shmsys), 84075d633cbSKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd32_shmctl), 84175d633cbSKonstantin Belousov #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \ 84275d633cbSKonstantin Belousov defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7) 84375d633cbSKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd7_freebsd32_shmctl), 84475d633cbSKonstantin Belousov #endif 84575d633cbSKonstantin Belousov SYSCALL_INIT_LAST 84675d633cbSKonstantin Belousov }; 84775d633cbSKonstantin Belousov #endif 84875d633cbSKonstantin Belousov 84975d633cbSKonstantin Belousov static int 8500555fb35SKonstantin Belousov shminit(void) 8513d903220SDoug Rabson { 85275d633cbSKonstantin Belousov int i, error; 853255108f3SPeter Wemm 8544d9d1e82SRuslan Ermilov #ifndef BURN_BRIDGES 8554d9d1e82SRuslan Ermilov if (TUNABLE_ULONG_FETCH("kern.ipc.shmmaxpgs", &shminfo.shmall) != 0) 8564d9d1e82SRuslan Ermilov printf("kern.ipc.shmmaxpgs is now called kern.ipc.shmall!\n"); 8574d9d1e82SRuslan Ermilov #endif 858af3b2549SHans Petter Selasky if (shminfo.shmmax == SHMMAX) { 8594d9d1e82SRuslan Ermilov /* Initialize shmmax dealing with possible overflow. */ 860af3b2549SHans Petter Selasky for (i = PAGE_SIZE; i != 0; i--) { 861a4c24c66SJohn Baldwin shminfo.shmmax = shminfo.shmall * i; 862af3b2549SHans Petter Selasky if ((shminfo.shmmax / shminfo.shmall) == (u_long)i) 8635015c68aSAlfred Perlstein break; 8645015c68aSAlfred Perlstein } 86512075c09SPawel Jakub Dawidek } 866255108f3SPeter Wemm shmalloced = shminfo.shmmni; 867a163d034SWarner Losh shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK); 868255108f3SPeter Wemm for (i = 0; i < shmalloced; i++) { 869921d05b9SRobert Watson shmsegs[i].u.shm_perm.mode = SHMSEG_FREE; 870921d05b9SRobert Watson shmsegs[i].u.shm_perm.seq = 0; 87114cedfc8SRobert Watson #ifdef MAC 87230d239bcSRobert Watson mac_sysvshm_init(&shmsegs[i]); 87314cedfc8SRobert Watson #endif 8743d903220SDoug Rabson } 8753d903220SDoug Rabson shm_last_free = 0; 8763d903220SDoug Rabson shm_nused = 0; 8773d903220SDoug Rabson shm_committed = 0; 8780555fb35SKonstantin Belousov sx_init(&sysvshmsx, "sysvshmsx"); 87978525ce3SAlfred Perlstein shmexit_hook = &shmexit_myhook; 88078525ce3SAlfred Perlstein shmfork_hook = &shmfork_myhook; 88175d633cbSKonstantin Belousov 882e015b1abSMateusz Guzik error = syscall_helper_register(shm_syscalls, SY_THR_STATIC_KLD); 88375d633cbSKonstantin Belousov if (error != 0) 88475d633cbSKonstantin Belousov return (error); 88575d633cbSKonstantin Belousov #ifdef COMPAT_FREEBSD32 886e015b1abSMateusz Guzik error = syscall32_helper_register(shm32_syscalls, SY_THR_STATIC_KLD); 88775d633cbSKonstantin Belousov if (error != 0) 88875d633cbSKonstantin Belousov return (error); 88975d633cbSKonstantin Belousov #endif 89075d633cbSKonstantin Belousov return (0); 8913d903220SDoug Rabson } 89278525ce3SAlfred Perlstein 89378525ce3SAlfred Perlstein static int 8940555fb35SKonstantin Belousov shmunload(void) 89578525ce3SAlfred Perlstein { 89614cedfc8SRobert Watson int i; 89778525ce3SAlfred Perlstein 89878525ce3SAlfred Perlstein if (shm_nused > 0) 89978525ce3SAlfred Perlstein return (EBUSY); 90078525ce3SAlfred Perlstein 90175d633cbSKonstantin Belousov #ifdef COMPAT_FREEBSD32 90275d633cbSKonstantin Belousov syscall32_helper_unregister(shm32_syscalls); 90375d633cbSKonstantin Belousov #endif 90475d633cbSKonstantin Belousov syscall_helper_unregister(shm_syscalls); 90575d633cbSKonstantin Belousov 9060d9d996dSKonstantin Belousov for (i = 0; i < shmalloced; i++) { 90714cedfc8SRobert Watson #ifdef MAC 90830d239bcSRobert Watson mac_sysvshm_destroy(&shmsegs[i]); 90914cedfc8SRobert Watson #endif 9100d9d996dSKonstantin Belousov /* 9110d9d996dSKonstantin Belousov * Objects might be still mapped into the processes 9120d9d996dSKonstantin Belousov * address spaces. Actual free would happen on the 9130d9d996dSKonstantin Belousov * last mapping destruction. 9140d9d996dSKonstantin Belousov */ 9150d9d996dSKonstantin Belousov if (shmsegs[i].u.shm_perm.mode != SHMSEG_FREE) 9160d9d996dSKonstantin Belousov vm_object_deallocate(shmsegs[i].object); 9170d9d996dSKonstantin Belousov } 91878525ce3SAlfred Perlstein free(shmsegs, M_SHM); 91978525ce3SAlfred Perlstein shmexit_hook = NULL; 92078525ce3SAlfred Perlstein shmfork_hook = NULL; 9210555fb35SKonstantin Belousov sx_destroy(&sysvshmsx); 92278525ce3SAlfred Perlstein return (0); 92378525ce3SAlfred Perlstein } 92478525ce3SAlfred Perlstein 92578525ce3SAlfred Perlstein static int 926a723c4e1SDima Dorfman sysctl_shmsegs(SYSCTL_HANDLER_ARGS) 927a723c4e1SDima Dorfman { 9280555fb35SKonstantin Belousov int error; 929a723c4e1SDima Dorfman 9300555fb35SKonstantin Belousov SYSVSHM_LOCK(); 9310555fb35SKonstantin Belousov error = SYSCTL_OUT(req, shmsegs, shmalloced * sizeof(shmsegs[0])); 9320555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 9330555fb35SKonstantin Belousov return (error); 934a723c4e1SDima Dorfman } 935a723c4e1SDima Dorfman 93645f48220SJohn Baldwin #if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43)) 93745f48220SJohn Baldwin struct oshmid_ds { 93845f48220SJohn Baldwin struct ipc_perm_old shm_perm; /* operation perms */ 93945f48220SJohn Baldwin int shm_segsz; /* size of segment (bytes) */ 94045f48220SJohn Baldwin u_short shm_cpid; /* pid, creator */ 94145f48220SJohn Baldwin u_short shm_lpid; /* pid, last operation */ 94245f48220SJohn Baldwin short shm_nattch; /* no. of current attaches */ 94345f48220SJohn Baldwin time_t shm_atime; /* last attach time */ 94445f48220SJohn Baldwin time_t shm_dtime; /* last detach time */ 94545f48220SJohn Baldwin time_t shm_ctime; /* last change time */ 94645f48220SJohn Baldwin void *shm_handle; /* internal handle for shm segment */ 94745f48220SJohn Baldwin }; 94845f48220SJohn Baldwin 94945f48220SJohn Baldwin struct oshmctl_args { 95045f48220SJohn Baldwin int shmid; 95145f48220SJohn Baldwin int cmd; 95245f48220SJohn Baldwin struct oshmid_ds *ubuf; 95345f48220SJohn Baldwin }; 95445f48220SJohn Baldwin 95545f48220SJohn Baldwin static int 956ca998284SJohn Baldwin oshmctl(struct thread *td, struct oshmctl_args *uap) 95745f48220SJohn Baldwin { 95845f48220SJohn Baldwin #ifdef COMPAT_43 95945f48220SJohn Baldwin int error = 0; 96045f48220SJohn Baldwin struct shmid_kernel *shmseg; 96145f48220SJohn Baldwin struct oshmid_ds outbuf; 96245f48220SJohn Baldwin 96345f48220SJohn Baldwin if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 96445f48220SJohn Baldwin return (ENOSYS); 965f16f8610SKonstantin Belousov if (uap->cmd != IPC_STAT) { 966f16f8610SKonstantin Belousov return (freebsd7_shmctl(td, 967f16f8610SKonstantin Belousov (struct freebsd7_shmctl_args *)uap)); 968f16f8610SKonstantin Belousov } 9690555fb35SKonstantin Belousov SYSVSHM_LOCK(); 9700555fb35SKonstantin Belousov shmseg = shm_find_segment(uap->shmid, true); 97145f48220SJohn Baldwin if (shmseg == NULL) { 9720555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 9734cfc037cSKonstantin Belousov return (EINVAL); 97445f48220SJohn Baldwin } 97545f48220SJohn Baldwin error = ipcperm(td, &shmseg->u.shm_perm, IPC_R); 976f16f8610SKonstantin Belousov if (error != 0) { 977f16f8610SKonstantin Belousov SYSVSHM_UNLOCK(); 978f16f8610SKonstantin Belousov return (error); 979f16f8610SKonstantin Belousov } 9800555fb35SKonstantin Belousov #ifdef MAC 981f16f8610SKonstantin Belousov error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, uap->cmd); 982f16f8610SKonstantin Belousov if (error != 0) { 983f16f8610SKonstantin Belousov SYSVSHM_UNLOCK(); 984f16f8610SKonstantin Belousov return (error); 985f16f8610SKonstantin Belousov } 98645f48220SJohn Baldwin #endif 98745f48220SJohn Baldwin ipcperm_new2old(&shmseg->u.shm_perm, &outbuf.shm_perm); 98845f48220SJohn Baldwin outbuf.shm_segsz = shmseg->u.shm_segsz; 98945f48220SJohn Baldwin outbuf.shm_cpid = shmseg->u.shm_cpid; 99045f48220SJohn Baldwin outbuf.shm_lpid = shmseg->u.shm_lpid; 99145f48220SJohn Baldwin outbuf.shm_nattch = shmseg->u.shm_nattch; 99245f48220SJohn Baldwin outbuf.shm_atime = shmseg->u.shm_atime; 99345f48220SJohn Baldwin outbuf.shm_dtime = shmseg->u.shm_dtime; 99445f48220SJohn Baldwin outbuf.shm_ctime = shmseg->u.shm_ctime; 99545f48220SJohn Baldwin outbuf.shm_handle = shmseg->object; 9960555fb35SKonstantin Belousov SYSVSHM_UNLOCK(); 997e2f5418eSMateusz Guzik return (copyout(&outbuf, uap->ubuf, sizeof(outbuf))); 99845f48220SJohn Baldwin #else 99945f48220SJohn Baldwin return (EINVAL); 100045f48220SJohn Baldwin #endif 100145f48220SJohn Baldwin } 100245f48220SJohn Baldwin 100345f48220SJohn Baldwin /* XXX casting to (sy_call_t *) is bogus, as usual. */ 100445f48220SJohn Baldwin static sy_call_t *shmcalls[] = { 10058451d0ddSKip Macy (sy_call_t *)sys_shmat, (sy_call_t *)oshmctl, 10068451d0ddSKip Macy (sy_call_t *)sys_shmdt, (sy_call_t *)sys_shmget, 1007b648d480SJohn Baldwin (sy_call_t *)freebsd7_shmctl 100845f48220SJohn Baldwin }; 100945f48220SJohn Baldwin 10100555fb35SKonstantin Belousov #ifndef _SYS_SYSPROTO_H_ 101145f48220SJohn Baldwin /* XXX actually varargs. */ 10120555fb35SKonstantin Belousov struct shmsys_args { 101345f48220SJohn Baldwin int which; 101445f48220SJohn Baldwin int a2; 101545f48220SJohn Baldwin int a3; 101645f48220SJohn Baldwin int a4; 10170555fb35SKonstantin Belousov }; 10180555fb35SKonstantin Belousov #endif 10190555fb35SKonstantin Belousov int 10200555fb35SKonstantin Belousov sys_shmsys(struct thread *td, struct shmsys_args *uap) 102145f48220SJohn Baldwin { 102245f48220SJohn Baldwin 102345f48220SJohn Baldwin if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC)) 102445f48220SJohn Baldwin return (ENOSYS); 10250555fb35SKonstantin Belousov if (uap->which < 0 || uap->which >= nitems(shmcalls)) 102645f48220SJohn Baldwin return (EINVAL); 1027e2f5418eSMateusz Guzik return ((*shmcalls[uap->which])(td, &uap->a2)); 102845f48220SJohn Baldwin } 102945f48220SJohn Baldwin 103045f48220SJohn Baldwin #endif /* i386 && (COMPAT_FREEBSD4 || COMPAT_43) */ 103145f48220SJohn Baldwin 103275d633cbSKonstantin Belousov #ifdef COMPAT_FREEBSD32 103375d633cbSKonstantin Belousov 103475d633cbSKonstantin Belousov int 103575d633cbSKonstantin Belousov freebsd32_shmsys(struct thread *td, struct freebsd32_shmsys_args *uap) 103675d633cbSKonstantin Belousov { 103775d633cbSKonstantin Belousov 103875d633cbSKonstantin Belousov #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \ 103975d633cbSKonstantin Belousov defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7) 104075d633cbSKonstantin Belousov switch (uap->which) { 104175d633cbSKonstantin Belousov case 0: { /* shmat */ 104275d633cbSKonstantin Belousov struct shmat_args ap; 104375d633cbSKonstantin Belousov 104475d633cbSKonstantin Belousov ap.shmid = uap->a2; 104575d633cbSKonstantin Belousov ap.shmaddr = PTRIN(uap->a3); 104675d633cbSKonstantin Belousov ap.shmflg = uap->a4; 104775d633cbSKonstantin Belousov return (sysent[SYS_shmat].sy_call(td, &ap)); 104875d633cbSKonstantin Belousov } 104975d633cbSKonstantin Belousov case 2: { /* shmdt */ 105075d633cbSKonstantin Belousov struct shmdt_args ap; 105175d633cbSKonstantin Belousov 105275d633cbSKonstantin Belousov ap.shmaddr = PTRIN(uap->a2); 105375d633cbSKonstantin Belousov return (sysent[SYS_shmdt].sy_call(td, &ap)); 105475d633cbSKonstantin Belousov } 105575d633cbSKonstantin Belousov case 3: { /* shmget */ 105675d633cbSKonstantin Belousov struct shmget_args ap; 105775d633cbSKonstantin Belousov 105875d633cbSKonstantin Belousov ap.key = uap->a2; 105975d633cbSKonstantin Belousov ap.size = uap->a3; 106075d633cbSKonstantin Belousov ap.shmflg = uap->a4; 106175d633cbSKonstantin Belousov return (sysent[SYS_shmget].sy_call(td, &ap)); 106275d633cbSKonstantin Belousov } 106375d633cbSKonstantin Belousov case 4: { /* shmctl */ 106475d633cbSKonstantin Belousov struct freebsd7_freebsd32_shmctl_args ap; 106575d633cbSKonstantin Belousov 106675d633cbSKonstantin Belousov ap.shmid = uap->a2; 106775d633cbSKonstantin Belousov ap.cmd = uap->a3; 106875d633cbSKonstantin Belousov ap.buf = PTRIN(uap->a4); 106975d633cbSKonstantin Belousov return (freebsd7_freebsd32_shmctl(td, &ap)); 107075d633cbSKonstantin Belousov } 107175d633cbSKonstantin Belousov case 1: /* oshmctl */ 107275d633cbSKonstantin Belousov default: 107375d633cbSKonstantin Belousov return (EINVAL); 107475d633cbSKonstantin Belousov } 107575d633cbSKonstantin Belousov #else 107675d633cbSKonstantin Belousov return (nosys(td, NULL)); 107775d633cbSKonstantin Belousov #endif 107875d633cbSKonstantin Belousov } 107975d633cbSKonstantin Belousov 108075d633cbSKonstantin Belousov #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \ 108175d633cbSKonstantin Belousov defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7) 108275d633cbSKonstantin Belousov int 108375d633cbSKonstantin Belousov freebsd7_freebsd32_shmctl(struct thread *td, 108475d633cbSKonstantin Belousov struct freebsd7_freebsd32_shmctl_args *uap) 108575d633cbSKonstantin Belousov { 1086e2f5418eSMateusz Guzik int error; 108775d633cbSKonstantin Belousov union { 108875d633cbSKonstantin Belousov struct shmid_ds shmid_ds; 108975d633cbSKonstantin Belousov struct shm_info shm_info; 109075d633cbSKonstantin Belousov struct shminfo shminfo; 109175d633cbSKonstantin Belousov } u; 109275d633cbSKonstantin Belousov union { 109375d633cbSKonstantin Belousov struct shmid_ds32_old shmid_ds32; 109475d633cbSKonstantin Belousov struct shm_info32 shm_info32; 109575d633cbSKonstantin Belousov struct shminfo32 shminfo32; 109675d633cbSKonstantin Belousov } u32; 109775d633cbSKonstantin Belousov size_t sz; 109875d633cbSKonstantin Belousov 109975d633cbSKonstantin Belousov if (uap->cmd == IPC_SET) { 110075d633cbSKonstantin Belousov if ((error = copyin(uap->buf, &u32.shmid_ds32, 110175d633cbSKonstantin Belousov sizeof(u32.shmid_ds32)))) 110275d633cbSKonstantin Belousov goto done; 110375d633cbSKonstantin Belousov freebsd32_ipcperm_old_in(&u32.shmid_ds32.shm_perm, 110475d633cbSKonstantin Belousov &u.shmid_ds.shm_perm); 110575d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_segsz); 110675d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_lpid); 110775d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_cpid); 110875d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_nattch); 110975d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_atime); 111075d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_dtime); 111175d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_ctime); 111275d633cbSKonstantin Belousov } 111375d633cbSKonstantin Belousov 111475d633cbSKonstantin Belousov error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz); 111575d633cbSKonstantin Belousov if (error) 111675d633cbSKonstantin Belousov goto done; 111775d633cbSKonstantin Belousov 111875d633cbSKonstantin Belousov /* Cases in which we need to copyout */ 111975d633cbSKonstantin Belousov switch (uap->cmd) { 112075d633cbSKonstantin Belousov case IPC_INFO: 112175d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmax); 112275d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmin); 112375d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmni); 112475d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmseg); 112575d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmall); 112675d633cbSKonstantin Belousov error = copyout(&u32.shminfo32, uap->buf, 112775d633cbSKonstantin Belousov sizeof(u32.shminfo32)); 112875d633cbSKonstantin Belousov break; 112975d633cbSKonstantin Belousov case SHM_INFO: 113075d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, used_ids); 113175d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_rss); 113275d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_tot); 113375d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_swp); 113475d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, swap_attempts); 113575d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, swap_successes); 113675d633cbSKonstantin Belousov error = copyout(&u32.shm_info32, uap->buf, 113775d633cbSKonstantin Belousov sizeof(u32.shm_info32)); 113875d633cbSKonstantin Belousov break; 113975d633cbSKonstantin Belousov case SHM_STAT: 114075d633cbSKonstantin Belousov case IPC_STAT: 114175d633cbSKonstantin Belousov freebsd32_ipcperm_old_out(&u.shmid_ds.shm_perm, 114275d633cbSKonstantin Belousov &u32.shmid_ds32.shm_perm); 114375d633cbSKonstantin Belousov if (u.shmid_ds.shm_segsz > INT32_MAX) 114475d633cbSKonstantin Belousov u32.shmid_ds32.shm_segsz = INT32_MAX; 114575d633cbSKonstantin Belousov else 114675d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_segsz); 114775d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_lpid); 114875d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_cpid); 114975d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_nattch); 115075d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_atime); 115175d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_dtime); 115275d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_ctime); 115375d633cbSKonstantin Belousov u32.shmid_ds32.shm_internal = 0; 115475d633cbSKonstantin Belousov error = copyout(&u32.shmid_ds32, uap->buf, 115575d633cbSKonstantin Belousov sizeof(u32.shmid_ds32)); 115675d633cbSKonstantin Belousov break; 115775d633cbSKonstantin Belousov } 115875d633cbSKonstantin Belousov 115975d633cbSKonstantin Belousov done: 116075d633cbSKonstantin Belousov if (error) { 116175d633cbSKonstantin Belousov /* Invalidate the return value */ 116275d633cbSKonstantin Belousov td->td_retval[0] = -1; 116375d633cbSKonstantin Belousov } 116475d633cbSKonstantin Belousov return (error); 116575d633cbSKonstantin Belousov } 116675d633cbSKonstantin Belousov #endif 116775d633cbSKonstantin Belousov 116875d633cbSKonstantin Belousov int 116975d633cbSKonstantin Belousov freebsd32_shmctl(struct thread *td, struct freebsd32_shmctl_args *uap) 117075d633cbSKonstantin Belousov { 1171e2f5418eSMateusz Guzik int error; 117275d633cbSKonstantin Belousov union { 117375d633cbSKonstantin Belousov struct shmid_ds shmid_ds; 117475d633cbSKonstantin Belousov struct shm_info shm_info; 117575d633cbSKonstantin Belousov struct shminfo shminfo; 117675d633cbSKonstantin Belousov } u; 117775d633cbSKonstantin Belousov union { 117875d633cbSKonstantin Belousov struct shmid_ds32 shmid_ds32; 117975d633cbSKonstantin Belousov struct shm_info32 shm_info32; 118075d633cbSKonstantin Belousov struct shminfo32 shminfo32; 118175d633cbSKonstantin Belousov } u32; 118275d633cbSKonstantin Belousov size_t sz; 118375d633cbSKonstantin Belousov 118475d633cbSKonstantin Belousov if (uap->cmd == IPC_SET) { 118575d633cbSKonstantin Belousov if ((error = copyin(uap->buf, &u32.shmid_ds32, 118675d633cbSKonstantin Belousov sizeof(u32.shmid_ds32)))) 118775d633cbSKonstantin Belousov goto done; 118875d633cbSKonstantin Belousov freebsd32_ipcperm_in(&u32.shmid_ds32.shm_perm, 118975d633cbSKonstantin Belousov &u.shmid_ds.shm_perm); 119075d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_segsz); 119175d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_lpid); 119275d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_cpid); 119375d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_nattch); 119475d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_atime); 119575d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_dtime); 119675d633cbSKonstantin Belousov CP(u32.shmid_ds32, u.shmid_ds, shm_ctime); 119775d633cbSKonstantin Belousov } 119875d633cbSKonstantin Belousov 119975d633cbSKonstantin Belousov error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz); 120075d633cbSKonstantin Belousov if (error) 120175d633cbSKonstantin Belousov goto done; 120275d633cbSKonstantin Belousov 120375d633cbSKonstantin Belousov /* Cases in which we need to copyout */ 120475d633cbSKonstantin Belousov switch (uap->cmd) { 120575d633cbSKonstantin Belousov case IPC_INFO: 120675d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmax); 120775d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmin); 120875d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmmni); 120975d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmseg); 121075d633cbSKonstantin Belousov CP(u.shminfo, u32.shminfo32, shmall); 121175d633cbSKonstantin Belousov error = copyout(&u32.shminfo32, uap->buf, 121275d633cbSKonstantin Belousov sizeof(u32.shminfo32)); 121375d633cbSKonstantin Belousov break; 121475d633cbSKonstantin Belousov case SHM_INFO: 121575d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, used_ids); 121675d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_rss); 121775d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_tot); 121875d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, shm_swp); 121975d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, swap_attempts); 122075d633cbSKonstantin Belousov CP(u.shm_info, u32.shm_info32, swap_successes); 122175d633cbSKonstantin Belousov error = copyout(&u32.shm_info32, uap->buf, 122275d633cbSKonstantin Belousov sizeof(u32.shm_info32)); 122375d633cbSKonstantin Belousov break; 122475d633cbSKonstantin Belousov case SHM_STAT: 122575d633cbSKonstantin Belousov case IPC_STAT: 122675d633cbSKonstantin Belousov freebsd32_ipcperm_out(&u.shmid_ds.shm_perm, 122775d633cbSKonstantin Belousov &u32.shmid_ds32.shm_perm); 122875d633cbSKonstantin Belousov if (u.shmid_ds.shm_segsz > INT32_MAX) 122975d633cbSKonstantin Belousov u32.shmid_ds32.shm_segsz = INT32_MAX; 123075d633cbSKonstantin Belousov else 123175d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_segsz); 123275d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_lpid); 123375d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_cpid); 123475d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_nattch); 123575d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_atime); 123675d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_dtime); 123775d633cbSKonstantin Belousov CP(u.shmid_ds, u32.shmid_ds32, shm_ctime); 123875d633cbSKonstantin Belousov error = copyout(&u32.shmid_ds32, uap->buf, 123975d633cbSKonstantin Belousov sizeof(u32.shmid_ds32)); 124075d633cbSKonstantin Belousov break; 124175d633cbSKonstantin Belousov } 124275d633cbSKonstantin Belousov 124375d633cbSKonstantin Belousov done: 124475d633cbSKonstantin Belousov if (error) { 124575d633cbSKonstantin Belousov /* Invalidate the return value */ 124675d633cbSKonstantin Belousov td->td_retval[0] = -1; 124775d633cbSKonstantin Belousov } 124875d633cbSKonstantin Belousov return (error); 124975d633cbSKonstantin Belousov } 125075d633cbSKonstantin Belousov #endif 125175d633cbSKonstantin Belousov 1252b648d480SJohn Baldwin #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \ 1253b648d480SJohn Baldwin defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7) 1254b648d480SJohn Baldwin 125575d633cbSKonstantin Belousov #ifndef CP 1256b648d480SJohn Baldwin #define CP(src, dst, fld) do { (dst).fld = (src).fld; } while (0) 125775d633cbSKonstantin Belousov #endif 1258b648d480SJohn Baldwin 1259b648d480SJohn Baldwin #ifndef _SYS_SYSPROTO_H_ 1260b648d480SJohn Baldwin struct freebsd7_shmctl_args { 1261b648d480SJohn Baldwin int shmid; 1262b648d480SJohn Baldwin int cmd; 1263b648d480SJohn Baldwin struct shmid_ds_old *buf; 1264b648d480SJohn Baldwin }; 1265b648d480SJohn Baldwin #endif 1266b648d480SJohn Baldwin int 12670555fb35SKonstantin Belousov freebsd7_shmctl(struct thread *td, struct freebsd7_shmctl_args *uap) 1268b648d480SJohn Baldwin { 1269e2f5418eSMateusz Guzik int error; 1270b648d480SJohn Baldwin struct shmid_ds_old old; 1271b648d480SJohn Baldwin struct shmid_ds buf; 1272b648d480SJohn Baldwin size_t bufsz; 1273b648d480SJohn Baldwin 1274b648d480SJohn Baldwin /* 1275b648d480SJohn Baldwin * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support 1276b648d480SJohn Baldwin * Linux binaries. If we see the call come through the FreeBSD ABI, 1277b648d480SJohn Baldwin * return an error back to the user since we do not to support this. 1278b648d480SJohn Baldwin */ 1279b648d480SJohn Baldwin if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO || 1280b648d480SJohn Baldwin uap->cmd == SHM_STAT) 1281b648d480SJohn Baldwin return (EINVAL); 1282b648d480SJohn Baldwin 1283b648d480SJohn Baldwin /* IPC_SET needs to copyin the buffer before calling kern_shmctl */ 1284b648d480SJohn Baldwin if (uap->cmd == IPC_SET) { 1285b648d480SJohn Baldwin if ((error = copyin(uap->buf, &old, sizeof(old)))) 1286b648d480SJohn Baldwin goto done; 1287b648d480SJohn Baldwin ipcperm_old2new(&old.shm_perm, &buf.shm_perm); 1288b648d480SJohn Baldwin CP(old, buf, shm_segsz); 1289b648d480SJohn Baldwin CP(old, buf, shm_lpid); 1290b648d480SJohn Baldwin CP(old, buf, shm_cpid); 1291b648d480SJohn Baldwin CP(old, buf, shm_nattch); 1292b648d480SJohn Baldwin CP(old, buf, shm_atime); 1293b648d480SJohn Baldwin CP(old, buf, shm_dtime); 1294b648d480SJohn Baldwin CP(old, buf, shm_ctime); 1295b648d480SJohn Baldwin } 1296b648d480SJohn Baldwin 1297b648d480SJohn Baldwin error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz); 1298b648d480SJohn Baldwin if (error) 1299b648d480SJohn Baldwin goto done; 1300b648d480SJohn Baldwin 1301b648d480SJohn Baldwin /* Cases in which we need to copyout */ 1302b648d480SJohn Baldwin switch (uap->cmd) { 1303b648d480SJohn Baldwin case IPC_STAT: 1304b648d480SJohn Baldwin ipcperm_new2old(&buf.shm_perm, &old.shm_perm); 1305b648d480SJohn Baldwin if (buf.shm_segsz > INT_MAX) 1306b648d480SJohn Baldwin old.shm_segsz = INT_MAX; 1307b648d480SJohn Baldwin else 1308b648d480SJohn Baldwin CP(buf, old, shm_segsz); 1309b648d480SJohn Baldwin CP(buf, old, shm_lpid); 1310b648d480SJohn Baldwin CP(buf, old, shm_cpid); 1311b648d480SJohn Baldwin if (buf.shm_nattch > SHRT_MAX) 1312b648d480SJohn Baldwin old.shm_nattch = SHRT_MAX; 1313b648d480SJohn Baldwin else 1314b648d480SJohn Baldwin CP(buf, old, shm_nattch); 1315b648d480SJohn Baldwin CP(buf, old, shm_atime); 1316b648d480SJohn Baldwin CP(buf, old, shm_dtime); 1317b648d480SJohn Baldwin CP(buf, old, shm_ctime); 1318b648d480SJohn Baldwin old.shm_internal = NULL; 1319b648d480SJohn Baldwin error = copyout(&old, uap->buf, sizeof(old)); 1320b648d480SJohn Baldwin break; 1321b648d480SJohn Baldwin } 1322b648d480SJohn Baldwin 1323b648d480SJohn Baldwin done: 1324b648d480SJohn Baldwin if (error) { 1325b648d480SJohn Baldwin /* Invalidate the return value */ 1326b648d480SJohn Baldwin td->td_retval[0] = -1; 1327b648d480SJohn Baldwin } 1328b648d480SJohn Baldwin return (error); 1329b648d480SJohn Baldwin } 1330b648d480SJohn Baldwin 1331b648d480SJohn Baldwin #endif /* COMPAT_FREEBSD4 || COMPAT_FREEBSD5 || COMPAT_FREEBSD6 || 1332b648d480SJohn Baldwin COMPAT_FREEBSD7 */ 1333b648d480SJohn Baldwin 1334a723c4e1SDima Dorfman static int 133578525ce3SAlfred Perlstein sysvshm_modload(struct module *module, int cmd, void *arg) 133678525ce3SAlfred Perlstein { 133778525ce3SAlfred Perlstein int error = 0; 133878525ce3SAlfred Perlstein 133978525ce3SAlfred Perlstein switch (cmd) { 134078525ce3SAlfred Perlstein case MOD_LOAD: 134175d633cbSKonstantin Belousov error = shminit(); 134275d633cbSKonstantin Belousov if (error != 0) 134375d633cbSKonstantin Belousov shmunload(); 134478525ce3SAlfred Perlstein break; 134578525ce3SAlfred Perlstein case MOD_UNLOAD: 134678525ce3SAlfred Perlstein error = shmunload(); 134778525ce3SAlfred Perlstein break; 134878525ce3SAlfred Perlstein case MOD_SHUTDOWN: 134978525ce3SAlfred Perlstein break; 135078525ce3SAlfred Perlstein default: 135178525ce3SAlfred Perlstein error = EINVAL; 135278525ce3SAlfred Perlstein break; 135378525ce3SAlfred Perlstein } 135478525ce3SAlfred Perlstein return (error); 135578525ce3SAlfred Perlstein } 135678525ce3SAlfred Perlstein 1357faa784b7SDag-Erling Smørgrav static moduledata_t sysvshm_mod = { 1358faa784b7SDag-Erling Smørgrav "sysvshm", 135978525ce3SAlfred Perlstein &sysvshm_modload, 136078525ce3SAlfred Perlstein NULL 136178525ce3SAlfred Perlstein }; 136278525ce3SAlfred Perlstein 136371361470SJohn Baldwin DECLARE_MODULE(sysvshm, sysvshm_mod, SI_SUB_SYSV_SHM, SI_ORDER_FIRST); 1364faa784b7SDag-Erling Smørgrav MODULE_VERSION(sysvshm, 1); 1365