1994-09-13 14:47:38 +00:00
|
|
|
/* $NetBSD: sysv_shm.c,v 1.23 1994/07/04 23:25:12 glass Exp $ */
|
2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
1994-09-13 14:47:38 +00:00
|
|
|
* Copyright (c) 1994 Adam Glass and Charles Hannum. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by Adam Glass and Charles
|
|
|
|
* Hannum.
|
|
|
|
* 4. The names of the authors may not be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
2005-01-22 19:10:25 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 2003-2005 McAfee, Inc.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This software was developed for the FreeBSD Project in part by McAfee
|
|
|
|
* Research, the Security Research Division of McAfee, Inc under DARPA/SPAWAR
|
|
|
|
* contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS research
|
|
|
|
* program.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2000-03-30 07:17:05 +00:00
|
|
|
#include "opt_sysvipc.h"
|
1996-01-05 16:38:03 +00:00
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
#include <sys/param.h>
|
1995-10-21 19:50:00 +00:00
|
|
|
#include <sys/systm.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
#include <sys/kernel.h>
|
2009-06-24 21:10:52 +00:00
|
|
|
#include <sys/limits.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
2000-03-30 07:17:05 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mman.h>
|
2004-05-30 20:34:58 +00:00
|
|
|
#include <sys/module.h>
|
2001-05-21 18:52:02 +00:00
|
|
|
#include <sys/mutex.h>
|
2004-06-19 14:46:13 +00:00
|
|
|
#include <sys/resourcevar.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
#include <sys/stat.h>
|
2000-12-01 08:57:47 +00:00
|
|
|
#include <sys/syscall.h>
|
2003-05-05 09:22:58 +00:00
|
|
|
#include <sys/syscallsubr.h>
|
1995-10-21 19:50:00 +00:00
|
|
|
#include <sys/sysent.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/sysproto.h>
|
2000-10-31 01:34:00 +00:00
|
|
|
#include <sys/jail.h>
|
2006-10-22 11:52:19 +00:00
|
|
|
|
|
|
|
#include <security/mac/mac_framework.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
|
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_param.h>
|
|
|
|
#include <vm/pmap.h>
|
1996-09-07 03:24:44 +00:00
|
|
|
#include <vm/vm_object.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
#include <vm/vm_map.h>
|
1999-01-21 08:29:12 +00:00
|
|
|
#include <vm/vm_page.h>
|
1996-09-10 01:42:34 +00:00
|
|
|
#include <vm/vm_pager.h>
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2011-02-25 10:11:01 +00:00
|
|
|
FEATURE(sysv_shm, "System V shared memory segments support");
|
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static int shmget_allocate_segment(struct thread *td,
|
|
|
|
struct shmget_args *uap, int mode);
|
|
|
|
static int shmget_existing(struct thread *td, struct shmget_args *uap,
|
|
|
|
int mode, int segnum);
|
1995-10-21 19:50:00 +00:00
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
#define SHMSEG_FREE 0x0200
|
|
|
|
#define SHMSEG_REMOVED 0x0400
|
|
|
|
#define SHMSEG_ALLOCATED 0x0800
|
|
|
|
#define SHMSEG_WANTED 0x1000
|
|
|
|
|
2009-03-02 18:53:30 +00:00
|
|
|
static int shm_last_free, shm_nused, shmalloced;
|
2009-03-05 11:45:42 +00:00
|
|
|
vm_size_t shm_committed;
|
2004-11-12 13:23:47 +00:00
|
|
|
static struct shmid_kernel *shmsegs;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
|
|
|
struct shmmap_state {
|
|
|
|
vm_offset_t va;
|
|
|
|
int shmid;
|
|
|
|
};
|
|
|
|
|
2004-11-12 13:23:47 +00:00
|
|
|
static void shm_deallocate_segment(struct shmid_kernel *);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int shm_find_segment_by_key(key_t);
|
2004-11-12 13:23:47 +00:00
|
|
|
static struct shmid_kernel *shm_find_segment_by_shmid(int);
|
|
|
|
static struct shmid_kernel *shm_find_segment_by_shmidx(int);
|
2003-01-13 23:04:32 +00:00
|
|
|
static int shm_delete_mapping(struct vmspace *vm, struct shmmap_state *);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void shmrealloc(void);
|
2010-03-19 11:04:42 +00:00
|
|
|
static int shminit(void);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int sysvshm_modload(struct module *, int, void *);
|
|
|
|
static int shmunload(void);
|
2003-01-13 23:04:32 +00:00
|
|
|
static void shmexit_myhook(struct vmspace *vm);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void shmfork_myhook(struct proc *p1, struct proc *p2);
|
|
|
|
static int sysctl_shmsegs(SYSCTL_HANDLER_ARGS);
|
2000-03-30 07:17:05 +00:00
|
|
|
|
|
|
|
/*
|
2001-05-23 23:38:05 +00:00
|
|
|
* Tuneable values.
|
2000-03-30 07:17:05 +00:00
|
|
|
*/
|
|
|
|
#ifndef SHMMAXPGS
|
2010-06-11 09:27:33 +00:00
|
|
|
#define SHMMAXPGS 131072 /* Note: sysv shared memory is swap backed. */
|
2000-03-30 07:17:05 +00:00
|
|
|
#endif
|
|
|
|
#ifndef SHMMAX
|
|
|
|
#define SHMMAX (SHMMAXPGS*PAGE_SIZE)
|
|
|
|
#endif
|
|
|
|
#ifndef SHMMIN
|
|
|
|
#define SHMMIN 1
|
|
|
|
#endif
|
|
|
|
#ifndef SHMMNI
|
2001-05-04 18:43:19 +00:00
|
|
|
#define SHMMNI 192
|
2000-03-30 07:17:05 +00:00
|
|
|
#endif
|
|
|
|
#ifndef SHMSEG
|
2001-05-04 18:43:19 +00:00
|
|
|
#define SHMSEG 128
|
2000-03-30 07:17:05 +00:00
|
|
|
#endif
|
|
|
|
#ifndef SHMALL
|
|
|
|
#define SHMALL (SHMMAXPGS)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct shminfo shminfo = {
|
|
|
|
SHMMAX,
|
|
|
|
SHMMIN,
|
|
|
|
SHMMNI,
|
|
|
|
SHMSEG,
|
|
|
|
SHMALL
|
|
|
|
};
|
|
|
|
|
2000-05-29 22:40:54 +00:00
|
|
|
static int shm_use_phys;
|
2003-11-05 01:53:10 +00:00
|
|
|
static int shm_allow_removed;
|
2000-05-29 22:40:54 +00:00
|
|
|
|
2005-08-06 07:20:18 +00:00
|
|
|
SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0,
|
2005-02-12 01:22:39 +00:00
|
|
|
"Maximum shared memory segment size");
|
2005-08-06 07:20:18 +00:00
|
|
|
SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0,
|
2005-02-12 01:22:39 +00:00
|
|
|
"Minimum shared memory segment size");
|
2005-08-06 07:20:18 +00:00
|
|
|
SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RDTUN, &shminfo.shmmni, 0,
|
2005-02-12 01:22:39 +00:00
|
|
|
"Number of shared memory identifiers");
|
2005-08-06 07:20:18 +00:00
|
|
|
SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RDTUN, &shminfo.shmseg, 0,
|
2005-02-12 01:22:39 +00:00
|
|
|
"Number of segments per process");
|
2005-08-06 07:20:18 +00:00
|
|
|
SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0,
|
2005-02-12 01:22:39 +00:00
|
|
|
"Maximum number of pages available for shared memory");
|
2001-05-23 23:38:05 +00:00
|
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW,
|
2005-02-12 01:22:39 +00:00
|
|
|
&shm_use_phys, 0, "Enable/Disable locking of shared memory pages in core");
|
2003-11-05 01:53:10 +00:00
|
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, shm_allow_removed, CTLFLAG_RW,
|
2005-02-12 01:22:39 +00:00
|
|
|
&shm_allow_removed, 0,
|
|
|
|
"Enable/Disable attachment to attached segments marked for removal");
|
2011-01-18 21:14:18 +00:00
|
|
|
SYSCTL_PROC(_kern_ipc, OID_AUTO, shmsegs, CTLTYPE_OPAQUE | CTLFLAG_RD,
|
2005-02-12 01:22:39 +00:00
|
|
|
NULL, 0, sysctl_shmsegs, "",
|
|
|
|
"Current number of shared memory segments allocated");
|
1994-09-13 14:47:38 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
shm_find_segment_by_key(key)
|
|
|
|
key_t key;
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2000-03-30 07:17:05 +00:00
|
|
|
for (i = 0; i < shmalloced; i++)
|
2004-11-12 13:23:47 +00:00
|
|
|
if ((shmsegs[i].u.shm_perm.mode & SHMSEG_ALLOCATED) &&
|
|
|
|
shmsegs[i].u.shm_perm.key == key)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (i);
|
|
|
|
return (-1);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2004-11-12 13:23:47 +00:00
|
|
|
static struct shmid_kernel *
|
2003-11-05 01:53:10 +00:00
|
|
|
shm_find_segment_by_shmid(int shmid)
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
|
|
|
int segnum;
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
|
|
|
segnum = IPCID_TO_IX(shmid);
|
2000-03-30 07:17:05 +00:00
|
|
|
if (segnum < 0 || segnum >= shmalloced)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (NULL);
|
1994-09-13 14:47:38 +00:00
|
|
|
shmseg = &shmsegs[segnum];
|
2004-11-12 13:23:47 +00:00
|
|
|
if ((shmseg->u.shm_perm.mode & SHMSEG_ALLOCATED) == 0 ||
|
2003-11-05 01:53:10 +00:00
|
|
|
(!shm_allow_removed &&
|
2004-11-12 13:23:47 +00:00
|
|
|
(shmseg->u.shm_perm.mode & SHMSEG_REMOVED) != 0) ||
|
|
|
|
shmseg->u.shm_perm.seq != IPCID_TO_SEQ(shmid))
|
2002-08-15 02:10:12 +00:00
|
|
|
return (NULL);
|
|
|
|
return (shmseg);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2004-11-12 13:23:47 +00:00
|
|
|
static struct shmid_kernel *
|
2003-11-05 01:53:10 +00:00
|
|
|
shm_find_segment_by_shmidx(int segnum)
|
2001-10-28 09:29:10 +00:00
|
|
|
{
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
2001-10-28 09:29:10 +00:00
|
|
|
|
|
|
|
if (segnum < 0 || segnum >= shmalloced)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (NULL);
|
2001-10-28 09:29:10 +00:00
|
|
|
shmseg = &shmsegs[segnum];
|
2004-11-12 13:23:47 +00:00
|
|
|
if ((shmseg->u.shm_perm.mode & SHMSEG_ALLOCATED) == 0 ||
|
2003-11-05 01:53:10 +00:00
|
|
|
(!shm_allow_removed &&
|
2004-11-12 13:23:47 +00:00
|
|
|
(shmseg->u.shm_perm.mode & SHMSEG_REMOVED) != 0))
|
2002-08-15 02:10:12 +00:00
|
|
|
return (NULL);
|
|
|
|
return (shmseg);
|
2001-10-28 09:29:10 +00:00
|
|
|
}
|
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
static void
|
|
|
|
shm_deallocate_segment(shmseg)
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2009-03-05 11:45:42 +00:00
|
|
|
vm_size_t size;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
2009-06-24 21:10:52 +00:00
|
|
|
vm_object_deallocate(shmseg->object);
|
|
|
|
shmseg->object = NULL;
|
|
|
|
size = round_page(shmseg->u.shm_segsz);
|
1994-09-13 14:47:38 +00:00
|
|
|
shm_committed -= btoc(size);
|
|
|
|
shm_nused--;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.mode = SHMSEG_FREE;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_sysvshm_cleanup(shmseg);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2003-01-13 23:04:32 +00:00
|
|
|
shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s)
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
int segnum, result;
|
2009-03-05 11:45:42 +00:00
|
|
|
vm_size_t size;
|
1995-05-30 08:16:23 +00:00
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
2001-05-23 23:38:05 +00:00
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
segnum = IPCID_TO_IX(shmmap_s->shmid);
|
|
|
|
shmseg = &shmsegs[segnum];
|
2009-06-24 21:10:52 +00:00
|
|
|
size = round_page(shmseg->u.shm_segsz);
|
2003-01-13 23:04:32 +00:00
|
|
|
result = vm_map_remove(&vm->vm_map, shmmap_s->va, shmmap_s->va + size);
|
1994-09-13 14:47:38 +00:00
|
|
|
if (result != KERN_SUCCESS)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (EINVAL);
|
1994-09-13 14:47:38 +00:00
|
|
|
shmmap_s->shmid = -1;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_dtime = time_second;
|
|
|
|
if ((--shmseg->u.shm_nattch <= 0) &&
|
|
|
|
(shmseg->u.shm_perm.mode & SHMSEG_REMOVED)) {
|
1994-09-13 14:47:38 +00:00
|
|
|
shm_deallocate_segment(shmseg);
|
|
|
|
shm_last_free = segnum;
|
|
|
|
}
|
2002-08-15 02:10:12 +00:00
|
|
|
return (0);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
1995-12-15 05:00:31 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmdt_args {
|
2003-01-25 21:33:05 +00:00
|
|
|
const void *shmaddr;
|
1994-09-13 14:47:38 +00:00
|
|
|
};
|
1995-12-15 05:00:31 +00:00
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
shmdt(td, uap)
|
|
|
|
struct thread *td;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmdt_args *uap;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmmap_state *shmmap_s;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
|
|
|
struct shmid_kernel *shmsegptr;
|
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
int i;
|
2001-08-31 00:02:18 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2009-05-27 14:11:23 +00:00
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
2002-03-05 18:57:36 +00:00
|
|
|
return (ENOSYS);
|
2001-08-31 00:02:18 +00:00
|
|
|
mtx_lock(&Giant);
|
2002-07-22 16:22:27 +00:00
|
|
|
shmmap_s = p->p_vmspace->vm_shm;
|
2001-08-31 00:02:18 +00:00
|
|
|
if (shmmap_s == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
|
|
|
for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) {
|
1994-09-13 14:47:38 +00:00
|
|
|
if (shmmap_s->shmid != -1 &&
|
2001-08-31 00:02:18 +00:00
|
|
|
shmmap_s->va == (vm_offset_t)uap->shmaddr) {
|
1994-09-13 14:47:38 +00:00
|
|
|
break;
|
2001-08-31 00:02:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == shminfo.shmseg) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
|
|
|
shmsegptr = &shmsegs[IPCID_TO_IX(shmmap_s->shmid)];
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_sysvshm_check_shmdt(td->td_ucred, shmsegptr);
|
2006-09-20 13:40:00 +00:00
|
|
|
if (error != 0)
|
2005-01-22 19:10:25 +00:00
|
|
|
goto done2;
|
|
|
|
#endif
|
2003-01-13 23:04:32 +00:00
|
|
|
error = shm_delete_mapping(p->p_vmspace, shmmap_s);
|
2001-08-31 00:02:18 +00:00
|
|
|
done2:
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
1995-12-15 05:00:31 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmat_args {
|
|
|
|
int shmid;
|
2003-01-25 21:33:05 +00:00
|
|
|
const void *shmaddr;
|
1994-09-13 14:47:38 +00:00
|
|
|
int shmflg;
|
|
|
|
};
|
1995-12-15 05:00:31 +00:00
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
int
|
2003-11-05 01:53:10 +00:00
|
|
|
kern_shmat(td, shmid, shmaddr, shmflg)
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2003-05-05 09:22:58 +00:00
|
|
|
int shmid;
|
|
|
|
const void *shmaddr;
|
|
|
|
int shmflg;
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2001-08-31 00:02:18 +00:00
|
|
|
int i, flags;
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmmap_state *shmmap_s = NULL;
|
|
|
|
vm_offset_t attach_va;
|
|
|
|
vm_prot_t prot;
|
|
|
|
vm_size_t size;
|
1996-09-07 03:24:44 +00:00
|
|
|
int rv;
|
2001-08-31 00:02:18 +00:00
|
|
|
int error = 0;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2009-05-27 14:11:23 +00:00
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
2002-03-05 18:57:36 +00:00
|
|
|
return (ENOSYS);
|
2001-08-31 00:02:18 +00:00
|
|
|
mtx_lock(&Giant);
|
2002-07-22 16:22:27 +00:00
|
|
|
shmmap_s = p->p_vmspace->vm_shm;
|
1994-09-13 14:47:38 +00:00
|
|
|
if (shmmap_s == NULL) {
|
2009-03-05 11:45:42 +00:00
|
|
|
shmmap_s = malloc(shminfo.shmseg * sizeof(struct shmmap_state),
|
|
|
|
M_SHM, M_WAITOK);
|
1994-09-13 14:47:38 +00:00
|
|
|
for (i = 0; i < shminfo.shmseg; i++)
|
|
|
|
shmmap_s[i].shmid = -1;
|
2002-07-22 16:12:55 +00:00
|
|
|
p->p_vmspace->vm_shm = shmmap_s;
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
2003-11-05 01:53:10 +00:00
|
|
|
shmseg = shm_find_segment_by_shmid(shmid);
|
2001-08-31 00:02:18 +00:00
|
|
|
if (shmseg == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
2004-11-12 13:23:47 +00:00
|
|
|
error = ipcperm(td, &shmseg->u.shm_perm,
|
2003-05-05 09:22:58 +00:00
|
|
|
(shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2001-08-31 00:02:18 +00:00
|
|
|
goto done2;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_sysvshm_check_shmat(td->td_ucred, shmseg, shmflg);
|
2006-09-20 13:40:00 +00:00
|
|
|
if (error != 0)
|
2005-01-22 19:10:25 +00:00
|
|
|
goto done2;
|
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
for (i = 0; i < shminfo.shmseg; i++) {
|
|
|
|
if (shmmap_s->shmid == -1)
|
|
|
|
break;
|
|
|
|
shmmap_s++;
|
|
|
|
}
|
2001-08-31 00:02:18 +00:00
|
|
|
if (i >= shminfo.shmseg) {
|
|
|
|
error = EMFILE;
|
|
|
|
goto done2;
|
|
|
|
}
|
2009-06-24 21:10:52 +00:00
|
|
|
size = round_page(shmseg->u.shm_segsz);
|
1994-09-13 14:47:38 +00:00
|
|
|
prot = VM_PROT_READ;
|
2003-05-05 09:22:58 +00:00
|
|
|
if ((shmflg & SHM_RDONLY) == 0)
|
1994-09-13 14:47:38 +00:00
|
|
|
prot |= VM_PROT_WRITE;
|
|
|
|
flags = MAP_ANON | MAP_SHARED;
|
2003-05-05 09:22:58 +00:00
|
|
|
if (shmaddr) {
|
1994-09-13 14:47:38 +00:00
|
|
|
flags |= MAP_FIXED;
|
2003-05-05 09:22:58 +00:00
|
|
|
if (shmflg & SHM_RND) {
|
|
|
|
attach_va = (vm_offset_t)shmaddr & ~(SHMLBA-1);
|
|
|
|
} else if (((vm_offset_t)shmaddr & (SHMLBA-1)) == 0) {
|
|
|
|
attach_va = (vm_offset_t)shmaddr;
|
2001-08-31 00:02:18 +00:00
|
|
|
} else {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
1994-09-13 14:47:38 +00:00
|
|
|
} else {
|
2001-05-23 23:38:05 +00:00
|
|
|
/*
|
|
|
|
* This is just a hint to vm_map_find() about where to
|
|
|
|
* put it.
|
|
|
|
*/
|
2004-06-19 14:46:13 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
attach_va = round_page((vm_offset_t)p->p_vmspace->vm_daddr +
|
|
|
|
lim_max(p, RLIMIT_DATA));
|
|
|
|
PROC_UNLOCK(p);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
1996-09-07 03:24:44 +00:00
|
|
|
|
2009-06-24 21:10:52 +00:00
|
|
|
vm_object_reference(shmseg->object);
|
|
|
|
rv = vm_map_find(&p->p_vmspace->vm_map, shmseg->object,
|
2009-03-02 18:53:30 +00:00
|
|
|
0, &attach_va, size, (flags & MAP_FIXED) ? VMFS_NO_SPACE :
|
|
|
|
VMFS_ANY_SPACE, prot, prot, 0);
|
1996-09-07 03:24:44 +00:00
|
|
|
if (rv != KERN_SUCCESS) {
|
2009-06-24 21:10:52 +00:00
|
|
|
vm_object_deallocate(shmseg->object);
|
2001-08-31 00:02:18 +00:00
|
|
|
error = ENOMEM;
|
|
|
|
goto done2;
|
1996-09-07 03:24:44 +00:00
|
|
|
}
|
1996-09-10 22:35:25 +00:00
|
|
|
vm_map_inherit(&p->p_vmspace->vm_map,
|
|
|
|
attach_va, attach_va + size, VM_INHERIT_SHARE);
|
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
shmmap_s->va = attach_va;
|
2003-05-05 09:22:58 +00:00
|
|
|
shmmap_s->shmid = shmid;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_lpid = p->p_pid;
|
|
|
|
shmseg->u.shm_atime = time_second;
|
|
|
|
shmseg->u.shm_nattch++;
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = attach_va;
|
2001-08-31 00:02:18 +00:00
|
|
|
done2:
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2003-11-07 04:47:14 +00:00
|
|
|
int
|
2003-05-05 09:22:58 +00:00
|
|
|
shmat(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct shmat_args *uap;
|
|
|
|
{
|
2003-11-05 01:53:10 +00:00
|
|
|
return kern_shmat(td, uap->shmid, uap->shmaddr, uap->shmflg);
|
2003-05-05 09:22:58 +00:00
|
|
|
}
|
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
int
|
2003-11-05 01:53:10 +00:00
|
|
|
kern_shmctl(td, shmid, cmd, buf, bufsz)
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
2003-05-05 09:22:58 +00:00
|
|
|
int shmid;
|
|
|
|
int cmd;
|
|
|
|
void *buf;
|
|
|
|
size_t *bufsz;
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2001-08-31 00:02:18 +00:00
|
|
|
int error = 0;
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2009-05-27 14:11:23 +00:00
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
2002-03-05 18:57:36 +00:00
|
|
|
return (ENOSYS);
|
2003-05-05 09:22:58 +00:00
|
|
|
|
2001-08-31 00:02:18 +00:00
|
|
|
mtx_lock(&Giant);
|
2003-05-05 09:22:58 +00:00
|
|
|
switch (cmd) {
|
2008-02-12 20:55:03 +00:00
|
|
|
/*
|
|
|
|
* It is possible that kern_shmctl is being called from the Linux ABI
|
|
|
|
* layer, in which case, we will need to implement IPC_INFO. It should
|
|
|
|
* be noted that other shmctl calls will be funneled through here for
|
|
|
|
* Linix binaries as well.
|
|
|
|
*
|
|
|
|
* NB: The Linux ABI layer will convert this data to structure(s) more
|
|
|
|
* consistent with the Linux ABI.
|
|
|
|
*/
|
2001-10-28 09:29:10 +00:00
|
|
|
case IPC_INFO:
|
2003-05-05 09:22:58 +00:00
|
|
|
memcpy(buf, &shminfo, sizeof(shminfo));
|
|
|
|
if (bufsz)
|
|
|
|
*bufsz = sizeof(shminfo);
|
2001-10-28 09:29:10 +00:00
|
|
|
td->td_retval[0] = shmalloced;
|
|
|
|
goto done2;
|
|
|
|
case SHM_INFO: {
|
|
|
|
struct shm_info shm_info;
|
|
|
|
shm_info.used_ids = shm_nused;
|
|
|
|
shm_info.shm_rss = 0; /*XXX where to get from ? */
|
|
|
|
shm_info.shm_tot = 0; /*XXX where to get from ? */
|
|
|
|
shm_info.shm_swp = 0; /*XXX where to get from ? */
|
|
|
|
shm_info.swap_attempts = 0; /*XXX where to get from ? */
|
|
|
|
shm_info.swap_successes = 0; /*XXX where to get from ? */
|
2003-05-05 09:22:58 +00:00
|
|
|
memcpy(buf, &shm_info, sizeof(shm_info));
|
|
|
|
if (bufsz)
|
|
|
|
*bufsz = sizeof(shm_info);
|
2001-10-28 09:29:10 +00:00
|
|
|
td->td_retval[0] = shmalloced;
|
|
|
|
goto done2;
|
|
|
|
}
|
|
|
|
}
|
2003-05-05 09:22:58 +00:00
|
|
|
if (cmd == SHM_STAT)
|
2003-11-05 01:53:10 +00:00
|
|
|
shmseg = shm_find_segment_by_shmidx(shmid);
|
2001-10-28 09:29:10 +00:00
|
|
|
else
|
2003-11-05 01:53:10 +00:00
|
|
|
shmseg = shm_find_segment_by_shmid(shmid);
|
2001-08-31 00:02:18 +00:00
|
|
|
if (shmseg == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, cmd);
|
2006-09-20 13:40:00 +00:00
|
|
|
if (error != 0)
|
2005-01-22 19:10:25 +00:00
|
|
|
goto done2;
|
|
|
|
#endif
|
2003-05-05 09:22:58 +00:00
|
|
|
switch (cmd) {
|
2001-10-28 09:29:10 +00:00
|
|
|
case SHM_STAT:
|
1994-09-13 14:47:38 +00:00
|
|
|
case IPC_STAT:
|
2004-11-12 13:23:47 +00:00
|
|
|
error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2001-08-31 00:02:18 +00:00
|
|
|
goto done2;
|
2004-11-12 13:23:47 +00:00
|
|
|
memcpy(buf, &shmseg->u, sizeof(struct shmid_ds));
|
2003-05-05 09:22:58 +00:00
|
|
|
if (bufsz)
|
|
|
|
*bufsz = sizeof(struct shmid_ds);
|
|
|
|
if (cmd == SHM_STAT)
|
2004-11-12 13:23:47 +00:00
|
|
|
td->td_retval[0] = IXSEQ_TO_IPCID(shmid, shmseg->u.shm_perm);
|
1994-09-13 14:47:38 +00:00
|
|
|
break;
|
2003-05-05 09:22:58 +00:00
|
|
|
case IPC_SET: {
|
|
|
|
struct shmid_ds *shmid;
|
|
|
|
|
|
|
|
shmid = (struct shmid_ds *)buf;
|
2004-11-12 13:23:47 +00:00
|
|
|
error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2001-08-31 00:02:18 +00:00
|
|
|
goto done2;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.uid = shmid->shm_perm.uid;
|
|
|
|
shmseg->u.shm_perm.gid = shmid->shm_perm.gid;
|
|
|
|
shmseg->u.shm_perm.mode =
|
|
|
|
(shmseg->u.shm_perm.mode & ~ACCESSPERMS) |
|
2003-05-05 09:22:58 +00:00
|
|
|
(shmid->shm_perm.mode & ACCESSPERMS);
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_ctime = time_second;
|
1994-09-13 14:47:38 +00:00
|
|
|
break;
|
2003-05-05 09:22:58 +00:00
|
|
|
}
|
1994-09-13 14:47:38 +00:00
|
|
|
case IPC_RMID:
|
2004-11-12 13:23:47 +00:00
|
|
|
error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2001-08-31 00:02:18 +00:00
|
|
|
goto done2;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.key = IPC_PRIVATE;
|
|
|
|
shmseg->u.shm_perm.mode |= SHMSEG_REMOVED;
|
|
|
|
if (shmseg->u.shm_nattch <= 0) {
|
1994-09-13 14:47:38 +00:00
|
|
|
shm_deallocate_segment(shmseg);
|
2003-05-05 09:22:58 +00:00
|
|
|
shm_last_free = IPCID_TO_IX(shmid);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
#if 0
|
|
|
|
case SHM_LOCK:
|
|
|
|
case SHM_UNLOCK:
|
|
|
|
#endif
|
|
|
|
default:
|
2001-08-31 00:02:18 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
2001-08-31 00:02:18 +00:00
|
|
|
done2:
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2009-06-24 13:35:38 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct shmctl_args {
|
|
|
|
int shmid;
|
|
|
|
int cmd;
|
|
|
|
struct shmid_ds *buf;
|
|
|
|
};
|
|
|
|
#endif
|
2003-05-05 09:22:58 +00:00
|
|
|
int
|
|
|
|
shmctl(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct shmctl_args *uap;
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct shmid_ds buf;
|
|
|
|
size_t bufsz;
|
|
|
|
|
2008-02-12 20:55:03 +00:00
|
|
|
/*
|
|
|
|
* The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
|
|
|
|
* Linux binaries. If we see the call come through the FreeBSD ABI,
|
|
|
|
* return an error back to the user since we do not to support this.
|
|
|
|
*/
|
|
|
|
if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
|
|
|
|
uap->cmd == SHM_STAT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2003-05-05 09:22:58 +00:00
|
|
|
/* IPC_SET needs to copyin the buffer before calling kern_shmctl */
|
|
|
|
if (uap->cmd == IPC_SET) {
|
|
|
|
if ((error = copyin(uap->buf, &buf, sizeof(struct shmid_ds))))
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2003-11-05 01:53:10 +00:00
|
|
|
error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
|
2003-05-05 09:22:58 +00:00
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Cases in which we need to copyout */
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case IPC_STAT:
|
|
|
|
error = copyout(&buf, uap->buf, bufsz);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
if (error) {
|
|
|
|
/* Invalidate the return value */
|
|
|
|
td->td_retval[0] = -1;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
shmget_existing(td, uap, mode, segnum)
|
|
|
|
struct thread *td;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmget_args *uap;
|
|
|
|
int mode;
|
|
|
|
int segnum;
|
|
|
|
{
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
1994-09-13 14:47:38 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
shmseg = &shmsegs[segnum];
|
2004-11-12 13:23:47 +00:00
|
|
|
if (shmseg->u.shm_perm.mode & SHMSEG_REMOVED) {
|
1994-09-13 14:47:38 +00:00
|
|
|
/*
|
|
|
|
* This segment is in the process of being allocated. Wait
|
|
|
|
* until it's done, and look the key up again (in case the
|
|
|
|
* allocation failed or it was freed).
|
|
|
|
*/
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.mode |= SHMSEG_WANTED;
|
2002-07-22 16:12:55 +00:00
|
|
|
error = tsleep(shmseg, PLOCK | PCATCH, "shmget", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (error);
|
|
|
|
return (EAGAIN);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
1999-06-19 23:53:13 +00:00
|
|
|
if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL))
|
2002-08-15 02:10:12 +00:00
|
|
|
return (EEXIST);
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_sysvshm_check_shmget(td->td_ucred, shmseg, uap->shmflg);
|
2006-09-20 13:40:00 +00:00
|
|
|
if (error != 0)
|
2005-10-04 16:40:20 +00:00
|
|
|
return (error);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
2009-06-24 21:10:52 +00:00
|
|
|
if (uap->size != 0 && uap->size > shmseg->u.shm_segsz)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (EINVAL);
|
2004-11-12 13:23:47 +00:00
|
|
|
td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
|
2002-08-15 02:10:12 +00:00
|
|
|
return (0);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
shmget_allocate_segment(td, uap, mode)
|
|
|
|
struct thread *td;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmget_args *uap;
|
|
|
|
int mode;
|
|
|
|
{
|
2009-03-02 18:53:30 +00:00
|
|
|
int i, segnum, shmid;
|
|
|
|
size_t size;
|
2002-02-27 18:32:23 +00:00
|
|
|
struct ucred *cred = td->td_ucred;
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *shmseg;
|
2004-07-09 05:28:38 +00:00
|
|
|
vm_object_t shm_object;
|
1995-05-30 08:16:23 +00:00
|
|
|
|
2001-07-04 16:20:28 +00:00
|
|
|
GIANT_REQUIRED;
|
|
|
|
|
1994-09-13 14:47:38 +00:00
|
|
|
if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (EINVAL);
|
2001-05-23 23:38:05 +00:00
|
|
|
if (shm_nused >= shminfo.shmmni) /* Any shmids left? */
|
2002-08-15 02:10:12 +00:00
|
|
|
return (ENOSPC);
|
1996-05-05 13:53:48 +00:00
|
|
|
size = round_page(uap->size);
|
1994-09-13 14:47:38 +00:00
|
|
|
if (shm_committed + btoc(size) > shminfo.shmall)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (ENOMEM);
|
1994-09-13 14:47:38 +00:00
|
|
|
if (shm_last_free < 0) {
|
2001-05-23 23:38:05 +00:00
|
|
|
shmrealloc(); /* Maybe expand the shmsegs[] array. */
|
2000-03-30 07:17:05 +00:00
|
|
|
for (i = 0; i < shmalloced; i++)
|
2004-11-12 13:23:47 +00:00
|
|
|
if (shmsegs[i].u.shm_perm.mode & SHMSEG_FREE)
|
1994-09-13 14:47:38 +00:00
|
|
|
break;
|
2000-03-30 07:17:05 +00:00
|
|
|
if (i == shmalloced)
|
2002-08-15 02:10:12 +00:00
|
|
|
return (ENOSPC);
|
1994-09-13 14:47:38 +00:00
|
|
|
segnum = i;
|
|
|
|
} else {
|
|
|
|
segnum = shm_last_free;
|
|
|
|
shm_last_free = -1;
|
|
|
|
}
|
|
|
|
shmseg = &shmsegs[segnum];
|
|
|
|
/*
|
|
|
|
* In case we sleep in malloc(), mark the segment present but deleted
|
|
|
|
* so that noone else tries to create the same key.
|
|
|
|
*/
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.mode = SHMSEG_ALLOCATED | SHMSEG_REMOVED;
|
|
|
|
shmseg->u.shm_perm.key = uap->key;
|
|
|
|
shmseg->u.shm_perm.seq = (shmseg->u.shm_perm.seq + 1) & 0x7fff;
|
|
|
|
shmid = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
|
1996-09-07 03:24:44 +00:00
|
|
|
|
1996-09-10 01:42:34 +00:00
|
|
|
/*
|
|
|
|
* We make sure that we have allocated a pager before we need
|
|
|
|
* to.
|
|
|
|
*/
|
Implement global and per-uid accounting of the anonymous memory. Add
rlimit RLIMIT_SWAP that limits the amount of swap that may be reserved
for the uid.
The accounting information (charge) is associated with either map entry,
or vm object backing the entry, assuming the object is the first one
in the shadow chain and entry does not require COW. Charge is moved
from entry to object on allocation of the object, e.g. during the mmap,
assuming the object is allocated, or on the first page fault on the
entry. It moves back to the entry on forks due to COW setup.
The per-entry granularity of accounting makes the charge process fair
for processes that change uid during lifetime, and decrements charge
for proper uid when region is unmapped.
The interface of vm_pager_allocate(9) is extended by adding struct ucred *,
that is used to charge appropriate uid when allocation if performed by
kernel, e.g. md(4).
Several syscalls, among them is fork(2), may now return ENOMEM when
global or per-uid limits are enforced.
In collaboration with: pho
Reviewed by: alc
Approved by: re (kensmith)
2009-06-23 20:45:22 +00:00
|
|
|
shm_object = vm_pager_allocate(shm_use_phys ? OBJT_PHYS : OBJT_SWAP,
|
|
|
|
0, size, VM_PROT_DEFAULT, 0, cred);
|
|
|
|
if (shm_object == NULL)
|
|
|
|
return (ENOMEM);
|
2004-07-09 05:28:38 +00:00
|
|
|
VM_OBJECT_LOCK(shm_object);
|
|
|
|
vm_object_clear_flag(shm_object, OBJ_ONEMAPPING);
|
|
|
|
vm_object_set_flag(shm_object, OBJ_NOSPLIT);
|
|
|
|
VM_OBJECT_UNLOCK(shm_object);
|
1998-05-04 03:01:44 +00:00
|
|
|
|
2009-06-24 21:10:52 +00:00
|
|
|
shmseg->object = shm_object;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.cuid = shmseg->u.shm_perm.uid = cred->cr_uid;
|
|
|
|
shmseg->u.shm_perm.cgid = shmseg->u.shm_perm.gid = cred->cr_gid;
|
|
|
|
shmseg->u.shm_perm.mode = (shmseg->u.shm_perm.mode & SHMSEG_WANTED) |
|
1994-09-13 14:47:38 +00:00
|
|
|
(mode & ACCESSPERMS) | SHMSEG_ALLOCATED;
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_segsz = uap->size;
|
|
|
|
shmseg->u.shm_cpid = td->td_proc->p_pid;
|
|
|
|
shmseg->u.shm_lpid = shmseg->u.shm_nattch = 0;
|
|
|
|
shmseg->u.shm_atime = shmseg->u.shm_dtime = 0;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_sysvshm_create(cred, shmseg);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_ctime = time_second;
|
1994-09-13 14:47:38 +00:00
|
|
|
shm_committed += btoc(size);
|
|
|
|
shm_nused++;
|
2004-11-12 13:23:47 +00:00
|
|
|
if (shmseg->u.shm_perm.mode & SHMSEG_WANTED) {
|
1994-09-13 14:47:38 +00:00
|
|
|
/*
|
|
|
|
* Somebody else wanted this key while we were asleep. Wake
|
|
|
|
* them up now.
|
|
|
|
*/
|
2004-11-12 13:23:47 +00:00
|
|
|
shmseg->u.shm_perm.mode &= ~SHMSEG_WANTED;
|
2002-07-22 16:12:55 +00:00
|
|
|
wakeup(shmseg);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = shmid;
|
2002-08-15 02:10:12 +00:00
|
|
|
return (0);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2009-06-24 13:35:38 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct shmget_args {
|
|
|
|
key_t key;
|
|
|
|
size_t size;
|
|
|
|
int shmflg;
|
|
|
|
};
|
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
shmget(td, uap)
|
|
|
|
struct thread *td;
|
1994-09-13 14:47:38 +00:00
|
|
|
struct shmget_args *uap;
|
|
|
|
{
|
2001-08-31 00:02:18 +00:00
|
|
|
int segnum, mode;
|
|
|
|
int error;
|
1994-09-13 14:47:38 +00:00
|
|
|
|
2009-05-27 14:11:23 +00:00
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
2002-03-05 18:57:36 +00:00
|
|
|
return (ENOSYS);
|
2001-08-31 00:02:18 +00:00
|
|
|
mtx_lock(&Giant);
|
1994-09-13 14:47:38 +00:00
|
|
|
mode = uap->shmflg & ACCESSPERMS;
|
|
|
|
if (uap->key != IPC_PRIVATE) {
|
|
|
|
again:
|
|
|
|
segnum = shm_find_segment_by_key(uap->key);
|
|
|
|
if (segnum >= 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
error = shmget_existing(td, uap, mode, segnum);
|
1994-09-13 14:47:38 +00:00
|
|
|
if (error == EAGAIN)
|
|
|
|
goto again;
|
2001-08-31 00:02:18 +00:00
|
|
|
goto done2;
|
|
|
|
}
|
|
|
|
if ((uap->shmflg & IPC_CREAT) == 0) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto done2;
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
error = shmget_allocate_segment(td, uap, mode);
|
2001-08-31 00:02:18 +00:00
|
|
|
done2:
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2000-12-01 08:57:47 +00:00
|
|
|
static void
|
|
|
|
shmfork_myhook(p1, p2)
|
1994-09-13 14:47:38 +00:00
|
|
|
struct proc *p1, *p2;
|
|
|
|
{
|
|
|
|
struct shmmap_state *shmmap_s;
|
|
|
|
size_t size;
|
|
|
|
int i;
|
|
|
|
|
2004-09-03 05:11:32 +00:00
|
|
|
mtx_lock(&Giant);
|
1994-09-13 14:47:38 +00:00
|
|
|
size = shminfo.shmseg * sizeof(struct shmmap_state);
|
2003-02-19 05:47:46 +00:00
|
|
|
shmmap_s = malloc(size, M_SHM, M_WAITOK);
|
2002-07-22 16:12:55 +00:00
|
|
|
bcopy(p1->p_vmspace->vm_shm, shmmap_s, size);
|
|
|
|
p2->p_vmspace->vm_shm = shmmap_s;
|
1994-09-13 14:47:38 +00:00
|
|
|
for (i = 0; i < shminfo.shmseg; i++, shmmap_s++)
|
|
|
|
if (shmmap_s->shmid != -1)
|
2004-11-12 13:23:47 +00:00
|
|
|
shmsegs[IPCID_TO_IX(shmmap_s->shmid)].u.shm_nattch++;
|
2004-09-03 05:11:32 +00:00
|
|
|
mtx_unlock(&Giant);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2000-12-01 08:57:47 +00:00
|
|
|
static void
|
2003-01-13 23:04:32 +00:00
|
|
|
shmexit_myhook(struct vmspace *vm)
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2003-01-13 23:04:32 +00:00
|
|
|
struct shmmap_state *base, *shm;
|
1994-09-13 14:47:38 +00:00
|
|
|
int i;
|
|
|
|
|
2003-01-13 23:04:32 +00:00
|
|
|
if ((base = vm->vm_shm) != NULL) {
|
|
|
|
vm->vm_shm = NULL;
|
2004-07-27 03:53:41 +00:00
|
|
|
mtx_lock(&Giant);
|
2003-01-13 23:04:32 +00:00
|
|
|
for (i = 0, shm = base; i < shminfo.shmseg; i++, shm++) {
|
|
|
|
if (shm->shmid != -1)
|
|
|
|
shm_delete_mapping(vm, shm);
|
|
|
|
}
|
2004-07-27 03:53:41 +00:00
|
|
|
mtx_unlock(&Giant);
|
2003-01-13 23:04:32 +00:00
|
|
|
free(base, M_SHM);
|
|
|
|
}
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
|
2000-03-30 07:17:05 +00:00
|
|
|
static void
|
|
|
|
shmrealloc(void)
|
|
|
|
{
|
|
|
|
int i;
|
2004-11-12 13:23:47 +00:00
|
|
|
struct shmid_kernel *newsegs;
|
2000-03-30 07:17:05 +00:00
|
|
|
|
|
|
|
if (shmalloced >= shminfo.shmmni)
|
|
|
|
return;
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK);
|
2000-03-30 07:17:05 +00:00
|
|
|
if (newsegs == NULL)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < shmalloced; i++)
|
|
|
|
bcopy(&shmsegs[i], &newsegs[i], sizeof(newsegs[0]));
|
|
|
|
for (; i < shminfo.shmmni; i++) {
|
2004-11-12 13:23:47 +00:00
|
|
|
shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
|
|
|
|
shmsegs[i].u.shm_perm.seq = 0;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_sysvshm_init(&shmsegs[i]);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
2000-03-30 07:17:05 +00:00
|
|
|
}
|
|
|
|
free(shmsegs, M_SHM);
|
|
|
|
shmsegs = newsegs;
|
|
|
|
shmalloced = shminfo.shmmni;
|
|
|
|
}
|
|
|
|
|
2010-03-19 11:04:42 +00:00
|
|
|
static struct syscall_helper_data shm_syscalls[] = {
|
|
|
|
SYSCALL_INIT_HELPER(shmat),
|
|
|
|
SYSCALL_INIT_HELPER(shmctl),
|
|
|
|
SYSCALL_INIT_HELPER(shmdt),
|
|
|
|
SYSCALL_INIT_HELPER(shmget),
|
|
|
|
#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
|
|
|
|
defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
|
|
|
|
SYSCALL_INIT_HELPER(freebsd7_shmctl),
|
|
|
|
#endif
|
|
|
|
#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
|
|
|
|
SYSCALL_INIT_HELPER(shmsys),
|
|
|
|
#endif
|
|
|
|
SYSCALL_INIT_LAST
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
#include <compat/freebsd32/freebsd32.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_ipc.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_proto.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_signal.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_syscall.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_util.h>
|
|
|
|
|
|
|
|
static struct syscall_helper_data shm32_syscalls[] = {
|
|
|
|
SYSCALL32_INIT_HELPER(shmat),
|
|
|
|
SYSCALL32_INIT_HELPER(shmdt),
|
|
|
|
SYSCALL32_INIT_HELPER(shmget),
|
|
|
|
SYSCALL32_INIT_HELPER(freebsd32_shmsys),
|
|
|
|
SYSCALL32_INIT_HELPER(freebsd32_shmctl),
|
|
|
|
#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
|
|
|
|
defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
|
|
|
|
SYSCALL32_INIT_HELPER(freebsd7_freebsd32_shmctl),
|
|
|
|
#endif
|
|
|
|
SYSCALL_INIT_LAST
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
2000-12-01 08:57:47 +00:00
|
|
|
shminit()
|
1994-09-13 14:47:38 +00:00
|
|
|
{
|
2010-03-19 11:04:42 +00:00
|
|
|
int i, error;
|
2000-03-30 07:17:05 +00:00
|
|
|
|
2009-10-24 19:00:58 +00:00
|
|
|
#ifndef BURN_BRIDGES
|
|
|
|
if (TUNABLE_ULONG_FETCH("kern.ipc.shmmaxpgs", &shminfo.shmall) != 0)
|
|
|
|
printf("kern.ipc.shmmaxpgs is now called kern.ipc.shmall!\n");
|
|
|
|
#endif
|
|
|
|
TUNABLE_ULONG_FETCH("kern.ipc.shmall", &shminfo.shmall);
|
|
|
|
|
|
|
|
/* Initialize shmmax dealing with possible overflow. */
|
2003-02-16 16:12:10 +00:00
|
|
|
for (i = PAGE_SIZE; i > 0; i--) {
|
2005-05-12 20:04:48 +00:00
|
|
|
shminfo.shmmax = shminfo.shmall * i;
|
2003-02-16 06:08:55 +00:00
|
|
|
if (shminfo.shmmax >= shminfo.shmall)
|
|
|
|
break;
|
|
|
|
}
|
2009-10-24 19:00:58 +00:00
|
|
|
|
2005-08-06 07:20:18 +00:00
|
|
|
TUNABLE_ULONG_FETCH("kern.ipc.shmmin", &shminfo.shmmin);
|
|
|
|
TUNABLE_ULONG_FETCH("kern.ipc.shmmni", &shminfo.shmmni);
|
|
|
|
TUNABLE_ULONG_FETCH("kern.ipc.shmseg", &shminfo.shmseg);
|
2001-09-13 20:20:09 +00:00
|
|
|
TUNABLE_INT_FETCH("kern.ipc.shm_use_phys", &shm_use_phys);
|
|
|
|
|
2000-03-30 07:17:05 +00:00
|
|
|
shmalloced = shminfo.shmmni;
|
2003-02-19 05:47:46 +00:00
|
|
|
shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK);
|
2000-03-30 07:17:05 +00:00
|
|
|
for (i = 0; i < shmalloced; i++) {
|
2004-11-12 13:23:47 +00:00
|
|
|
shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
|
|
|
|
shmsegs[i].u.shm_perm.seq = 0;
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_sysvshm_init(&shmsegs[i]);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
|
|
|
shm_last_free = 0;
|
|
|
|
shm_nused = 0;
|
|
|
|
shm_committed = 0;
|
2000-12-01 08:57:47 +00:00
|
|
|
shmexit_hook = &shmexit_myhook;
|
|
|
|
shmfork_hook = &shmfork_myhook;
|
2010-03-19 11:04:42 +00:00
|
|
|
|
|
|
|
error = syscall_helper_register(shm_syscalls);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
error = syscall32_helper_register(shm32_syscalls);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
#endif
|
|
|
|
return (0);
|
2000-12-01 08:57:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
shmunload()
|
|
|
|
{
|
2005-01-22 19:10:25 +00:00
|
|
|
int i;
|
2000-12-01 08:57:47 +00:00
|
|
|
|
|
|
|
if (shm_nused > 0)
|
|
|
|
return (EBUSY);
|
|
|
|
|
2010-03-19 11:04:42 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
syscall32_helper_unregister(shm32_syscalls);
|
|
|
|
#endif
|
|
|
|
syscall_helper_unregister(shm_syscalls);
|
|
|
|
|
2010-06-28 18:12:42 +00:00
|
|
|
for (i = 0; i < shmalloced; i++) {
|
2005-01-22 19:10:25 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_sysvshm_destroy(&shmsegs[i]);
|
2005-01-22 19:10:25 +00:00
|
|
|
#endif
|
2010-06-28 18:12:42 +00:00
|
|
|
/*
|
|
|
|
* Objects might be still mapped into the processes
|
|
|
|
* address spaces. Actual free would happen on the
|
|
|
|
* last mapping destruction.
|
|
|
|
*/
|
|
|
|
if (shmsegs[i].u.shm_perm.mode != SHMSEG_FREE)
|
|
|
|
vm_object_deallocate(shmsegs[i].object);
|
|
|
|
}
|
2000-12-01 08:57:47 +00:00
|
|
|
free(shmsegs, M_SHM);
|
|
|
|
shmexit_hook = NULL;
|
|
|
|
shmfork_hook = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2001-05-30 03:28:59 +00:00
|
|
|
static int
|
|
|
|
sysctl_shmsegs(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (SYSCTL_OUT(req, shmsegs, shmalloced * sizeof(shmsegs[0])));
|
|
|
|
}
|
|
|
|
|
2009-06-24 20:01:13 +00:00
|
|
|
#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
|
|
|
|
struct oshmid_ds {
|
|
|
|
struct ipc_perm_old shm_perm; /* operation perms */
|
|
|
|
int shm_segsz; /* size of segment (bytes) */
|
|
|
|
u_short shm_cpid; /* pid, creator */
|
|
|
|
u_short shm_lpid; /* pid, last operation */
|
|
|
|
short shm_nattch; /* no. of current attaches */
|
|
|
|
time_t shm_atime; /* last attach time */
|
|
|
|
time_t shm_dtime; /* last detach time */
|
|
|
|
time_t shm_ctime; /* last change time */
|
|
|
|
void *shm_handle; /* internal handle for shm segment */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct oshmctl_args {
|
|
|
|
int shmid;
|
|
|
|
int cmd;
|
|
|
|
struct oshmid_ds *ubuf;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2009-06-25 13:36:57 +00:00
|
|
|
oshmctl(struct thread *td, struct oshmctl_args *uap)
|
2009-06-24 20:01:13 +00:00
|
|
|
{
|
|
|
|
#ifdef COMPAT_43
|
|
|
|
int error = 0;
|
|
|
|
struct shmid_kernel *shmseg;
|
|
|
|
struct oshmid_ds outbuf;
|
|
|
|
|
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
|
|
|
return (ENOSYS);
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
shmseg = shm_find_segment_by_shmid(uap->shmid);
|
|
|
|
if (shmseg == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto done2;
|
|
|
|
}
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case IPC_STAT:
|
|
|
|
error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
|
|
|
|
if (error)
|
|
|
|
goto done2;
|
|
|
|
#ifdef MAC
|
|
|
|
error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, uap->cmd);
|
|
|
|
if (error != 0)
|
|
|
|
goto done2;
|
|
|
|
#endif
|
|
|
|
ipcperm_new2old(&shmseg->u.shm_perm, &outbuf.shm_perm);
|
|
|
|
outbuf.shm_segsz = shmseg->u.shm_segsz;
|
|
|
|
outbuf.shm_cpid = shmseg->u.shm_cpid;
|
|
|
|
outbuf.shm_lpid = shmseg->u.shm_lpid;
|
|
|
|
outbuf.shm_nattch = shmseg->u.shm_nattch;
|
|
|
|
outbuf.shm_atime = shmseg->u.shm_atime;
|
|
|
|
outbuf.shm_dtime = shmseg->u.shm_dtime;
|
|
|
|
outbuf.shm_ctime = shmseg->u.shm_ctime;
|
|
|
|
outbuf.shm_handle = shmseg->object;
|
|
|
|
error = copyout(&outbuf, uap->ubuf, sizeof(outbuf));
|
|
|
|
if (error)
|
|
|
|
goto done2;
|
|
|
|
break;
|
|
|
|
default:
|
2009-06-25 17:11:27 +00:00
|
|
|
error = freebsd7_shmctl(td, (struct freebsd7_shmctl_args *)uap);
|
2009-06-24 20:01:13 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
done2:
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
|
|
|
#else
|
|
|
|
return (EINVAL);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX casting to (sy_call_t *) is bogus, as usual. */
|
|
|
|
static sy_call_t *shmcalls[] = {
|
|
|
|
(sy_call_t *)shmat, (sy_call_t *)oshmctl,
|
|
|
|
(sy_call_t *)shmdt, (sy_call_t *)shmget,
|
2009-06-24 21:10:52 +00:00
|
|
|
(sy_call_t *)freebsd7_shmctl
|
2009-06-24 20:01:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
int
|
|
|
|
shmsys(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
/* XXX actually varargs. */
|
|
|
|
struct shmsys_args /* {
|
|
|
|
int which;
|
|
|
|
int a2;
|
|
|
|
int a3;
|
|
|
|
int a4;
|
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
|
|
|
|
return (ENOSYS);
|
|
|
|
if (uap->which < 0 ||
|
|
|
|
uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0]))
|
|
|
|
return (EINVAL);
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
error = (*shmcalls[uap->which])(td, &uap->a2);
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* i386 && (COMPAT_FREEBSD4 || COMPAT_43) */
|
|
|
|
|
2010-03-19 11:04:42 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
|
|
|
|
int
|
|
|
|
freebsd32_shmsys(struct thread *td, struct freebsd32_shmsys_args *uap)
|
|
|
|
{
|
|
|
|
|
2009-06-24 21:10:52 +00:00
|
|
|
#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
|
|
|
|
defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
|
2010-03-19 11:04:42 +00:00
|
|
|
switch (uap->which) {
|
|
|
|
case 0: { /* shmat */
|
|
|
|
struct shmat_args ap;
|
|
|
|
|
|
|
|
ap.shmid = uap->a2;
|
|
|
|
ap.shmaddr = PTRIN(uap->a3);
|
|
|
|
ap.shmflg = uap->a4;
|
|
|
|
return (sysent[SYS_shmat].sy_call(td, &ap));
|
|
|
|
}
|
|
|
|
case 2: { /* shmdt */
|
|
|
|
struct shmdt_args ap;
|
2009-06-24 21:10:52 +00:00
|
|
|
|
2010-03-19 11:04:42 +00:00
|
|
|
ap.shmaddr = PTRIN(uap->a2);
|
|
|
|
return (sysent[SYS_shmdt].sy_call(td, &ap));
|
|
|
|
}
|
|
|
|
case 3: { /* shmget */
|
|
|
|
struct shmget_args ap;
|
2009-06-24 21:10:52 +00:00
|
|
|
|
2010-03-19 11:04:42 +00:00
|
|
|
ap.key = uap->a2;
|
|
|
|
ap.size = uap->a3;
|
|
|
|
ap.shmflg = uap->a4;
|
|
|
|
return (sysent[SYS_shmget].sy_call(td, &ap));
|
|
|
|
}
|
|
|
|
case 4: { /* shmctl */
|
|
|
|
struct freebsd7_freebsd32_shmctl_args ap;
|
|
|
|
|
|
|
|
ap.shmid = uap->a2;
|
|
|
|
ap.cmd = uap->a3;
|
|
|
|
ap.buf = PTRIN(uap->a4);
|
|
|
|
return (freebsd7_freebsd32_shmctl(td, &ap));
|
|
|
|
}
|
|
|
|
case 1: /* oshmctl */
|
|
|
|
default:
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
return (nosys(td, NULL));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
|
|
|
|
defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
|
|
|
|
int
|
|
|
|
freebsd7_freebsd32_shmctl(struct thread *td,
|
|
|
|
struct freebsd7_freebsd32_shmctl_args *uap)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
union {
|
|
|
|
struct shmid_ds shmid_ds;
|
|
|
|
struct shm_info shm_info;
|
|
|
|
struct shminfo shminfo;
|
|
|
|
} u;
|
|
|
|
union {
|
|
|
|
struct shmid_ds32_old shmid_ds32;
|
|
|
|
struct shm_info32 shm_info32;
|
|
|
|
struct shminfo32 shminfo32;
|
|
|
|
} u32;
|
|
|
|
size_t sz;
|
|
|
|
|
|
|
|
if (uap->cmd == IPC_SET) {
|
|
|
|
if ((error = copyin(uap->buf, &u32.shmid_ds32,
|
|
|
|
sizeof(u32.shmid_ds32))))
|
|
|
|
goto done;
|
|
|
|
freebsd32_ipcperm_old_in(&u32.shmid_ds32.shm_perm,
|
|
|
|
&u.shmid_ds.shm_perm);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Cases in which we need to copyout */
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case IPC_INFO:
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmax);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmin);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmni);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmseg);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmall);
|
|
|
|
error = copyout(&u32.shminfo32, uap->buf,
|
|
|
|
sizeof(u32.shminfo32));
|
|
|
|
break;
|
|
|
|
case SHM_INFO:
|
|
|
|
CP(u.shm_info, u32.shm_info32, used_ids);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_rss);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_tot);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_swp);
|
|
|
|
CP(u.shm_info, u32.shm_info32, swap_attempts);
|
|
|
|
CP(u.shm_info, u32.shm_info32, swap_successes);
|
|
|
|
error = copyout(&u32.shm_info32, uap->buf,
|
|
|
|
sizeof(u32.shm_info32));
|
|
|
|
break;
|
|
|
|
case SHM_STAT:
|
|
|
|
case IPC_STAT:
|
|
|
|
freebsd32_ipcperm_old_out(&u.shmid_ds.shm_perm,
|
|
|
|
&u32.shmid_ds32.shm_perm);
|
|
|
|
if (u.shmid_ds.shm_segsz > INT32_MAX)
|
|
|
|
u32.shmid_ds32.shm_segsz = INT32_MAX;
|
|
|
|
else
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
|
|
|
|
u32.shmid_ds32.shm_internal = 0;
|
|
|
|
error = copyout(&u32.shmid_ds32, uap->buf,
|
|
|
|
sizeof(u32.shmid_ds32));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
if (error) {
|
|
|
|
/* Invalidate the return value */
|
|
|
|
td->td_retval[0] = -1;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int
|
|
|
|
freebsd32_shmctl(struct thread *td, struct freebsd32_shmctl_args *uap)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
union {
|
|
|
|
struct shmid_ds shmid_ds;
|
|
|
|
struct shm_info shm_info;
|
|
|
|
struct shminfo shminfo;
|
|
|
|
} u;
|
|
|
|
union {
|
|
|
|
struct shmid_ds32 shmid_ds32;
|
|
|
|
struct shm_info32 shm_info32;
|
|
|
|
struct shminfo32 shminfo32;
|
|
|
|
} u32;
|
|
|
|
size_t sz;
|
|
|
|
|
|
|
|
if (uap->cmd == IPC_SET) {
|
|
|
|
if ((error = copyin(uap->buf, &u32.shmid_ds32,
|
|
|
|
sizeof(u32.shmid_ds32))))
|
|
|
|
goto done;
|
|
|
|
freebsd32_ipcperm_in(&u32.shmid_ds32.shm_perm,
|
|
|
|
&u.shmid_ds.shm_perm);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
|
|
|
|
CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Cases in which we need to copyout */
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case IPC_INFO:
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmax);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmin);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmmni);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmseg);
|
|
|
|
CP(u.shminfo, u32.shminfo32, shmall);
|
|
|
|
error = copyout(&u32.shminfo32, uap->buf,
|
|
|
|
sizeof(u32.shminfo32));
|
|
|
|
break;
|
|
|
|
case SHM_INFO:
|
|
|
|
CP(u.shm_info, u32.shm_info32, used_ids);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_rss);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_tot);
|
|
|
|
CP(u.shm_info, u32.shm_info32, shm_swp);
|
|
|
|
CP(u.shm_info, u32.shm_info32, swap_attempts);
|
|
|
|
CP(u.shm_info, u32.shm_info32, swap_successes);
|
|
|
|
error = copyout(&u32.shm_info32, uap->buf,
|
|
|
|
sizeof(u32.shm_info32));
|
|
|
|
break;
|
|
|
|
case SHM_STAT:
|
|
|
|
case IPC_STAT:
|
|
|
|
freebsd32_ipcperm_out(&u.shmid_ds.shm_perm,
|
|
|
|
&u32.shmid_ds32.shm_perm);
|
|
|
|
if (u.shmid_ds.shm_segsz > INT32_MAX)
|
|
|
|
u32.shmid_ds32.shm_segsz = INT32_MAX;
|
|
|
|
else
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
|
|
|
|
CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
|
|
|
|
error = copyout(&u32.shmid_ds32, uap->buf,
|
|
|
|
sizeof(u32.shmid_ds32));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
if (error) {
|
|
|
|
/* Invalidate the return value */
|
|
|
|
td->td_retval[0] = -1;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
|
|
|
|
defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
|
|
|
|
|
|
|
|
#ifndef CP
|
|
|
|
#define CP(src, dst, fld) do { (dst).fld = (src).fld; } while (0)
|
|
|
|
#endif
|
2009-06-24 21:10:52 +00:00
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct freebsd7_shmctl_args {
|
|
|
|
int shmid;
|
|
|
|
int cmd;
|
|
|
|
struct shmid_ds_old *buf;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
freebsd7_shmctl(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct freebsd7_shmctl_args *uap;
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct shmid_ds_old old;
|
|
|
|
struct shmid_ds buf;
|
|
|
|
size_t bufsz;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
|
|
|
|
* Linux binaries. If we see the call come through the FreeBSD ABI,
|
|
|
|
* return an error back to the user since we do not to support this.
|
|
|
|
*/
|
|
|
|
if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
|
|
|
|
uap->cmd == SHM_STAT)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
/* IPC_SET needs to copyin the buffer before calling kern_shmctl */
|
|
|
|
if (uap->cmd == IPC_SET) {
|
|
|
|
if ((error = copyin(uap->buf, &old, sizeof(old))))
|
|
|
|
goto done;
|
|
|
|
ipcperm_old2new(&old.shm_perm, &buf.shm_perm);
|
|
|
|
CP(old, buf, shm_segsz);
|
|
|
|
CP(old, buf, shm_lpid);
|
|
|
|
CP(old, buf, shm_cpid);
|
|
|
|
CP(old, buf, shm_nattch);
|
|
|
|
CP(old, buf, shm_atime);
|
|
|
|
CP(old, buf, shm_dtime);
|
|
|
|
CP(old, buf, shm_ctime);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Cases in which we need to copyout */
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case IPC_STAT:
|
|
|
|
ipcperm_new2old(&buf.shm_perm, &old.shm_perm);
|
|
|
|
if (buf.shm_segsz > INT_MAX)
|
|
|
|
old.shm_segsz = INT_MAX;
|
|
|
|
else
|
|
|
|
CP(buf, old, shm_segsz);
|
|
|
|
CP(buf, old, shm_lpid);
|
|
|
|
CP(buf, old, shm_cpid);
|
|
|
|
if (buf.shm_nattch > SHRT_MAX)
|
|
|
|
old.shm_nattch = SHRT_MAX;
|
|
|
|
else
|
|
|
|
CP(buf, old, shm_nattch);
|
|
|
|
CP(buf, old, shm_atime);
|
|
|
|
CP(buf, old, shm_dtime);
|
|
|
|
CP(buf, old, shm_ctime);
|
|
|
|
old.shm_internal = NULL;
|
|
|
|
error = copyout(&old, uap->buf, sizeof(old));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
if (error) {
|
|
|
|
/* Invalidate the return value */
|
|
|
|
td->td_retval[0] = -1;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* COMPAT_FREEBSD4 || COMPAT_FREEBSD5 || COMPAT_FREEBSD6 ||
|
|
|
|
COMPAT_FREEBSD7 */
|
|
|
|
|
2000-12-01 08:57:47 +00:00
|
|
|
static int
|
|
|
|
sysvshm_modload(struct module *module, int cmd, void *arg)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case MOD_LOAD:
|
2010-03-19 11:04:42 +00:00
|
|
|
error = shminit();
|
|
|
|
if (error != 0)
|
|
|
|
shmunload();
|
2000-12-01 08:57:47 +00:00
|
|
|
break;
|
|
|
|
case MOD_UNLOAD:
|
|
|
|
error = shmunload();
|
|
|
|
break;
|
|
|
|
case MOD_SHUTDOWN:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (error);
|
1994-09-13 14:47:38 +00:00
|
|
|
}
|
2000-12-01 08:57:47 +00:00
|
|
|
|
2001-01-14 18:04:30 +00:00
|
|
|
static moduledata_t sysvshm_mod = {
|
|
|
|
"sysvshm",
|
2000-12-01 08:57:47 +00:00
|
|
|
&sysvshm_modload,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-06-24 13:35:38 +00:00
|
|
|
DECLARE_MODULE(sysvshm, sysvshm_mod, SI_SUB_SYSV_SHM, SI_ORDER_FIRST);
|
2001-01-14 18:04:30 +00:00
|
|
|
MODULE_VERSION(sysvshm, 1);
|