sys/i386/ibcs2/ibcs2_ipc.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1995 Scott Bartram
   5  * Copyright (c) 1995 Steven Wallace
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/limits.h>
  34 #include <sys/msg.h>
  35 #include <sys/sem.h>
  36 #include <sys/shm.h>
  37 #include <sys/syscallsubr.h>
  38 #include <sys/sysproto.h>
  39
  40 #include <i386/ibcs2/ibcs2_types.h>
  41 #include <i386/ibcs2/ibcs2_signal.h>
  42 #include <i386/ibcs2/ibcs2_proto.h>
  43 #include <i386/ibcs2/ibcs2_util.h>
  44 #include <i386/ibcs2/ibcs2_ipc.h>
  45
  46 #define IBCS2_IPC_RMID  0
  47 #define IBCS2_IPC_SET   1
  48 #define IBCS2_IPC_STAT  2
  49 #define IBCS2_SETVAL    8
  50
  51
  52
  53 static void cvt_msqid2imsqid(struct msqid_ds *, struct ibcs2_msqid_ds *);
  54 static void cvt_imsqid2msqid(struct ibcs2_msqid_ds *, struct msqid_ds *);
  55 #ifdef unused
  56 static void cvt_sem2isem(struct sem *, struct ibcs2_sem *);
  57 static void cvt_isem2sem(struct ibcs2_sem *, struct sem *);
  58 #endif
  59 static void cvt_semid2isemid(struct semid_ds *, struct ibcs2_semid_ds *);
  60 static void cvt_isemid2semid(struct ibcs2_semid_ds *, struct semid_ds *);
  61 static void cvt_shmid2ishmid(struct shmid_ds *, struct ibcs2_shmid_ds *);
  62 static void cvt_ishmid2shmid(struct ibcs2_shmid_ds *, struct shmid_ds *);
  63 static void cvt_perm2iperm(struct ipc_perm *, struct ibcs2_ipc_perm *);
  64 static void cvt_iperm2perm(struct ibcs2_ipc_perm *, struct ipc_perm *);
  65
  66
  67 /*
  68  * iBCS2 msgsys call
  69  */
  70
  71 static void
  72 cvt_msqid2imsqid(bp, ibp)
  73 struct msqid_ds *bp;
  74 struct ibcs2_msqid_ds *ibp;
  75 {
  76         memset(ibp, 0, sizeof(*ibp));
  77         cvt_perm2iperm(&bp->msg_perm, &ibp->msg_perm);
  78         ibp->msg_cbytes = (u_short)bp->msg_cbytes;
  79         ibp->msg_qnum = (u_short)bp->msg_qnum;
  80         ibp->msg_qbytes = (u_short)bp->msg_qbytes;
  81         ibp->msg_lspid = (u_short)bp->msg_lspid;
  82         ibp->msg_lrpid = (u_short)bp->msg_lrpid;
  83         ibp->msg_stime = bp->msg_stime;
  84         ibp->msg_rtime = bp->msg_rtime;
  85         ibp->msg_ctime = bp->msg_ctime;
  86         return;
  87 }
  88
  89 static void
  90 cvt_imsqid2msqid(ibp, bp)
  91 struct ibcs2_msqid_ds *ibp;
  92 struct msqid_ds *bp;
  93 {
  94         cvt_iperm2perm(&ibp->msg_perm, &bp->msg_perm);
  95         bp->msg_cbytes = ibp->msg_cbytes;
  96         bp->msg_qnum = ibp->msg_qnum;
  97         bp->msg_qbytes = ibp->msg_qbytes;
  98         bp->msg_lspid = ibp->msg_lspid;
  99         bp->msg_lrpid = ibp->msg_lrpid;
 100         bp->msg_stime = ibp->msg_stime;
 101         bp->msg_rtime = ibp->msg_rtime;
 102         bp->msg_ctime = ibp->msg_ctime;
 103         return;
 104 }
 105
 106 struct ibcs2_msgget_args {
 107         int what;
 108         ibcs2_key_t key;
 109         int msgflg;
 110 };
 111
 112 static int
 113 ibcs2_msgget(struct thread *td, void *v)
 114 {
 115         struct ibcs2_msgget_args *uap = v;
 116         struct msgget_args ap;
 117
 118         ap.key = uap->key;
 119         ap.msgflg = uap->msgflg;
 120         return sys_msgget(td, &ap);
 121 }
 122
 123 struct ibcs2_msgctl_args {
 124         int what;
 125         int msqid;
 126         int cmd;
 127         struct ibcs2_msqid_ds *buf;
 128 };
 129
 130 static int
 131 ibcs2_msgctl(struct thread *td, void *v)
 132 {
 133         struct ibcs2_msgctl_args *uap = v;
 134         struct ibcs2_msqid_ds is;
 135         struct msqid_ds bs;
 136         int error;
 137
 138         memset(&is, 0, sizeof(is));
 139
 140         switch (uap->cmd) {
 141         case IBCS2_IPC_STAT:
 142                 error = kern_msgctl(td, uap->msqid, IPC_STAT, &bs);
 143                 if (!error) {
 144                         cvt_msqid2imsqid(&bs, &is);
 145                         error = copyout(&is, uap->buf, sizeof(is));
 146                 }
 147                 return (error);
 148         case IBCS2_IPC_SET:
 149                 error = copyin(uap->buf, &is, sizeof(is));
 150                 if (error)
 151                         return (error);
 152                 cvt_imsqid2msqid(&is, &bs);
 153                 return (kern_msgctl(td, uap->msqid, IPC_SET, &bs));
 154         case IBCS2_IPC_RMID:
 155                 return (kern_msgctl(td, uap->msqid, IPC_RMID, NULL));
 156         }
 157         return (EINVAL);
 158 }
 159
 160 struct ibcs2_msgrcv_args {
 161         int what;
 162         int msqid;
 163         void *msgp;
 164         size_t msgsz;
 165         long msgtyp;
 166         int msgflg;
 167 };
 168
 169 static int
 170 ibcs2_msgrcv(struct thread *td, void *v)
 171 {
 172         struct ibcs2_msgrcv_args *uap = v;
 173         struct msgrcv_args ap;
 174
 175         ap.msqid = uap->msqid;
 176         ap.msgp = uap->msgp;
 177         ap.msgsz = uap->msgsz;
 178         ap.msgtyp = uap->msgtyp;
 179         ap.msgflg = uap->msgflg;
 180         return (sys_msgrcv(td, &ap));
 181 }
 182
 183 struct ibcs2_msgsnd_args {
 184         int what;
 185         int msqid;
 186         void *msgp;
 187         size_t msgsz;
 188         int msgflg;
 189 };
 190
 191 static int
 192 ibcs2_msgsnd(struct thread *td, void *v)
 193 {
 194         struct ibcs2_msgsnd_args *uap = v;
 195         struct msgsnd_args ap;
 196
 197         ap.msqid = uap->msqid;
 198         ap.msgp = uap->msgp;
 199         ap.msgsz = uap->msgsz;
 200         ap.msgflg = uap->msgflg;
 201         return (sys_msgsnd(td, &ap));
 202 }
 203
 204 int
 205 ibcs2_msgsys(td, uap)
 206         struct thread *td;
 207         struct ibcs2_msgsys_args *uap;
 208 {
 209         switch (uap->which) {
 210         case 0:
 211                 return (ibcs2_msgget(td, uap));
 212         case 1:
 213                 return (ibcs2_msgctl(td, uap));
 214         case 2:
 215                 return (ibcs2_msgrcv(td, uap));
 216         case 3:
 217                 return (ibcs2_msgsnd(td, uap));
 218         default:
 219                 return (EINVAL);
 220         }
 221 }
 222
 223 /*
 224  * iBCS2 semsys call
 225  */
 226 #ifdef unused
 227 static void
 228 cvt_sem2isem(bp, ibp)
 229 struct sem *bp;
 230 struct ibcs2_sem *ibp;
 231 {
 232         ibp->semval = bp->semval;
 233         ibp->sempid = bp->sempid;
 234         ibp->semncnt = bp->semncnt;
 235         ibp->semzcnt = bp->semzcnt;
 236         return;
 237 }
 238
 239 static void
 240 cvt_isem2sem(ibp, bp)
 241 struct ibcs2_sem *ibp;
 242 struct sem *bp;
 243 {
 244         bp->semval = ibp->semval;
 245         bp->sempid = ibp->sempid;
 246         bp->semncnt = ibp->semncnt;
 247         bp->semzcnt = ibp->semzcnt;
 248         return;
 249 }
 250 #endif
 251
 252 static void
 253 cvt_iperm2perm(ipp, pp)
 254 struct ibcs2_ipc_perm *ipp;
 255 struct ipc_perm *pp;
 256 {
 257         pp->uid = ipp->uid;
 258         pp->gid = ipp->gid;
 259         pp->cuid = ipp->cuid;
 260         pp->cgid = ipp->cgid;
 261         pp->mode = ipp->mode;
 262         pp->seq = ipp->seq;
 263         pp->key = ipp->key;
 264 }
 265
 266 static void
 267 cvt_perm2iperm(pp, ipp)
 268 struct ipc_perm *pp;
 269 struct ibcs2_ipc_perm *ipp;
 270 {
 271         ipp->uid = pp->uid;
 272         ipp->gid = pp->gid;
 273         ipp->cuid = pp->cuid;
 274         ipp->cgid = pp->cgid;
 275         ipp->mode = pp->mode;
 276         ipp->seq = pp->seq;
 277         ipp->key = pp->key;
 278 }
 279
 280 static void
 281 cvt_semid2isemid(bp, ibp)
 282 struct semid_ds *bp;
 283 struct ibcs2_semid_ds *ibp;
 284 {
 285         memset(ibp, 0, sizeof(*ibp));
 286         cvt_perm2iperm(&bp->sem_perm, &ibp->sem_perm);
 287         ibp->sem_nsems = bp->sem_nsems;
 288         ibp->sem_otime = bp->sem_otime;
 289         ibp->sem_ctime = bp->sem_ctime;
 290         return;
 291 }
 292
 293 static void
 294 cvt_isemid2semid(ibp, bp)
 295 struct ibcs2_semid_ds *ibp;
 296 struct semid_ds *bp;
 297 {
 298         cvt_iperm2perm(&ibp->sem_perm, &bp->sem_perm);
 299         bp->sem_nsems = ibp->sem_nsems;
 300         bp->sem_otime = ibp->sem_otime;
 301         bp->sem_ctime = ibp->sem_ctime;
 302         return;
 303 }
 304
 305 struct ibcs2_semctl_args {
 306         int what;
 307         int semid;
 308         int semnum;
 309         int cmd;
 310         union semun arg;
 311 };
 312
 313 static int
 314 ibcs2_semctl(struct thread *td, void *v)
 315 {
 316         struct ibcs2_semctl_args *uap = v;
 317         struct ibcs2_semid_ds is;
 318         struct semid_ds bs;
 319         union semun semun;
 320         register_t rval;
 321         int error;
 322
 323         memset(&is, 0, sizeof(is));
 324
 325         switch(uap->cmd) {
 326         case IBCS2_IPC_STAT:
 327                 semun.buf = &bs;
 328                 error = kern_semctl(td, uap->semid, uap->semnum, IPC_STAT,
 329                     &semun, &rval);
 330                 if (error)
 331                         return (error);
 332                 cvt_semid2isemid(&bs, &is);
 333                 error = copyout(&is, uap->arg.buf, sizeof(is));
 334                 if (error == 0)
 335                         td->td_retval[0] = rval;
 336                 return (error);
 337
 338         case IBCS2_IPC_SET:
 339                 error = copyin(uap->arg.buf, &is, sizeof(is));
 340                 if (error)
 341                         return (error);
 342                 cvt_isemid2semid(&is, &bs);
 343                 semun.buf = &bs;
 344                 return (kern_semctl(td, uap->semid, uap->semnum, IPC_SET,
 345                     &semun, td->td_retval));
 346         }
 347
 348         return (kern_semctl(td, uap->semid, uap->semnum, uap->cmd, &uap->arg,
 349             td->td_retval));
 350 }
 351
 352 struct ibcs2_semget_args {
 353         int what;
 354         ibcs2_key_t key;
 355         int nsems;
 356         int semflg;
 357 };
 358
 359 static int
 360 ibcs2_semget(struct thread *td, void *v)
 361 {
 362         struct ibcs2_semget_args *uap = v;
 363         struct semget_args ap;
 364
 365         ap.key = uap->key;
 366         ap.nsems = uap->nsems;
 367         ap.semflg = uap->semflg;
 368         return (sys_semget(td, &ap));
 369 }
 370
 371 struct ibcs2_semop_args {
 372         int what;
 373         int semid;
 374         struct sembuf *sops;
 375         size_t nsops;
 376 };
 377
 378 static int
 379 ibcs2_semop(struct thread *td, void *v)
 380 {
 381         struct ibcs2_semop_args *uap = v;
 382         struct semop_args ap;
 383
 384         ap.semid = uap->semid;
 385         ap.sops = uap->sops;
 386         ap.nsops = uap->nsops;
 387         return (sys_semop(td, &ap));
 388 }
 389
 390 int
 391 ibcs2_semsys(td, uap)
 392         struct thread *td;
 393         struct ibcs2_semsys_args *uap;
 394 {
 395
 396         switch (uap->which) {
 397         case 0:
 398                 return (ibcs2_semctl(td, uap));
 399         case 1:
 400                 return (ibcs2_semget(td, uap));
 401         case 2:
 402                 return (ibcs2_semop(td, uap));
 403         }
 404         return (EINVAL);
 405 }
 406
 407
 408 /*
 409  * iBCS2 shmsys call
 410  */
 411
 412 static void
 413 cvt_shmid2ishmid(bp, ibp)
 414 struct shmid_ds *bp;
 415 struct ibcs2_shmid_ds *ibp;
 416 {
 417         cvt_perm2iperm(&bp->shm_perm, &ibp->shm_perm);
 418         ibp->shm_segsz = bp->shm_segsz;
 419         ibp->shm_lpid = bp->shm_lpid;
 420         ibp->shm_cpid = bp->shm_cpid;
 421         if (bp->shm_nattch > SHRT_MAX)
 422                 ibp->shm_nattch = SHRT_MAX;
 423         else
 424                 ibp->shm_nattch = bp->shm_nattch;
 425         ibp->shm_cnattch = 0;                   /* ignored anyway */
 426         ibp->shm_atime = bp->shm_atime;
 427         ibp->shm_dtime = bp->shm_dtime;
 428         ibp->shm_ctime = bp->shm_ctime;
 429         return;
 430 }
 431
 432 static void
 433 cvt_ishmid2shmid(ibp, bp)
 434 struct ibcs2_shmid_ds *ibp;
 435 struct shmid_ds *bp;
 436 {
 437         cvt_iperm2perm(&ibp->shm_perm, &bp->shm_perm);
 438         bp->shm_segsz = ibp->shm_segsz;
 439         bp->shm_lpid = ibp->shm_lpid;
 440         bp->shm_cpid = ibp->shm_cpid;
 441         bp->shm_nattch = ibp->shm_nattch;
 442         bp->shm_atime = ibp->shm_atime;
 443         bp->shm_dtime = ibp->shm_dtime;
 444         bp->shm_ctime = ibp->shm_ctime;
 445         return;
 446 }
 447
 448 struct ibcs2_shmat_args {
 449         int what;
 450         int shmid;
 451         const void *shmaddr;
 452         int shmflg;
 453 };
 454
 455 static int
 456 ibcs2_shmat(struct thread *td, void *v)
 457 {
 458         struct ibcs2_shmat_args *uap = v;
 459         struct shmat_args ap;
 460
 461         ap.shmid = uap->shmid;
 462         ap.shmaddr = uap->shmaddr;
 463         ap.shmflg = uap->shmflg;
 464         return (sys_shmat(td, &ap));
 465 }
 466
 467 struct ibcs2_shmctl_args {
 468         int what;
 469         int shmid;
 470         int cmd;
 471         struct ibcs2_shmid_ds *buf;
 472 };
 473
 474 static int
 475 ibcs2_shmctl(struct thread *td, void *v)
 476 {
 477         struct ibcs2_shmctl_args *uap = v;
 478         struct ibcs2_shmid_ds is;
 479         struct shmid_ds bs;
 480         int error;
 481
 482         switch(uap->cmd) {
 483         case IBCS2_IPC_STAT:
 484                 error = kern_shmctl(td, uap->shmid, IPC_STAT, &bs, NULL);
 485                 if (error)
 486                         return (error);
 487                 cvt_shmid2ishmid(&bs, &is);
 488                 return (copyout(&is, uap->buf, sizeof(is)));
 489
 490         case IBCS2_IPC_SET:
 491                 error = copyin(uap->buf, &is, sizeof(is));
 492                 if (error)
 493                         return (error);
 494                 cvt_ishmid2shmid(&is, &bs);
 495                 return (kern_shmctl(td, uap->shmid, IPC_SET, &bs, NULL));
 496
 497         case IPC_INFO:
 498         case SHM_INFO:
 499         case SHM_STAT:
 500                 /* XXX: */
 501                 return (EINVAL);
 502         }
 503
 504         return (kern_shmctl(td, uap->shmid, uap->cmd, NULL, NULL));
 505 }
 506
 507 struct ibcs2_shmdt_args {
 508         int what;
 509         const void *shmaddr;
 510 };
 511
 512 static int
 513 ibcs2_shmdt(struct thread *td, void *v)
 514 {
 515         struct ibcs2_shmdt_args *uap = v;
 516         struct shmdt_args ap;
 517
 518         ap.shmaddr = uap->shmaddr;
 519         return (sys_shmdt(td, &ap));
 520 }
 521
 522 struct ibcs2_shmget_args {
 523         int what;
 524         ibcs2_key_t key;
 525         size_t size;
 526         int shmflg;
 527 };
 528
 529 static int
 530 ibcs2_shmget(struct thread *td, void *v)
 531 {
 532         struct ibcs2_shmget_args *uap = v;
 533         struct shmget_args ap;
 534
 535         ap.key = uap->key;
 536         ap.size = uap->size;
 537         ap.shmflg = uap->shmflg;
 538         return (sys_shmget(td, &ap));
 539 }
 540
 541 int
 542 ibcs2_shmsys(td, uap)
 543         struct thread *td;
 544         struct ibcs2_shmsys_args *uap;
 545 {
 546
 547         switch (uap->which) {
 548         case 0:
 549                 return (ibcs2_shmat(td, uap));
 550         case 1:
 551                 return (ibcs2_shmctl(td, uap));
 552         case 2:
 553                 return (ibcs2_shmdt(td, uap));
 554         case 3:
 555                 return (ibcs2_shmget(td, uap));
 556         }
 557         return (EINVAL);
 558 }
 559
 560 MODULE_DEPEND(ibcs2, sysvmsg, 1, 1, 1);
 561 MODULE_DEPEND(ibcs2, sysvsem, 1, 1, 1);
 562 MODULE_DEPEND(ibcs2, sysvshm, 1, 1, 1);