sys/emulation/svr4/svr4_ipc.c

   1 /*
   2  * $FreeBSD: src/sys/svr4/svr4_ipc.c,v 1.5 1999/12/08 10:51:16 newton Exp $
   3  * $DragonFly: src/sys/emulation/svr4/Attic/svr4_ipc.c,v 1.2 2003/06/17 04:28:57 dillon Exp $
   4  *      Derived from:
   5  *      $NetBSD: svr4_ipc.c,v 1.7 1998/10/19 22:43:00 tron Exp $        */
   6
   7 /*-
   8  * Original copyright:
   9  *
  10  * Copyright (c) 1995 The NetBSD Foundation, Inc.
  11  * All rights reserved.
  12  *
  13  * This code is derived from software contributed to The NetBSD Foundation
  14  * by Christos Zoulas.
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  * 3. All advertising materials mentioning features or use of this software
  25  *    must display the following acknowledgement:
  26  *        This product includes software developed by the NetBSD
  27  *        Foundation, Inc. and its contributors.
  28  * 4. Neither the name of The NetBSD Foundation nor the names of its
  29  *    contributors may be used to endorse or promote products derived
  30  *    from this software without specific prior written permission.
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  33  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  34  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  35  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  36  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  37  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  38  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  39  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  40  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGE.
  43  */
  44
  45 /*
  46  * Portions of this code have been derived from software contributed
  47  * to the FreeBSD Project by Mark Newton.
  48  *
  49  * Copyright (c) 1999 Mark Newton
  50  * All rights reserved.
  51  *
  52  * Redistribution and use in source and binary forms, with or without
  53  * modification, are permitted provided that the following conditions
  54  * are met:
  55  * 1. Redistributions of source code must retain the above copyright
  56  *    notice, this list of conditions and the following disclaimer.
  57  * 2. Redistributions in binary form must reproduce the above copyright
  58  *    notice, this list of conditions and the following disclaimer in the
  59  *    documentation and/or other materials provided with the distribution.
  60  * 3. The name of the author may not be used to endorse or promote products
  61  *    derived from this software without specific prior written permission
  62  *
  63  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  64  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  65  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  66  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  67  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  68  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  69  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  70  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  71  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  72  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  73  *
  74  * XXX- This code is presently a no-op on FreeBSD (and isn't compiled due
  75  * to preprocessor conditionals).  A nice project for a kernel hacking
  76  * novice might be to MakeItGo, but I have more important fish to fry
  77  * at present.
  78  *
  79  */
  80
  81 #include <sys/types.h>
  82 #include <sys/param.h>
  83 #include <sys/kernel.h>
  84 #include <sys/proc.h>
  85 #include <sys/time.h>
  86
  87 #include <svr4/svr4.h>
  88 #include <svr4/svr4_types.h>
  89 #include <svr4/svr4_signal.h>
  90 #include <svr4/svr4_proto.h>
  91 #include <svr4/svr4_util.h>
  92 #include <svr4/svr4_ipc.h>
  93
  94 #if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
  95 static void svr4_to_bsd_ipc_perm __P((const struct svr4_ipc_perm *,
  96                                       struct ipc_perm *));
  97 static void bsd_to_svr4_ipc_perm __P((const struct ipc_perm *,
  98                                       struct svr4_ipc_perm *));
  99 #endif
 100
 101 #ifdef SYSVSEM
 102 static void bsd_to_svr4_semid_ds __P((const struct semid_ds *,
 103                                       struct svr4_semid_ds *));
 104 static void svr4_to_bsd_semid_ds __P((const struct svr4_semid_ds *,
 105                                       struct semid_ds *));
 106 static int svr4_setsemun __P((caddr_t *sgp, union semun **argp,
 107                               union semun *usp));
 108 static int svr4_semop __P((struct proc *, void *, register_t *));
 109 static int svr4_semget __P((struct proc *, void *, register_t *));
 110 static int svr4_semctl __P((struct proc *, void *, register_t *));
 111 #endif
 112
 113 #ifdef SYSVMSG
 114 static void bsd_to_svr4_msqid_ds __P((const struct msqid_ds *,
 115                                       struct svr4_msqid_ds *));
 116 static void svr4_to_bsd_msqid_ds __P((const struct svr4_msqid_ds *,
 117                                       struct msqid_ds *));
 118 static int svr4_msgsnd __P((struct proc *, void *, register_t *));
 119 static int svr4_msgrcv __P((struct proc *, void *, register_t *));
 120 static int svr4_msgget __P((struct proc *, void *, register_t *));
 121 static int svr4_msgctl __P((struct proc *, void *, register_t *));
 122 #endif
 123
 124 #ifdef SYSVSHM
 125 static void bsd_to_svr4_shmid_ds __P((const struct shmid_ds *,
 126                                       struct svr4_shmid_ds *));
 127 static void svr4_to_bsd_shmid_ds __P((const struct svr4_shmid_ds *,
 128                                       struct shmid_ds *));
 129 static int svr4_shmat __P((struct proc *, void *, register_t *));
 130 static int svr4_shmdt __P((struct proc *, void *, register_t *));
 131 static int svr4_shmget __P((struct proc *, void *, register_t *));
 132 static int svr4_shmctl __P((struct proc *, void *, register_t *));
 133 #endif
 134
 135 #if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
 136
 137 static void
 138 svr4_to_bsd_ipc_perm(spp, bpp)
 139         const struct svr4_ipc_perm *spp;
 140         struct ipc_perm *bpp;
 141 {
 142         bpp->key = spp->key;
 143         bpp->uid = spp->uid;
 144         bpp->gid = spp->gid;
 145         bpp->cuid = spp->cuid;
 146         bpp->cgid = spp->cgid;
 147         bpp->mode = spp->mode;
 148         bpp->seq = spp->seq;
 149 }
 150
 151 static void
 152 bsd_to_svr4_ipc_perm(bpp, spp)
 153         const struct ipc_perm *bpp;
 154         struct svr4_ipc_perm *spp;
 155 {
 156         spp->key = bpp->key;
 157         spp->uid = bpp->uid;
 158         spp->gid = bpp->gid;
 159         spp->cuid = bpp->cuid;
 160         spp->cgid = bpp->cgid;
 161         spp->mode = bpp->mode;
 162         spp->seq = bpp->seq;
 163 }
 164 #endif
 165
 166 #ifdef SYSVSEM
 167 static void
 168 bsd_to_svr4_semid_ds(bds, sds)
 169         const struct semid_ds *bds;
 170         struct svr4_semid_ds *sds;
 171 {
 172         bsd_to_svr4_ipc_perm(&bds->sem_perm, &sds->sem_perm);
 173         sds->sem_base = (struct svr4_sem *) bds->sem_base;
 174         sds->sem_nsems = bds->sem_nsems;
 175         sds->sem_otime = bds->sem_otime;
 176         sds->sem_pad1 = bds->sem_pad1;
 177         sds->sem_ctime = bds->sem_ctime;
 178         sds->sem_pad2 = bds->sem_pad2;
 179 }
 180
 181 static void
 182 svr4_to_bsd_semid_ds(sds, bds)
 183         const struct svr4_semid_ds *sds;
 184         struct semid_ds *bds;
 185 {
 186         svr4_to_bsd_ipc_perm(&sds->sem_perm, &bds->sem_perm);
 187         bds->sem_base = (struct sem *) bds->sem_base;
 188         bds->sem_nsems = sds->sem_nsems;
 189         bds->sem_otime = sds->sem_otime;
 190         bds->sem_pad1 = sds->sem_pad1;
 191         bds->sem_ctime = sds->sem_ctime;
 192         bds->sem_pad2 = sds->sem_pad2;
 193 }
 194
 195 static int
 196 svr4_setsemun(sgp, argp, usp)
 197         caddr_t *sgp;
 198         union semun **argp;
 199         union semun *usp;
 200 {
 201         *argp = stackgap_alloc(sgp, sizeof(union semun));
 202         return copyout((caddr_t)usp, *argp, sizeof(union semun));
 203 }
 204
 205 struct svr4_sys_semctl_args {
 206         syscallarg(int) what;
 207         syscallarg(int) semid;
 208         syscallarg(int) semnum;
 209         syscallarg(int) cmd;
 210         syscallarg(union semun) arg;
 211 };
 212
 213 static int
 214 svr4_semctl(p, v, retval)
 215         struct proc *p;
 216         void *v;
 217         register_t *retval;
 218 {
 219         int error;
 220         struct svr4_sys_semctl_args *uap = v;
 221         struct sys___semctl_args ap;
 222         struct svr4_semid_ds ss;
 223         struct semid_ds bs, *bsp;
 224         caddr_t sg = stackgap_init(p->p_emul);
 225
 226         SCARG(&ap, semid) = SCARG(uap, semid);
 227         SCARG(&ap, semnum) = SCARG(uap, semnum);
 228
 229         switch (SCARG(uap, cmd)) {
 230         case SVR4_SEM_GETZCNT:
 231         case SVR4_SEM_GETNCNT:
 232         case SVR4_SEM_GETPID:
 233         case SVR4_SEM_GETVAL:
 234                 switch (SCARG(uap, cmd)) {
 235                 case SVR4_SEM_GETZCNT:
 236                         SCARG(&ap, cmd) = GETZCNT;
 237                         break;
 238                 case SVR4_SEM_GETNCNT:
 239                         SCARG(&ap, cmd) = GETNCNT;
 240                         break;
 241                 case SVR4_SEM_GETPID:
 242                         SCARG(&ap, cmd) = GETPID;
 243                         break;
 244                 case SVR4_SEM_GETVAL:
 245                         SCARG(&ap, cmd) = GETVAL;
 246                         break;
 247                 }
 248                 return sys___semctl(p, &ap, retval);
 249
 250         case SVR4_SEM_SETVAL:
 251                 error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
 252                 if (error)
 253                         return error;
 254                 SCARG(&ap, cmd) = SETVAL;
 255                 return sys___semctl(p, &ap, retval);
 256
 257         case SVR4_SEM_GETALL:
 258                 error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
 259                 if (error)
 260                         return error;
 261                 SCARG(&ap, cmd) = GETVAL;
 262                 return sys___semctl(p, &ap, retval);
 263
 264         case SVR4_SEM_SETALL:
 265                 error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
 266                 if (error)
 267                         return error;
 268                 SCARG(&ap, cmd) = SETVAL;
 269                 return sys___semctl(p, &ap, retval);
 270
 271         case SVR4_IPC_STAT:
 272                 SCARG(&ap, cmd) = IPC_STAT;
 273                 bsp = stackgap_alloc(&sg, sizeof(bs));
 274                 error = svr4_setsemun(&sg, &SCARG(&ap, arg),
 275                                       (union semun *)&bsp);
 276                 if (error)
 277                         return error;
 278                 if ((error = sys___semctl(p, &ap, retval)) != 0)
 279                         return error;
 280                 error = copyin((caddr_t)bsp, (caddr_t)&bs, sizeof(bs));
 281                 if (error)
 282                         return error;
 283                 bsd_to_svr4_semid_ds(&bs, &ss);
 284                 return copyout(&ss, SCARG(uap, arg).buf, sizeof(ss));
 285
 286         case SVR4_IPC_SET:
 287                 SCARG(&ap, cmd) = IPC_SET;
 288                 bsp = stackgap_alloc(&sg, sizeof(bs));
 289                 error = svr4_setsemun(&sg, &SCARG(&ap, arg),
 290                                       (union semun *)&bsp);
 291                 if (error)
 292                         return error;
 293                 error = copyin(SCARG(uap, arg).buf, (caddr_t) &ss, sizeof ss);
 294                 if (error)
 295                         return error;
 296                 svr4_to_bsd_semid_ds(&ss, &bs);
 297                 error = copyout(&bs, bsp, sizeof(bs));
 298                 if (error)
 299                         return error;
 300                 return sys___semctl(p, &ap, retval);
 301
 302         case SVR4_IPC_RMID:
 303                 SCARG(&ap, cmd) = IPC_RMID;
 304                 bsp = stackgap_alloc(&sg, sizeof(bs));
 305                 error = svr4_setsemun(&sg, &SCARG(&ap, arg),
 306                                       (union semun *)&bsp);
 307                 if (error)
 308                         return error;
 309                 error = copyin(SCARG(uap, arg).buf, &ss, sizeof ss);
 310                 if (error)
 311                         return error;
 312                 svr4_to_bsd_semid_ds(&ss, &bs);
 313                 error = copyout(&bs, bsp, sizeof(bs));
 314                 if (error)
 315                         return error;
 316                 return sys___semctl(p, &ap, retval);
 317
 318         default:
 319                 return EINVAL;
 320         }
 321 }
 322
 323 struct svr4_sys_semget_args {
 324         syscallarg(int) what;
 325         syscallarg(svr4_key_t) key;
 326         syscallarg(int) nsems;
 327         syscallarg(int) semflg;
 328 };
 329
 330 static int
 331 svr4_semget(p, v, retval)
 332         struct proc *p;
 333         void *v;
 334         register_t *retval;
 335 {
 336         struct svr4_sys_semget_args *uap = v;
 337         struct sys_semget_args ap;
 338
 339         SCARG(&ap, key) = SCARG(uap, key);
 340         SCARG(&ap, nsems) = SCARG(uap, nsems);
 341         SCARG(&ap, semflg) = SCARG(uap, semflg);
 342
 343         return sys_semget(p, &ap, retval);
 344 }
 345
 346 struct svr4_sys_semop_args {
 347         syscallarg(int) what;
 348         syscallarg(int) semid;
 349         syscallarg(struct svr4_sembuf *) sops;
 350         syscallarg(u_int) nsops;
 351 };
 352
 353 static int
 354 svr4_semop(p, v, retval)
 355         struct proc *p;
 356         void *v;
 357         register_t *retval;
 358 {
 359         struct svr4_sys_semop_args *uap = v;
 360         struct sys_semop_args ap;
 361
 362         SCARG(&ap, semid) = SCARG(uap, semid);
 363         /* These are the same */
 364         SCARG(&ap, sops) = (struct sembuf *) SCARG(uap, sops);
 365         SCARG(&ap, nsops) = SCARG(uap, nsops);
 366
 367         return sys_semop(p, &ap, retval);
 368 }
 369
 370 int
 371 svr4_sys_semsys(p, v, retval)
 372         struct proc *p;
 373         void *v;
 374         register_t *retval;
 375 {
 376         struct svr4_sys_semsys_args *uap = v;
 377
 378         DPRINTF(("svr4_semsys(%d)\n", SCARG(uap, what)));
 379
 380         switch (SCARG(uap, what)) {
 381         case SVR4_semctl:
 382                 return svr4_semctl(p, v, retval);
 383         case SVR4_semget:
 384                 return svr4_semget(p, v, retval);
 385         case SVR4_semop:
 386                 return svr4_semop(p, v, retval);
 387         default:
 388                 return EINVAL;
 389         }
 390 }
 391 #endif
 392
 393 #ifdef SYSVMSG
 394 static void
 395 bsd_to_svr4_msqid_ds(bds, sds)
 396         const struct msqid_ds *bds;
 397         struct svr4_msqid_ds *sds;
 398 {
 399         bsd_to_svr4_ipc_perm(&bds->msg_perm, &sds->msg_perm);
 400         sds->msg_first = (struct svr4_msg *) bds->msg_first;
 401         sds->msg_last = (struct svr4_msg *) bds->msg_last;
 402         sds->msg_cbytes = bds->msg_cbytes;
 403         sds->msg_qnum = bds->msg_qnum;
 404         sds->msg_qbytes = bds->msg_qbytes;
 405         sds->msg_lspid = bds->msg_lspid;
 406         sds->msg_lrpid = bds->msg_lrpid;
 407         sds->msg_stime = bds->msg_stime;
 408         sds->msg_pad1 = bds->msg_pad1;
 409         sds->msg_rtime = bds->msg_rtime;
 410         sds->msg_pad2 = bds->msg_pad2;
 411         sds->msg_ctime = bds->msg_ctime;
 412         sds->msg_pad3 = bds->msg_pad3;
 413
 414         /* use the padding for the rest of the fields */
 415         {
 416                 const short *pad = (const short *) bds->msg_pad4;
 417                 sds->msg_cv = pad[0];
 418                 sds->msg_qnum_cv = pad[1];
 419         }
 420 }
 421
 422 static void
 423 svr4_to_bsd_msqid_ds(sds, bds)
 424         const struct svr4_msqid_ds *sds;
 425         struct msqid_ds *bds;
 426 {
 427         svr4_to_bsd_ipc_perm(&sds->msg_perm, &bds->msg_perm);
 428         bds->msg_first = (struct msg *) sds->msg_first;
 429         bds->msg_last = (struct msg *) sds->msg_last;
 430         bds->msg_cbytes = sds->msg_cbytes;
 431         bds->msg_qnum = sds->msg_qnum;
 432         bds->msg_qbytes = sds->msg_qbytes;
 433         bds->msg_lspid = sds->msg_lspid;
 434         bds->msg_lrpid = sds->msg_lrpid;
 435         bds->msg_stime = sds->msg_stime;
 436         bds->msg_pad1 = sds->msg_pad1;
 437         bds->msg_rtime = sds->msg_rtime;
 438         bds->msg_pad2 = sds->msg_pad2;
 439         bds->msg_ctime = sds->msg_ctime;
 440         bds->msg_pad3 = sds->msg_pad3;
 441
 442         /* use the padding for the rest of the fields */
 443         {
 444                 short *pad = (short *) bds->msg_pad4;
 445                 pad[0] = sds->msg_cv;
 446                 pad[1] = sds->msg_qnum_cv;
 447         }
 448 }
 449
 450 struct svr4_sys_msgsnd_args {
 451         syscallarg(int) what;
 452         syscallarg(int) msqid;
 453         syscallarg(void *) msgp;
 454         syscallarg(size_t) msgsz;
 455         syscallarg(int) msgflg;
 456 };
 457
 458 static int
 459 svr4_msgsnd(p, v, retval)
 460         struct proc *p;
 461         void *v;
 462         register_t *retval;
 463 {
 464         struct svr4_sys_msgsnd_args *uap = v;
 465         struct sys_msgsnd_args ap;
 466
 467         SCARG(&ap, msqid) = SCARG(uap, msqid);
 468         SCARG(&ap, msgp) = SCARG(uap, msgp);
 469         SCARG(&ap, msgsz) = SCARG(uap, msgsz);
 470         SCARG(&ap, msgflg) = SCARG(uap, msgflg);
 471
 472         return sys_msgsnd(p, &ap, retval);
 473 }
 474
 475 struct svr4_sys_msgrcv_args {
 476         syscallarg(int) what;
 477         syscallarg(int) msqid;
 478         syscallarg(void *) msgp;
 479         syscallarg(size_t) msgsz;
 480         syscallarg(long) msgtyp;
 481         syscallarg(int) msgflg;
 482 };
 483
 484 static int
 485 svr4_msgrcv(p, v, retval)
 486         struct proc *p;
 487         void *v;
 488         register_t *retval;
 489 {
 490         struct svr4_sys_msgrcv_args *uap = v;
 491         struct sys_msgrcv_args ap;
 492
 493         SCARG(&ap, msqid) = SCARG(uap, msqid);
 494         SCARG(&ap, msgp) = SCARG(uap, msgp);
 495         SCARG(&ap, msgsz) = SCARG(uap, msgsz);
 496         SCARG(&ap, msgtyp) = SCARG(uap, msgtyp);
 497         SCARG(&ap, msgflg) = SCARG(uap, msgflg);
 498
 499         return sys_msgrcv(p, &ap, retval);
 500 }
 501
 502 struct svr4_sys_msgget_args {
 503         syscallarg(int) what;
 504         syscallarg(svr4_key_t) key;
 505         syscallarg(int) msgflg;
 506 };
 507
 508 static int
 509 svr4_msgget(p, v, retval)
 510         struct proc *p;
 511         void *v;
 512         register_t *retval;
 513 {
 514         struct svr4_sys_msgget_args *uap = v;
 515         struct sys_msgget_args ap;
 516
 517         SCARG(&ap, key) = SCARG(uap, key);
 518         SCARG(&ap, msgflg) = SCARG(uap, msgflg);
 519
 520         return sys_msgget(p, &ap, retval);
 521 }
 522
 523 struct svr4_sys_msgctl_args {
 524         syscallarg(int) what;
 525         syscallarg(int) msqid;
 526         syscallarg(int) cmd;
 527         syscallarg(struct svr4_msqid_ds *) buf;
 528 };
 529
 530 static int
 531 svr4_msgctl(p, v, retval)
 532         struct proc *p;
 533         void *v;
 534         register_t *retval;
 535 {
 536         int error;
 537         struct svr4_sys_msgctl_args *uap = v;
 538         struct sys_msgctl_args ap;
 539         struct svr4_msqid_ds ss;
 540         struct msqid_ds bs;
 541         caddr_t sg = stackgap_init(p->p_emul);
 542
 543         SCARG(&ap, msqid) = SCARG(uap, msqid);
 544         SCARG(&ap, cmd) = SCARG(uap, cmd);
 545         SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof(bs));
 546
 547         switch (SCARG(uap, cmd)) {
 548         case SVR4_IPC_STAT:
 549                 SCARG(&ap, cmd) = IPC_STAT;
 550                 if ((error = sys_msgctl(p, &ap, retval)) != 0)
 551                         return error;
 552                 error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
 553                 if (error)
 554                         return error;
 555                 bsd_to_svr4_msqid_ds(&bs, &ss);
 556                 return copyout(&ss, SCARG(uap, buf), sizeof ss);
 557
 558         case SVR4_IPC_SET:
 559                 SCARG(&ap, cmd) = IPC_SET;
 560                 error = copyin(SCARG(uap, buf), &ss, sizeof ss);
 561                 if (error)
 562                         return error;
 563                 svr4_to_bsd_msqid_ds(&ss, &bs);
 564                 error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
 565                 if (error)
 566                         return error;
 567                 return sys_msgctl(p, &ap, retval);
 568
 569         case SVR4_IPC_RMID:
 570                 SCARG(&ap, cmd) = IPC_RMID;
 571                 error = copyin(SCARG(uap, buf), &ss, sizeof ss);
 572                 if (error)
 573                         return error;
 574                 svr4_to_bsd_msqid_ds(&ss, &bs);
 575                 error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
 576                 if (error)
 577                         return error;
 578                 return sys_msgctl(p, &ap, retval);
 579
 580         default:
 581                 return EINVAL;
 582         }
 583 }
 584
 585 int
 586 svr4_sys_msgsys(p, v, retval)
 587         struct proc *p;
 588         void *v;
 589         register_t *retval;
 590 {
 591         struct svr4_sys_msgsys_args *uap = v;
 592
 593         DPRINTF(("svr4_msgsys(%d)\n", SCARG(uap, what)));
 594
 595         switch (SCARG(uap, what)) {
 596         case SVR4_msgsnd:
 597                 return svr4_msgsnd(p, v, retval);
 598         case SVR4_msgrcv:
 599                 return svr4_msgrcv(p, v, retval);
 600         case SVR4_msgget:
 601                 return svr4_msgget(p, v, retval);
 602         case SVR4_msgctl:
 603                 return svr4_msgctl(p, v, retval);
 604         default:
 605                 return EINVAL;
 606         }
 607 }
 608 #endif
 609
 610 #ifdef SYSVSHM
 611
 612 static void
 613 bsd_to_svr4_shmid_ds(bds, sds)
 614         const struct shmid_ds *bds;
 615         struct svr4_shmid_ds *sds;
 616 {
 617         bsd_to_svr4_ipc_perm(&bds->shm_perm, &sds->shm_perm);
 618         sds->shm_segsz = bds->shm_segsz;
 619         sds->shm_lkcnt = 0;
 620         sds->shm_lpid = bds->shm_lpid;
 621         sds->shm_cpid = bds->shm_cpid;
 622         sds->shm_amp = bds->shm_internal;
 623         sds->shm_nattch = bds->shm_nattch;
 624         sds->shm_cnattch = 0;
 625         sds->shm_atime = bds->shm_atime;
 626         sds->shm_pad1 = 0;
 627         sds->shm_dtime = bds->shm_dtime;
 628         sds->shm_pad2 = 0;
 629         sds->shm_ctime = bds->shm_ctime;
 630         sds->shm_pad3 = 0;
 631 }
 632
 633 static void
 634 svr4_to_bsd_shmid_ds(sds, bds)
 635         const struct svr4_shmid_ds *sds;
 636         struct shmid_ds *bds;
 637 {
 638         svr4_to_bsd_ipc_perm(&sds->shm_perm, &bds->shm_perm);
 639         bds->shm_segsz = sds->shm_segsz;
 640         bds->shm_lpid = sds->shm_lpid;
 641         bds->shm_cpid = sds->shm_cpid;
 642         bds->shm_internal = sds->shm_amp;
 643         bds->shm_nattch = sds->shm_nattch;
 644         bds->shm_atime = sds->shm_atime;
 645         bds->shm_dtime = sds->shm_dtime;
 646         bds->shm_ctime = sds->shm_ctime;
 647 }
 648
 649 struct svr4_sys_shmat_args {
 650         syscallarg(int) what;
 651         syscallarg(int) shmid;
 652         syscallarg(void *) shmaddr;
 653         syscallarg(int) shmflg;
 654 };
 655
 656 static int
 657 svr4_shmat(p, v, retval)
 658         struct proc *p;
 659         void *v;
 660         register_t *retval;
 661 {
 662         struct svr4_sys_shmat_args *uap = v;
 663         struct sys_shmat_args ap;
 664
 665         SCARG(&ap, shmid) = SCARG(uap, shmid);
 666         SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
 667         SCARG(&ap, shmflg) = SCARG(uap, shmflg);
 668
 669         return sys_shmat(p, &ap, retval);
 670 }
 671
 672 struct svr4_sys_shmdt_args {
 673         syscallarg(int) what;
 674         syscallarg(void *) shmaddr;
 675 };
 676
 677 static int
 678 svr4_shmdt(p, v, retval)
 679         struct proc *p;
 680         void *v;
 681         register_t *retval;
 682 {
 683         struct svr4_sys_shmdt_args *uap = v;
 684         struct sys_shmdt_args ap;
 685
 686         SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
 687
 688         return sys_shmdt(p, &ap, retval);
 689 }
 690
 691 struct svr4_sys_shmget_args {
 692         syscallarg(int) what;
 693         syscallarg(key_t) key;
 694         syscallarg(int) size;
 695         syscallarg(int) shmflg;
 696 };
 697
 698 static int
 699 svr4_shmget(p, v, retval)
 700         struct proc *p;
 701         void *v;
 702         register_t *retval;
 703 {
 704         struct svr4_sys_shmget_args *uap = v;
 705         struct sys_shmget_args ap;
 706
 707         SCARG(&ap, key) = SCARG(uap, key);
 708         SCARG(&ap, size) = SCARG(uap, size);
 709         SCARG(&ap, shmflg) = SCARG(uap, shmflg);
 710
 711         return sys_shmget(p, &ap, retval);
 712 }
 713
 714 struct svr4_sys_shmctl_args {
 715         syscallarg(int) what;
 716         syscallarg(int) shmid;
 717         syscallarg(int) cmd;
 718         syscallarg(struct svr4_shmid_ds *) buf;
 719 };
 720
 721 int
 722 svr4_shmctl(p, v, retval)
 723         struct proc *p;
 724         void *v;
 725         register_t *retval;
 726 {
 727         struct svr4_sys_shmctl_args *uap = v;
 728         int error;
 729         caddr_t sg = stackgap_init(p->p_emul);
 730         struct sys_shmctl_args ap;
 731         struct shmid_ds bs;
 732         struct svr4_shmid_ds ss;
 733
 734         SCARG(&ap, shmid) = SCARG(uap, shmid);
 735
 736         if (SCARG(uap, buf) != NULL) {
 737                 SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof (struct shmid_ds));
 738                 switch (SCARG(uap, cmd)) {
 739                 case SVR4_IPC_SET:
 740                 case SVR4_IPC_RMID:
 741                 case SVR4_SHM_LOCK:
 742                 case SVR4_SHM_UNLOCK:
 743                         error = copyin(SCARG(uap, buf), (caddr_t) &ss,
 744                             sizeof ss);
 745                         if (error)
 746                                 return error;
 747                         svr4_to_bsd_shmid_ds(&ss, &bs);
 748                         error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
 749                         if (error)
 750                                 return error;
 751                         break;
 752                 default:
 753                         break;
 754                 }
 755         }
 756         else
 757                 SCARG(&ap, buf) = NULL;
 758
 759
 760         switch (SCARG(uap, cmd)) {
 761         case SVR4_IPC_STAT:
 762                 SCARG(&ap, cmd) = IPC_STAT;
 763                 if ((error = sys_shmctl(p, &ap, retval)) != 0)
 764                         return error;
 765                 if (SCARG(uap, buf) == NULL)
 766                         return 0;
 767                 error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
 768                 if (error)
 769                         return error;
 770                 bsd_to_svr4_shmid_ds(&bs, &ss);
 771                 return copyout(&ss, SCARG(uap, buf), sizeof ss);
 772
 773         case SVR4_IPC_SET:
 774                 SCARG(&ap, cmd) = IPC_SET;
 775                 return sys_shmctl(p, &ap, retval);
 776
 777         case SVR4_IPC_RMID:
 778         case SVR4_SHM_LOCK:
 779         case SVR4_SHM_UNLOCK:
 780                 switch (SCARG(uap, cmd)) {
 781                 case SVR4_IPC_RMID:
 782                         SCARG(&ap, cmd) = IPC_RMID;
 783                         break;
 784                 case SVR4_SHM_LOCK:
 785                         SCARG(&ap, cmd) = SHM_LOCK;
 786                         break;
 787                 case SVR4_SHM_UNLOCK:
 788                         SCARG(&ap, cmd) = SHM_UNLOCK;
 789                         break;
 790                 default:
 791                         return EINVAL;
 792                 }
 793                 return sys_shmctl(p, &ap, retval);
 794
 795         default:
 796                 return EINVAL;
 797         }
 798 }
 799
 800 int
 801 svr4_sys_shmsys(p, v, retval)
 802         struct proc *p;
 803         void *v;
 804         register_t *retval;
 805 {
 806         struct svr4_sys_shmsys_args *uap = v;
 807
 808         DPRINTF(("svr4_shmsys(%d)\n", SCARG(uap, what)));
 809
 810         switch (SCARG(uap, what)) {
 811         case SVR4_shmat:
 812                 return svr4_shmat(p, v, retval);
 813         case SVR4_shmdt:
 814                 return svr4_shmdt(p, v, retval);
 815         case SVR4_shmget:
 816                 return svr4_shmget(p, v, retval);
 817         case SVR4_shmctl:
 818                 return svr4_shmctl(p, v, retval);
 819         default:
 820                 return ENOSYS;
 821         }
 822 }
 823 #endif /* SYSVSHM */