143412Snewton/*- 243412Snewton * Copyright (c) 1995 The NetBSD Foundation, Inc. 343412Snewton * All rights reserved. 443412Snewton * 543412Snewton * This code is derived from software contributed to The NetBSD Foundation 643412Snewton * by Christos Zoulas. 743412Snewton * 843412Snewton * Redistribution and use in source and binary forms, with or without 943412Snewton * modification, are permitted provided that the following conditions 1043412Snewton * are met: 1143412Snewton * 1. Redistributions of source code must retain the above copyright 1243412Snewton * notice, this list of conditions and the following disclaimer. 1343412Snewton * 2. Redistributions in binary form must reproduce the above copyright 1443412Snewton * notice, this list of conditions and the following disclaimer in the 1543412Snewton * documentation and/or other materials provided with the distribution. 1643412Snewton * 1743412Snewton * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 1843412Snewton * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 1943412Snewton * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 2043412Snewton * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 2143412Snewton * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2243412Snewton * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2343412Snewton * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2443412Snewton * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2543412Snewton * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2643412Snewton * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 2743412Snewton * POSSIBILITY OF SUCH DAMAGE. 2843412Snewton */ 29139743Simp/*- 3043412Snewton * Portions of this code have been derived from software contributed 3143412Snewton * to the FreeBSD Project by Mark Newton. 3243412Snewton * 3343412Snewton * Copyright (c) 1999 Mark Newton 3443412Snewton * All rights reserved. 3543412Snewton * 3643412Snewton * Redistribution and use in source and binary forms, with or without 3743412Snewton * modification, are permitted provided that the following conditions 3843412Snewton * are met: 3943412Snewton * 1. Redistributions of source code must retain the above copyright 4043412Snewton * notice, this list of conditions and the following disclaimer. 4143412Snewton * 2. Redistributions in binary form must reproduce the above copyright 4243412Snewton * notice, this list of conditions and the following disclaimer in the 4343412Snewton * documentation and/or other materials provided with the distribution. 4443412Snewton * 3. The name of the author may not be used to endorse or promote products 4543412Snewton * derived from this software without specific prior written permission 4643412Snewton * 4743412Snewton * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4843412Snewton * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 4943412Snewton * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 5043412Snewton * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 5143412Snewton * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 5243412Snewton * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 5343412Snewton * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 5443412Snewton * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 5543412Snewton * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 5643412Snewton * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 5743412Snewton * 5843412Snewton * XXX- This code is presently a no-op on FreeBSD (and isn't compiled due 5943412Snewton * to preprocessor conditionals). A nice project for a kernel hacking 6043412Snewton * novice might be to MakeItGo, but I have more important fish to fry 6143412Snewton * at present. 6243412Snewton * 63116174Sobrien * Derived from: $NetBSD: svr4_ipc.c,v 1.7 1998/10/19 22:43:00 tron Exp $ 6443412Snewton */ 6543412Snewton 66116174Sobrien#include <sys/cdefs.h> 67116174Sobrien__FBSDID("$FreeBSD$"); 68116174Sobrien 69147817Sjhb#include "opt_sysvipc.h" 70147817Sjhb 7143412Snewton#include <sys/param.h> 72147817Sjhb#include <sys/ipc.h> 73147817Sjhb#include <sys/msg.h> 7443412Snewton#include <sys/proc.h> 75147817Sjhb#include <sys/sem.h> 76147817Sjhb#include <sys/shm.h> 77147817Sjhb#include <sys/syscallsubr.h> 78147817Sjhb#include <sys/sysproto.h> 79147817Sjhb#include <sys/systm.h> 8043412Snewton#include <sys/time.h> 8143412Snewton 8265302Sobrien#include <compat/svr4/svr4.h> 8365302Sobrien#include <compat/svr4/svr4_types.h> 8465302Sobrien#include <compat/svr4/svr4_signal.h> 8565302Sobrien#include <compat/svr4/svr4_proto.h> 8665302Sobrien#include <compat/svr4/svr4_util.h> 8765302Sobrien#include <compat/svr4/svr4_ipc.h> 8843412Snewton 8992761Salfredstatic void svr4_to_bsd_ipc_perm(const struct svr4_ipc_perm *, 9092761Salfred struct ipc_perm *); 9192761Salfredstatic void bsd_to_svr4_ipc_perm(const struct ipc_perm *, 9292761Salfred struct svr4_ipc_perm *); 9392761Salfredstatic void bsd_to_svr4_semid_ds(const struct semid_ds *, 9492761Salfred struct svr4_semid_ds *); 9592761Salfredstatic void svr4_to_bsd_semid_ds(const struct svr4_semid_ds *, 9692761Salfred struct semid_ds *); 97147817Sjhbstatic int svr4_semop(struct thread *, void *); 98147817Sjhbstatic int svr4_semget(struct thread *, void *); 99147817Sjhbstatic int svr4_semctl(struct thread *, void *); 10092761Salfredstatic void bsd_to_svr4_msqid_ds(const struct msqid_ds *, 10192761Salfred struct svr4_msqid_ds *); 10292761Salfredstatic void svr4_to_bsd_msqid_ds(const struct svr4_msqid_ds *, 10392761Salfred struct msqid_ds *); 104147817Sjhbstatic int svr4_msgsnd(struct thread *, void *); 105147817Sjhbstatic int svr4_msgrcv(struct thread *, void *); 106147817Sjhbstatic int svr4_msgget(struct thread *, void *); 107147817Sjhbstatic int svr4_msgctl(struct thread *, void *); 10892761Salfredstatic void bsd_to_svr4_shmid_ds(const struct shmid_ds *, 10992761Salfred struct svr4_shmid_ds *); 11092761Salfredstatic void svr4_to_bsd_shmid_ds(const struct svr4_shmid_ds *, 11192761Salfred struct shmid_ds *); 112147817Sjhbstatic int svr4_shmat(struct thread *, void *); 113147817Sjhbstatic int svr4_shmdt(struct thread *, void *); 114147817Sjhbstatic int svr4_shmget(struct thread *, void *); 115147817Sjhbstatic int svr4_shmctl(struct thread *, void *); 11643412Snewton 11743412Snewtonstatic void 11843412Snewtonsvr4_to_bsd_ipc_perm(spp, bpp) 11943412Snewton const struct svr4_ipc_perm *spp; 12043412Snewton struct ipc_perm *bpp; 12143412Snewton{ 12243412Snewton bpp->key = spp->key; 12343412Snewton bpp->uid = spp->uid; 12443412Snewton bpp->gid = spp->gid; 12543412Snewton bpp->cuid = spp->cuid; 12643412Snewton bpp->cgid = spp->cgid; 12743412Snewton bpp->mode = spp->mode; 12843412Snewton bpp->seq = spp->seq; 12943412Snewton} 13043412Snewton 13143412Snewtonstatic void 13243412Snewtonbsd_to_svr4_ipc_perm(bpp, spp) 13343412Snewton const struct ipc_perm *bpp; 13443412Snewton struct svr4_ipc_perm *spp; 13543412Snewton{ 13643412Snewton spp->key = bpp->key; 13743412Snewton spp->uid = bpp->uid; 13843412Snewton spp->gid = bpp->gid; 13943412Snewton spp->cuid = bpp->cuid; 14043412Snewton spp->cgid = bpp->cgid; 14143412Snewton spp->mode = bpp->mode; 14243412Snewton spp->seq = bpp->seq; 14343412Snewton} 14443412Snewton 14543412Snewtonstatic void 14643412Snewtonbsd_to_svr4_semid_ds(bds, sds) 14743412Snewton const struct semid_ds *bds; 14843412Snewton struct svr4_semid_ds *sds; 14943412Snewton{ 150194910Sjhb bzero(sds, sizeof(*sds)); 15143412Snewton bsd_to_svr4_ipc_perm(&bds->sem_perm, &sds->sem_perm); 15243412Snewton sds->sem_base = (struct svr4_sem *) bds->sem_base; 15343412Snewton sds->sem_nsems = bds->sem_nsems; 15443412Snewton sds->sem_otime = bds->sem_otime; 15543412Snewton sds->sem_ctime = bds->sem_ctime; 15643412Snewton} 15743412Snewton 15843412Snewtonstatic void 15943412Snewtonsvr4_to_bsd_semid_ds(sds, bds) 16043412Snewton const struct svr4_semid_ds *sds; 16143412Snewton struct semid_ds *bds; 16243412Snewton{ 16343412Snewton svr4_to_bsd_ipc_perm(&sds->sem_perm, &bds->sem_perm); 16443412Snewton bds->sem_base = (struct sem *) bds->sem_base; 16543412Snewton bds->sem_nsems = sds->sem_nsems; 16643412Snewton bds->sem_otime = sds->sem_otime; 16743412Snewton bds->sem_ctime = sds->sem_ctime; 16843412Snewton} 16943412Snewton 17043412Snewtonstruct svr4_sys_semctl_args { 171147817Sjhb int what; 172147817Sjhb int semid; 173147817Sjhb int semnum; 174147817Sjhb int cmd; 175147817Sjhb union semun arg; 17643412Snewton}; 17743412Snewton 17843412Snewtonstatic int 179147817Sjhbsvr4_semctl(td, v) 180147817Sjhb struct thread *td; 18143412Snewton void *v; 18243412Snewton{ 18343412Snewton struct svr4_sys_semctl_args *uap = v; 18443412Snewton struct svr4_semid_ds ss; 185159991Sjhb struct semid_ds bs; 186159991Sjhb union semun semun; 187160187Sjhb register_t rval; 188159991Sjhb int cmd, error; 18943412Snewton 190107849Salfred switch (uap->cmd) { 19143412Snewton case SVR4_SEM_GETZCNT: 192159991Sjhb cmd = GETZCNT; 193159991Sjhb break; 194159991Sjhb 19543412Snewton case SVR4_SEM_GETNCNT: 196159991Sjhb cmd = GETNCNT; 197159991Sjhb break; 198159991Sjhb 19943412Snewton case SVR4_SEM_GETPID: 200159991Sjhb cmd = GETPID; 201159991Sjhb break; 202159991Sjhb 20343412Snewton case SVR4_SEM_GETVAL: 204159991Sjhb cmd = GETVAL; 205159991Sjhb break; 20643412Snewton 20743412Snewton case SVR4_SEM_SETVAL: 208159991Sjhb cmd = SETVAL; 209159991Sjhb break; 21043412Snewton 21143412Snewton case SVR4_SEM_GETALL: 212159991Sjhb cmd = GETVAL; 213159991Sjhb break; 21443412Snewton 21543412Snewton case SVR4_SEM_SETALL: 216159991Sjhb cmd = SETVAL; 217159991Sjhb break; 21843412Snewton 21943412Snewton case SVR4_IPC_STAT: 220159991Sjhb cmd = IPC_STAT; 221159991Sjhb semun.buf = &bs; 222159991Sjhb error = kern_semctl(td, uap->semid, uap->semnum, cmd, &semun, 223160187Sjhb &rval); 22443412Snewton if (error) 225160187Sjhb return (error); 22643412Snewton bsd_to_svr4_semid_ds(&bs, &ss); 227160187Sjhb error = copyout(&ss, uap->arg.buf, sizeof(ss)); 228160187Sjhb if (error == 0) 229160187Sjhb td->td_retval[0] = rval; 230160187Sjhb return (error); 23143412Snewton 23243412Snewton case SVR4_IPC_SET: 233159991Sjhb cmd = IPC_SET; 234107849Salfred error = copyin(uap->arg.buf, (caddr_t) &ss, sizeof ss); 23543412Snewton if (error) 236160187Sjhb return (error); 23743412Snewton svr4_to_bsd_semid_ds(&ss, &bs); 238159991Sjhb semun.buf = &bs; 239160187Sjhb return (kern_semctl(td, uap->semid, uap->semnum, cmd, &semun, 240160187Sjhb td->td_retval)); 24143412Snewton 24243412Snewton case SVR4_IPC_RMID: 243159991Sjhb cmd = IPC_RMID; 244159991Sjhb break; 24543412Snewton 24643412Snewton default: 24743412Snewton return EINVAL; 24843412Snewton } 249159991Sjhb 250160187Sjhb return (kern_semctl(td, uap->semid, uap->semnum, cmd, &uap->arg, 251160187Sjhb td->td_retval)); 25243412Snewton} 25343412Snewton 25443412Snewtonstruct svr4_sys_semget_args { 255147817Sjhb int what; 256147817Sjhb svr4_key_t key; 257147817Sjhb int nsems; 258147817Sjhb int semflg; 25943412Snewton}; 26043412Snewton 26143412Snewtonstatic int 262147817Sjhbsvr4_semget(td, v) 263147817Sjhb struct thread *td; 26443412Snewton void *v; 26543412Snewton{ 26643412Snewton struct svr4_sys_semget_args *uap = v; 267147817Sjhb struct semget_args ap; 26843412Snewton 269107849Salfred ap.key = uap->key; 270107849Salfred ap.nsems = uap->nsems; 271107849Salfred ap.semflg = uap->semflg; 27243412Snewton 273225617Skmacy return sys_semget(td, &ap); 27443412Snewton} 27543412Snewton 27643412Snewtonstruct svr4_sys_semop_args { 277147817Sjhb int what; 278147817Sjhb int semid; 279147817Sjhb struct svr4_sembuf * sops; 280147817Sjhb u_int nsops; 28143412Snewton}; 28243412Snewton 28343412Snewtonstatic int 284147817Sjhbsvr4_semop(td, v) 285147817Sjhb struct thread *td; 28643412Snewton void *v; 28743412Snewton{ 28843412Snewton struct svr4_sys_semop_args *uap = v; 289147817Sjhb struct semop_args ap; 29043412Snewton 291107849Salfred ap.semid = uap->semid; 29243412Snewton /* These are the same */ 293107849Salfred ap.sops = (struct sembuf *) uap->sops; 294107849Salfred ap.nsops = uap->nsops; 29543412Snewton 296225617Skmacy return sys_semop(td, &ap); 29743412Snewton} 29843412Snewton 29943412Snewtonint 300147817Sjhbsvr4_sys_semsys(td, uap) 301147817Sjhb struct thread *td; 302147817Sjhb struct svr4_sys_semsys_args *uap; 30343412Snewton{ 30443412Snewton 305107849Salfred DPRINTF(("svr4_semsys(%d)\n", uap->what)); 30643412Snewton 307107849Salfred switch (uap->what) { 30843412Snewton case SVR4_semctl: 309147817Sjhb return svr4_semctl(td, uap); 31043412Snewton case SVR4_semget: 311147817Sjhb return svr4_semget(td, uap); 31243412Snewton case SVR4_semop: 313147817Sjhb return svr4_semop(td, uap); 31443412Snewton default: 31543412Snewton return EINVAL; 31643412Snewton } 31743412Snewton} 318148541Sjhb 31943412Snewton 32043412Snewtonstatic void 32143412Snewtonbsd_to_svr4_msqid_ds(bds, sds) 32243412Snewton const struct msqid_ds *bds; 32343412Snewton struct svr4_msqid_ds *sds; 32443412Snewton{ 325194910Sjhb bzero(sds, sizeof(*sds)); 32643412Snewton bsd_to_svr4_ipc_perm(&bds->msg_perm, &sds->msg_perm); 32743412Snewton sds->msg_first = (struct svr4_msg *) bds->msg_first; 32843412Snewton sds->msg_last = (struct svr4_msg *) bds->msg_last; 32943412Snewton sds->msg_cbytes = bds->msg_cbytes; 33043412Snewton sds->msg_qnum = bds->msg_qnum; 33143412Snewton sds->msg_qbytes = bds->msg_qbytes; 33243412Snewton sds->msg_lspid = bds->msg_lspid; 33343412Snewton sds->msg_lrpid = bds->msg_lrpid; 33443412Snewton sds->msg_stime = bds->msg_stime; 33543412Snewton sds->msg_rtime = bds->msg_rtime; 33643412Snewton sds->msg_ctime = bds->msg_ctime; 33743412Snewton} 33843412Snewton 33943412Snewtonstatic void 34043412Snewtonsvr4_to_bsd_msqid_ds(sds, bds) 34143412Snewton const struct svr4_msqid_ds *sds; 34243412Snewton struct msqid_ds *bds; 34343412Snewton{ 34443412Snewton svr4_to_bsd_ipc_perm(&sds->msg_perm, &bds->msg_perm); 34543412Snewton bds->msg_first = (struct msg *) sds->msg_first; 34643412Snewton bds->msg_last = (struct msg *) sds->msg_last; 34743412Snewton bds->msg_cbytes = sds->msg_cbytes; 34843412Snewton bds->msg_qnum = sds->msg_qnum; 34943412Snewton bds->msg_qbytes = sds->msg_qbytes; 35043412Snewton bds->msg_lspid = sds->msg_lspid; 35143412Snewton bds->msg_lrpid = sds->msg_lrpid; 35243412Snewton bds->msg_stime = sds->msg_stime; 35343412Snewton bds->msg_rtime = sds->msg_rtime; 35443412Snewton bds->msg_ctime = sds->msg_ctime; 35543412Snewton} 35643412Snewton 35743412Snewtonstruct svr4_sys_msgsnd_args { 358147817Sjhb int what; 359147817Sjhb int msqid; 360147817Sjhb void * msgp; 361147817Sjhb size_t msgsz; 362147817Sjhb int msgflg; 36343412Snewton}; 36443412Snewton 36543412Snewtonstatic int 366147817Sjhbsvr4_msgsnd(td, v) 367147817Sjhb struct thread *td; 36843412Snewton void *v; 36943412Snewton{ 37043412Snewton struct svr4_sys_msgsnd_args *uap = v; 371147817Sjhb struct msgsnd_args ap; 37243412Snewton 373107849Salfred ap.msqid = uap->msqid; 374107849Salfred ap.msgp = uap->msgp; 375107849Salfred ap.msgsz = uap->msgsz; 376107849Salfred ap.msgflg = uap->msgflg; 37743412Snewton 378225617Skmacy return sys_msgsnd(td, &ap); 37943412Snewton} 38043412Snewton 38143412Snewtonstruct svr4_sys_msgrcv_args { 382147817Sjhb int what; 383147817Sjhb int msqid; 384147817Sjhb void * msgp; 385147817Sjhb size_t msgsz; 386147817Sjhb long msgtyp; 387147817Sjhb int msgflg; 38843412Snewton}; 38943412Snewton 39043412Snewtonstatic int 391147817Sjhbsvr4_msgrcv(td, v) 392147817Sjhb struct thread *td; 39343412Snewton void *v; 39443412Snewton{ 39543412Snewton struct svr4_sys_msgrcv_args *uap = v; 396147817Sjhb struct msgrcv_args ap; 39743412Snewton 398107849Salfred ap.msqid = uap->msqid; 399107849Salfred ap.msgp = uap->msgp; 400107849Salfred ap.msgsz = uap->msgsz; 401107849Salfred ap.msgtyp = uap->msgtyp; 402107849Salfred ap.msgflg = uap->msgflg; 40343412Snewton 404225617Skmacy return sys_msgrcv(td, &ap); 40543412Snewton} 406298520Sdchagin 40743412Snewtonstruct svr4_sys_msgget_args { 408147817Sjhb int what; 409147817Sjhb svr4_key_t key; 410147817Sjhb int msgflg; 41143412Snewton}; 41243412Snewton 41343412Snewtonstatic int 414147817Sjhbsvr4_msgget(td, v) 415147817Sjhb struct thread *td; 41643412Snewton void *v; 41743412Snewton{ 41843412Snewton struct svr4_sys_msgget_args *uap = v; 419147817Sjhb struct msgget_args ap; 42043412Snewton 421107849Salfred ap.key = uap->key; 422107849Salfred ap.msgflg = uap->msgflg; 42343412Snewton 424225617Skmacy return sys_msgget(td, &ap); 42543412Snewton} 42643412Snewton 42743412Snewtonstruct svr4_sys_msgctl_args { 428147817Sjhb int what; 429147817Sjhb int msqid; 430147817Sjhb int cmd; 431147817Sjhb struct svr4_msqid_ds * buf; 43243412Snewton}; 43343412Snewton 43443412Snewtonstatic int 435147817Sjhbsvr4_msgctl(td, v) 436147817Sjhb struct thread *td; 43743412Snewton void *v; 43843412Snewton{ 43943412Snewton struct svr4_sys_msgctl_args *uap = v; 44043412Snewton struct svr4_msqid_ds ss; 44143412Snewton struct msqid_ds bs; 442141486Sjhb int error; 44343412Snewton 444107849Salfred switch (uap->cmd) { 44543412Snewton case SVR4_IPC_STAT: 446141486Sjhb error = kern_msgctl(td, uap->msqid, IPC_STAT, &bs); 44743412Snewton if (error) 44843412Snewton return error; 44943412Snewton bsd_to_svr4_msqid_ds(&bs, &ss); 450107849Salfred return copyout(&ss, uap->buf, sizeof ss); 45143412Snewton 45243412Snewton case SVR4_IPC_SET: 453107849Salfred error = copyin(uap->buf, &ss, sizeof ss); 45443412Snewton if (error) 45543412Snewton return error; 45643412Snewton svr4_to_bsd_msqid_ds(&ss, &bs); 457141486Sjhb return (kern_msgctl(td, uap->msqid, IPC_SET, &bs)); 45843412Snewton 45943412Snewton case SVR4_IPC_RMID: 460160141Sjhb return (kern_msgctl(td, uap->msqid, IPC_RMID, NULL)); 46143412Snewton 46243412Snewton default: 46343412Snewton return EINVAL; 46443412Snewton } 46543412Snewton} 46643412Snewton 46743412Snewtonint 468147817Sjhbsvr4_sys_msgsys(td, uap) 469147817Sjhb struct thread *td; 470147817Sjhb struct svr4_sys_msgsys_args *uap; 47143412Snewton{ 47243412Snewton 473107849Salfred DPRINTF(("svr4_msgsys(%d)\n", uap->what)); 47443412Snewton 475107849Salfred switch (uap->what) { 47643412Snewton case SVR4_msgsnd: 477147817Sjhb return svr4_msgsnd(td, uap); 47843412Snewton case SVR4_msgrcv: 479147817Sjhb return svr4_msgrcv(td, uap); 48043412Snewton case SVR4_msgget: 481147817Sjhb return svr4_msgget(td, uap); 48243412Snewton case SVR4_msgctl: 483147817Sjhb return svr4_msgctl(td, uap); 48443412Snewton default: 48543412Snewton return EINVAL; 48643412Snewton } 48743412Snewton} 488148541Sjhb 48943412Snewton 49043412Snewtonstatic void 49143412Snewtonbsd_to_svr4_shmid_ds(bds, sds) 49243412Snewton const struct shmid_ds *bds; 49343412Snewton struct svr4_shmid_ds *sds; 49443412Snewton{ 495194910Sjhb bzero(sds, sizeof(*sds)); 49643412Snewton bsd_to_svr4_ipc_perm(&bds->shm_perm, &sds->shm_perm); 49743412Snewton sds->shm_segsz = bds->shm_segsz; 49843412Snewton sds->shm_lkcnt = 0; 49943412Snewton sds->shm_lpid = bds->shm_lpid; 50043412Snewton sds->shm_cpid = bds->shm_cpid; 501194910Sjhb sds->shm_amp = 0; 50243412Snewton sds->shm_nattch = bds->shm_nattch; 50343412Snewton sds->shm_cnattch = 0; 50443412Snewton sds->shm_atime = bds->shm_atime; 50543412Snewton sds->shm_dtime = bds->shm_dtime; 50643412Snewton sds->shm_ctime = bds->shm_ctime; 50743412Snewton} 50843412Snewton 50943412Snewtonstatic void 51043412Snewtonsvr4_to_bsd_shmid_ds(sds, bds) 51143412Snewton const struct svr4_shmid_ds *sds; 51243412Snewton struct shmid_ds *bds; 51343412Snewton{ 51443412Snewton svr4_to_bsd_ipc_perm(&sds->shm_perm, &bds->shm_perm); 51543412Snewton bds->shm_segsz = sds->shm_segsz; 51643412Snewton bds->shm_lpid = sds->shm_lpid; 51743412Snewton bds->shm_cpid = sds->shm_cpid; 51843412Snewton bds->shm_nattch = sds->shm_nattch; 51943412Snewton bds->shm_atime = sds->shm_atime; 52043412Snewton bds->shm_dtime = sds->shm_dtime; 52143412Snewton bds->shm_ctime = sds->shm_ctime; 52243412Snewton} 52343412Snewton 52443412Snewtonstruct svr4_sys_shmat_args { 525147817Sjhb int what; 526147817Sjhb int shmid; 527147817Sjhb void * shmaddr; 528147817Sjhb int shmflg; 52943412Snewton}; 53043412Snewton 53143412Snewtonstatic int 532147817Sjhbsvr4_shmat(td, v) 533147817Sjhb struct thread *td; 53443412Snewton void *v; 53543412Snewton{ 53643412Snewton struct svr4_sys_shmat_args *uap = v; 537147817Sjhb struct shmat_args ap; 53843412Snewton 539107849Salfred ap.shmid = uap->shmid; 540107849Salfred ap.shmaddr = uap->shmaddr; 541107849Salfred ap.shmflg = uap->shmflg; 54243412Snewton 543225617Skmacy return sys_shmat(td, &ap); 54443412Snewton} 54543412Snewton 54643412Snewtonstruct svr4_sys_shmdt_args { 547147817Sjhb int what; 548147817Sjhb void * shmaddr; 54943412Snewton}; 55043412Snewton 55143412Snewtonstatic int 552147817Sjhbsvr4_shmdt(td, v) 553147817Sjhb struct thread *td; 55443412Snewton void *v; 55543412Snewton{ 55643412Snewton struct svr4_sys_shmdt_args *uap = v; 557147817Sjhb struct shmdt_args ap; 55843412Snewton 559107849Salfred ap.shmaddr = uap->shmaddr; 56043412Snewton 561225617Skmacy return sys_shmdt(td, &ap); 56243412Snewton} 56343412Snewton 56443412Snewtonstruct svr4_sys_shmget_args { 565147817Sjhb int what; 566147817Sjhb key_t key; 567147817Sjhb int size; 568147817Sjhb int shmflg; 56943412Snewton}; 57043412Snewton 57143412Snewtonstatic int 572147817Sjhbsvr4_shmget(td, v) 573147817Sjhb struct thread *td; 57443412Snewton void *v; 57543412Snewton{ 57643412Snewton struct svr4_sys_shmget_args *uap = v; 577147817Sjhb struct shmget_args ap; 57843412Snewton 579107849Salfred ap.key = uap->key; 580107849Salfred ap.size = uap->size; 581107849Salfred ap.shmflg = uap->shmflg; 58243412Snewton 583225617Skmacy return sys_shmget(td, &ap); 58443412Snewton} 58543412Snewton 58643412Snewtonstruct svr4_sys_shmctl_args { 587147817Sjhb int what; 588147817Sjhb int shmid; 589147817Sjhb int cmd; 590147817Sjhb struct svr4_shmid_ds * buf; 59143412Snewton}; 59243412Snewton 59343412Snewtonint 594147817Sjhbsvr4_shmctl(td, v) 595147817Sjhb struct thread *td; 59643412Snewton void *v; 59743412Snewton{ 59843412Snewton struct svr4_sys_shmctl_args *uap = v; 59943412Snewton struct shmid_ds bs; 60043412Snewton struct svr4_shmid_ds ss; 601159993Sjhb size_t bufsize; 602159993Sjhb int cmd, error; 60343412Snewton 604107849Salfred if (uap->buf != NULL) { 605107849Salfred switch (uap->cmd) { 60643412Snewton case SVR4_IPC_SET: 60743412Snewton case SVR4_SHM_LOCK: 60843412Snewton case SVR4_SHM_UNLOCK: 609159993Sjhb error = copyin(uap->buf, &ss, sizeof(ss)); 61043412Snewton if (error) 611159993Sjhb return (error); 61243412Snewton svr4_to_bsd_shmid_ds(&ss, &bs); 61343412Snewton break; 61443412Snewton default: 615159993Sjhb return (EINVAL); 61643412Snewton } 61743412Snewton } 61843412Snewton 619107849Salfred switch (uap->cmd) { 62043412Snewton case SVR4_IPC_STAT: 621159993Sjhb cmd = IPC_STAT; 622159993Sjhb break; 62343412Snewton case SVR4_IPC_SET: 624159993Sjhb cmd = IPC_SET; 625159993Sjhb break; 62643412Snewton case SVR4_IPC_RMID: 627159993Sjhb cmd = IPC_RMID; 628159993Sjhb break; 62943412Snewton case SVR4_SHM_LOCK: 630159993Sjhb cmd = SHM_LOCK; 631159993Sjhb break; 63243412Snewton case SVR4_SHM_UNLOCK: 633159993Sjhb cmd = SHM_UNLOCK; 634159993Sjhb break; 635159993Sjhb default: 636159993Sjhb return (EINVAL); 637159993Sjhb } 638298520Sdchagin 639159993Sjhb error = kern_shmctl(td, uap->shmid, cmd, &bs, &bufsize); 640159993Sjhb if (error) 641159993Sjhb return (error); 642159993Sjhb 643159993Sjhb switch (uap->cmd) { 644159993Sjhb case SVR4_IPC_STAT: 645159993Sjhb if (uap->buf != NULL) { 646159993Sjhb bsd_to_svr4_shmid_ds(&bs, &ss); 647159993Sjhb error = copyout(&ss, uap->buf, sizeof(ss)); 64843412Snewton } 649159993Sjhb break; 650159993Sjhb } 65143412Snewton 652159993Sjhb return (error); 65343412Snewton} 65443412Snewton 65543412Snewtonint 656147817Sjhbsvr4_sys_shmsys(td, uap) 657147817Sjhb struct thread *td; 658147817Sjhb struct svr4_sys_shmsys_args *uap; 65943412Snewton{ 66043412Snewton 661107849Salfred DPRINTF(("svr4_shmsys(%d)\n", uap->what)); 66243412Snewton 663107849Salfred switch (uap->what) { 66443412Snewton case SVR4_shmat: 665147817Sjhb return svr4_shmat(td, uap); 66643412Snewton case SVR4_shmdt: 667147817Sjhb return svr4_shmdt(td, uap); 66843412Snewton case SVR4_shmget: 669147817Sjhb return svr4_shmget(td, uap); 67043412Snewton case SVR4_shmctl: 671147817Sjhb return svr4_shmctl(td, uap); 67243412Snewton default: 67343412Snewton return ENOSYS; 67443412Snewton } 67543412Snewton} 676148541Sjhb 677148541SjhbMODULE_DEPEND(svr4elf, sysvshm, 1, 1, 1); 678298520SdchaginMODULE_DEPEND(svr4elf, sysvmsg, 1, 1, 1); 679298520SdchaginMODULE_DEPEND(svr4elf, sysvsem, 1, 1, 1); 680