xref: /freebsd/sys/kern/sysv_shm.c (revision 2cc593fd8ee1a1d71b0adcc8d3039e2722a31196)
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