svr4_ipc.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1995 The NetBSD Foundation, Inc.
    3  * All rights reserved.
    4  *
    5  * This code is derived from software contributed to The NetBSD Foundation
    6  * by Christos Zoulas.
    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. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *        This product includes software developed by the NetBSD
   19  *        Foundation, Inc. and its contributors.
   20  * 4. Neither the name of The NetBSD Foundation nor the names of its
   21  *    contributors may be used to endorse or promote products derived
   22  *    from this software without specific prior written permission.
   23  *
   24  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   27  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   28  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   34  * POSSIBILITY OF SUCH DAMAGE.
   35  */
   36 /*-
   37  * Portions of this code have been derived from software contributed
   38  * to the FreeBSD Project by Mark Newton.
   39  *
   40  * Copyright (c) 1999 Mark Newton
   41  * All rights reserved.
   42  * 
   43  * Redistribution and use in source and binary forms, with or without
   44  * modification, are permitted provided that the following conditions
   45  * are met:
   46  * 1. Redistributions of source code must retain the above copyright
   47  *    notice, this list of conditions and the following disclaimer.
   48  * 2. Redistributions in binary form must reproduce the above copyright
   49  *    notice, this list of conditions and the following disclaimer in the
   50  *    documentation and/or other materials provided with the distribution.
   51  * 3. The name of the author may not be used to endorse or promote products
   52  *    derived from this software without specific prior written permission
   53  *
   54  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   55  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   56  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   57  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   58  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   59  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   60  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   61  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   63  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   64  *
   65  * XXX- This code is presently a no-op on FreeBSD (and isn't compiled due
   66  * to preprocessor conditionals).  A nice project for a kernel hacking 
   67  * novice might be to MakeItGo, but I have more important fish to fry
   68  * at present.
   69  *
   70  *      Derived from: $NetBSD: svr4_ipc.c,v 1.7 1998/10/19 22:43:00 tron Exp $
   71  */
   72 
   73 #include <sys/cdefs.h>
   74 __FBSDID("$FreeBSD: releng/8.1/sys/compat/svr4/svr4_ipc.c 194910 2009-06-24 21:10:52Z jhb $");
   75 
   76 #include "opt_sysvipc.h"
   77 
   78 #include <sys/param.h>
   79 #include <sys/ipc.h>
   80 #include <sys/msg.h>
   81 #include <sys/proc.h>
   82 #include <sys/sem.h>
   83 #include <sys/shm.h>
   84 #include <sys/syscallsubr.h>
   85 #include <sys/sysproto.h>
   86 #include <sys/systm.h>
   87 #include <sys/time.h>
   88 
   89 #include <compat/svr4/svr4.h>
   90 #include <compat/svr4/svr4_types.h>
   91 #include <compat/svr4/svr4_signal.h>
   92 #include <compat/svr4/svr4_proto.h>
   93 #include <compat/svr4/svr4_util.h>
   94 #include <compat/svr4/svr4_ipc.h>
   95 
   96 #if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
   97 static void svr4_to_bsd_ipc_perm(const struct svr4_ipc_perm *,
   98                                       struct ipc_perm *);
   99 static void bsd_to_svr4_ipc_perm(const struct ipc_perm *,
  100                                       struct svr4_ipc_perm *);
  101 #endif
  102 
  103 #ifdef SYSVSEM
  104 static void bsd_to_svr4_semid_ds(const struct semid_ds *,
  105                                       struct svr4_semid_ds *);
  106 static void svr4_to_bsd_semid_ds(const struct svr4_semid_ds *,
  107                                       struct semid_ds *);
  108 static int svr4_semop(struct thread *, void *);
  109 static int svr4_semget(struct thread *, void *);
  110 static int svr4_semctl(struct thread *, void *);
  111 #endif
  112 
  113 #ifdef SYSVMSG
  114 static void bsd_to_svr4_msqid_ds(const struct msqid_ds *,
  115                                       struct svr4_msqid_ds *);
  116 static void svr4_to_bsd_msqid_ds(const struct svr4_msqid_ds *,
  117                                       struct msqid_ds *);
  118 static int svr4_msgsnd(struct thread *, void *);
  119 static int svr4_msgrcv(struct thread *, void *);
  120 static int svr4_msgget(struct thread *, void *);
  121 static int svr4_msgctl(struct thread *, void *);
  122 #endif
  123 
  124 #ifdef SYSVSHM
  125 static void bsd_to_svr4_shmid_ds(const struct shmid_ds *,
  126                                       struct svr4_shmid_ds *);
  127 static void svr4_to_bsd_shmid_ds(const struct svr4_shmid_ds *,
  128                                       struct shmid_ds *);
  129 static int svr4_shmat(struct thread *, void *);
  130 static int svr4_shmdt(struct thread *, void *);
  131 static int svr4_shmget(struct thread *, void *);
  132 static int svr4_shmctl(struct thread *, void *);
  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         bzero(sds, sizeof(*sds));
  173         bsd_to_svr4_ipc_perm(&bds->sem_perm, &sds->sem_perm);
  174         sds->sem_base = (struct svr4_sem *) bds->sem_base;
  175         sds->sem_nsems = bds->sem_nsems;
  176         sds->sem_otime = bds->sem_otime;
  177         sds->sem_ctime = bds->sem_ctime;
  178 }
  179 
  180 static void
  181 svr4_to_bsd_semid_ds(sds, bds)
  182         const struct svr4_semid_ds *sds;
  183         struct semid_ds *bds;
  184 {
  185         svr4_to_bsd_ipc_perm(&sds->sem_perm, &bds->sem_perm);
  186         bds->sem_base = (struct sem *) bds->sem_base;
  187         bds->sem_nsems = sds->sem_nsems;
  188         bds->sem_otime = sds->sem_otime;
  189         bds->sem_ctime = sds->sem_ctime;
  190 }
  191 
  192 struct svr4_sys_semctl_args {
  193         int what;
  194         int semid;
  195         int semnum;
  196         int cmd;
  197         union semun arg;
  198 };
  199 
  200 static int
  201 svr4_semctl(td, v)
  202         struct thread *td;
  203         void *v;
  204 {
  205         struct svr4_sys_semctl_args *uap = v;
  206         struct svr4_semid_ds ss;
  207         struct semid_ds bs;
  208         union semun semun;
  209         register_t rval;
  210         int cmd, error;
  211 
  212         switch (uap->cmd) {
  213         case SVR4_SEM_GETZCNT:
  214                 cmd = GETZCNT;
  215                 break;
  216 
  217         case SVR4_SEM_GETNCNT:
  218                 cmd = GETNCNT;
  219                 break;
  220 
  221         case SVR4_SEM_GETPID:
  222                 cmd = GETPID;
  223                 break;
  224 
  225         case SVR4_SEM_GETVAL:
  226                 cmd = GETVAL;
  227                 break;
  228 
  229         case SVR4_SEM_SETVAL:
  230                 cmd = SETVAL;
  231                 break;
  232 
  233         case SVR4_SEM_GETALL:
  234                 cmd = GETVAL;
  235                 break;
  236 
  237         case SVR4_SEM_SETALL:
  238                 cmd = SETVAL;
  239                 break;
  240 
  241         case SVR4_IPC_STAT:
  242                 cmd = IPC_STAT;
  243                 semun.buf = &bs;
  244                 error = kern_semctl(td, uap->semid, uap->semnum, cmd, &semun,
  245                     &rval);
  246                 if (error)
  247                         return (error);
  248                 bsd_to_svr4_semid_ds(&bs, &ss);
  249                 error = copyout(&ss, uap->arg.buf, sizeof(ss));
  250                 if (error == 0)
  251                         td->td_retval[0] = rval;
  252                 return (error);
  253 
  254         case SVR4_IPC_SET:
  255                 cmd = IPC_SET;
  256                 error = copyin(uap->arg.buf, (caddr_t) &ss, sizeof ss);
  257                 if (error)
  258                         return (error);
  259                 svr4_to_bsd_semid_ds(&ss, &bs);
  260                 semun.buf = &bs;
  261                 return (kern_semctl(td, uap->semid, uap->semnum, cmd, &semun,
  262                     td->td_retval));
  263 
  264         case SVR4_IPC_RMID:
  265                 cmd = IPC_RMID;
  266                 break;
  267 
  268         default:
  269                 return EINVAL;
  270         }
  271 
  272         return (kern_semctl(td, uap->semid, uap->semnum, cmd, &uap->arg,
  273             td->td_retval));
  274 }
  275 
  276 struct svr4_sys_semget_args {
  277         int what;
  278         svr4_key_t key;
  279         int nsems;
  280         int semflg;
  281 };
  282 
  283 static int
  284 svr4_semget(td, v)
  285         struct thread *td;
  286         void *v;
  287 {
  288         struct svr4_sys_semget_args *uap = v;
  289         struct semget_args ap;
  290 
  291         ap.key = uap->key;
  292         ap.nsems = uap->nsems;
  293         ap.semflg = uap->semflg;
  294 
  295         return semget(td, &ap);
  296 }
  297 
  298 struct svr4_sys_semop_args {
  299         int what;
  300         int semid;
  301         struct svr4_sembuf * sops;
  302         u_int nsops;
  303 };
  304 
  305 static int
  306 svr4_semop(td, v)
  307         struct thread *td;
  308         void *v;
  309 {
  310         struct svr4_sys_semop_args *uap = v;
  311         struct semop_args ap;
  312 
  313         ap.semid = uap->semid;
  314         /* These are the same */
  315         ap.sops = (struct sembuf *) uap->sops;
  316         ap.nsops = uap->nsops;
  317 
  318         return semop(td, &ap);
  319 }
  320 
  321 int
  322 svr4_sys_semsys(td, uap)
  323         struct thread *td;
  324         struct svr4_sys_semsys_args *uap;
  325 {
  326 
  327         DPRINTF(("svr4_semsys(%d)\n", uap->what));
  328 
  329         switch (uap->what) {
  330         case SVR4_semctl:
  331                 return svr4_semctl(td, uap);
  332         case SVR4_semget:
  333                 return svr4_semget(td, uap);
  334         case SVR4_semop:
  335                 return svr4_semop(td, uap);
  336         default:
  337                 return EINVAL;
  338         }
  339 }
  340 
  341 MODULE_DEPEND(svr4elf, sysvsem, 1, 1, 1);
  342 #endif
  343 
  344 #ifdef SYSVMSG
  345 static void
  346 bsd_to_svr4_msqid_ds(bds, sds)
  347         const struct msqid_ds *bds;
  348         struct svr4_msqid_ds *sds;
  349 {
  350         bzero(sds, sizeof(*sds));
  351         bsd_to_svr4_ipc_perm(&bds->msg_perm, &sds->msg_perm);
  352         sds->msg_first = (struct svr4_msg *) bds->msg_first;
  353         sds->msg_last = (struct svr4_msg *) bds->msg_last;
  354         sds->msg_cbytes = bds->msg_cbytes;
  355         sds->msg_qnum = bds->msg_qnum;
  356         sds->msg_qbytes = bds->msg_qbytes;
  357         sds->msg_lspid = bds->msg_lspid;
  358         sds->msg_lrpid = bds->msg_lrpid;
  359         sds->msg_stime = bds->msg_stime;
  360         sds->msg_rtime = bds->msg_rtime;
  361         sds->msg_ctime = bds->msg_ctime;
  362 }
  363 
  364 static void
  365 svr4_to_bsd_msqid_ds(sds, bds)
  366         const struct svr4_msqid_ds *sds;
  367         struct msqid_ds *bds;
  368 {
  369         svr4_to_bsd_ipc_perm(&sds->msg_perm, &bds->msg_perm);
  370         bds->msg_first = (struct msg *) sds->msg_first;
  371         bds->msg_last = (struct msg *) sds->msg_last;
  372         bds->msg_cbytes = sds->msg_cbytes;
  373         bds->msg_qnum = sds->msg_qnum;
  374         bds->msg_qbytes = sds->msg_qbytes;
  375         bds->msg_lspid = sds->msg_lspid;
  376         bds->msg_lrpid = sds->msg_lrpid;
  377         bds->msg_stime = sds->msg_stime;
  378         bds->msg_rtime = sds->msg_rtime;
  379         bds->msg_ctime = sds->msg_ctime;
  380 }
  381 
  382 struct svr4_sys_msgsnd_args {
  383         int what;
  384         int msqid;
  385         void * msgp;
  386         size_t msgsz;
  387         int msgflg;
  388 };
  389 
  390 static int
  391 svr4_msgsnd(td, v)
  392         struct thread *td;
  393         void *v;
  394 {
  395         struct svr4_sys_msgsnd_args *uap = v;
  396         struct msgsnd_args ap;
  397 
  398         ap.msqid = uap->msqid;
  399         ap.msgp = uap->msgp;
  400         ap.msgsz = uap->msgsz;
  401         ap.msgflg = uap->msgflg;
  402 
  403         return msgsnd(td, &ap);
  404 }
  405 
  406 struct svr4_sys_msgrcv_args {
  407         int what;
  408         int msqid;
  409         void * msgp;
  410         size_t msgsz;
  411         long msgtyp;
  412         int msgflg;
  413 };
  414 
  415 static int
  416 svr4_msgrcv(td, v)
  417         struct thread *td;
  418         void *v;
  419 {
  420         struct svr4_sys_msgrcv_args *uap = v;
  421         struct msgrcv_args ap;
  422 
  423         ap.msqid = uap->msqid;
  424         ap.msgp = uap->msgp;
  425         ap.msgsz = uap->msgsz;
  426         ap.msgtyp = uap->msgtyp;
  427         ap.msgflg = uap->msgflg;
  428 
  429         return msgrcv(td, &ap);
  430 }
  431         
  432 struct svr4_sys_msgget_args {
  433         int what;
  434         svr4_key_t key;
  435         int msgflg;
  436 };
  437 
  438 static int
  439 svr4_msgget(td, v)
  440         struct thread *td;
  441         void *v;
  442 {
  443         struct svr4_sys_msgget_args *uap = v;
  444         struct msgget_args ap;
  445 
  446         ap.key = uap->key;
  447         ap.msgflg = uap->msgflg;
  448 
  449         return msgget(td, &ap);
  450 }
  451 
  452 struct svr4_sys_msgctl_args {
  453         int what;
  454         int msqid;
  455         int cmd;
  456         struct svr4_msqid_ds * buf;
  457 };
  458 
  459 static int
  460 svr4_msgctl(td, v)
  461         struct thread *td;
  462         void *v;
  463 {
  464         struct svr4_sys_msgctl_args *uap = v;
  465         struct svr4_msqid_ds ss;
  466         struct msqid_ds bs;
  467         int error;
  468 
  469         switch (uap->cmd) {
  470         case SVR4_IPC_STAT:
  471                 error = kern_msgctl(td, uap->msqid, IPC_STAT, &bs);
  472                 if (error)
  473                         return error;
  474                 bsd_to_svr4_msqid_ds(&bs, &ss);
  475                 return copyout(&ss, uap->buf, sizeof ss);
  476 
  477         case SVR4_IPC_SET:
  478                 error = copyin(uap->buf, &ss, sizeof ss);
  479                 if (error)
  480                         return error;
  481                 svr4_to_bsd_msqid_ds(&ss, &bs);
  482                 return (kern_msgctl(td, uap->msqid, IPC_SET, &bs));
  483 
  484         case SVR4_IPC_RMID:
  485                 return (kern_msgctl(td, uap->msqid, IPC_RMID, NULL));
  486 
  487         default:
  488                 return EINVAL;
  489         }
  490 }
  491 
  492 int
  493 svr4_sys_msgsys(td, uap)
  494         struct thread *td;
  495         struct svr4_sys_msgsys_args *uap;
  496 {
  497 
  498         DPRINTF(("svr4_msgsys(%d)\n", uap->what));
  499 
  500         switch (uap->what) {
  501         case SVR4_msgsnd:
  502                 return svr4_msgsnd(td, uap);
  503         case SVR4_msgrcv:
  504                 return svr4_msgrcv(td, uap);
  505         case SVR4_msgget:
  506                 return svr4_msgget(td, uap);
  507         case SVR4_msgctl:
  508                 return svr4_msgctl(td, uap);
  509         default:
  510                 return EINVAL;
  511         }
  512 }
  513 
  514 MODULE_DEPEND(svr4elf, sysvmsg, 1, 1, 1);
  515 #endif
  516 
  517 #ifdef SYSVSHM
  518 
  519 static void
  520 bsd_to_svr4_shmid_ds(bds, sds)
  521         const struct shmid_ds *bds;
  522         struct svr4_shmid_ds *sds;
  523 {
  524         bzero(sds, sizeof(*sds));
  525         bsd_to_svr4_ipc_perm(&bds->shm_perm, &sds->shm_perm);
  526         sds->shm_segsz = bds->shm_segsz;
  527         sds->shm_lkcnt = 0;
  528         sds->shm_lpid = bds->shm_lpid;
  529         sds->shm_cpid = bds->shm_cpid;
  530         sds->shm_amp = 0;
  531         sds->shm_nattch = bds->shm_nattch;
  532         sds->shm_cnattch = 0;
  533         sds->shm_atime = bds->shm_atime;
  534         sds->shm_dtime = bds->shm_dtime;
  535         sds->shm_ctime = bds->shm_ctime;
  536 }
  537 
  538 static void
  539 svr4_to_bsd_shmid_ds(sds, bds)
  540         const struct svr4_shmid_ds *sds;
  541         struct shmid_ds *bds;
  542 {
  543         svr4_to_bsd_ipc_perm(&sds->shm_perm, &bds->shm_perm);
  544         bds->shm_segsz = sds->shm_segsz;
  545         bds->shm_lpid = sds->shm_lpid;
  546         bds->shm_cpid = sds->shm_cpid;
  547         bds->shm_nattch = sds->shm_nattch;
  548         bds->shm_atime = sds->shm_atime;
  549         bds->shm_dtime = sds->shm_dtime;
  550         bds->shm_ctime = sds->shm_ctime;
  551 }
  552 
  553 struct svr4_sys_shmat_args {
  554         int what;
  555         int shmid;
  556         void * shmaddr;
  557         int shmflg;
  558 };
  559 
  560 static int
  561 svr4_shmat(td, v)
  562         struct thread *td;
  563         void *v;
  564 {
  565         struct svr4_sys_shmat_args *uap = v;
  566         struct shmat_args ap;
  567 
  568         ap.shmid = uap->shmid;
  569         ap.shmaddr = uap->shmaddr;
  570         ap.shmflg = uap->shmflg;
  571 
  572         return shmat(td, &ap);
  573 }
  574 
  575 struct svr4_sys_shmdt_args {
  576         int what;
  577         void * shmaddr;
  578 };
  579 
  580 static int
  581 svr4_shmdt(td, v)
  582         struct thread *td;
  583         void *v;
  584 {
  585         struct svr4_sys_shmdt_args *uap = v;
  586         struct shmdt_args ap;
  587 
  588         ap.shmaddr = uap->shmaddr;
  589 
  590         return shmdt(td, &ap);
  591 }
  592 
  593 struct svr4_sys_shmget_args {
  594         int what;
  595         key_t key;
  596         int size;
  597         int shmflg;
  598 };
  599 
  600 static int
  601 svr4_shmget(td, v)
  602         struct thread *td;
  603         void *v;
  604 {
  605         struct svr4_sys_shmget_args *uap = v;
  606         struct shmget_args ap;
  607 
  608         ap.key = uap->key;
  609         ap.size = uap->size;
  610         ap.shmflg = uap->shmflg;
  611 
  612         return shmget(td, &ap);
  613 }
  614 
  615 struct svr4_sys_shmctl_args {
  616         int what;
  617         int shmid;
  618         int cmd;
  619         struct svr4_shmid_ds * buf;
  620 };
  621 
  622 int
  623 svr4_shmctl(td, v)
  624         struct thread *td;
  625         void *v;
  626 {
  627         struct svr4_sys_shmctl_args *uap = v;
  628         struct shmid_ds bs;
  629         struct svr4_shmid_ds ss;
  630         size_t bufsize;
  631         int cmd, error;
  632 
  633         if (uap->buf != NULL) {
  634                 switch (uap->cmd) {
  635                 case SVR4_IPC_SET:
  636                 case SVR4_SHM_LOCK:
  637                 case SVR4_SHM_UNLOCK:
  638                         error = copyin(uap->buf, &ss, sizeof(ss));
  639                         if (error)
  640                                 return (error);
  641                         svr4_to_bsd_shmid_ds(&ss, &bs);
  642                         break;
  643                 default:
  644                         return (EINVAL);
  645                 }
  646         }
  647 
  648         switch (uap->cmd) {
  649         case SVR4_IPC_STAT:
  650                 cmd = IPC_STAT;
  651                 break;
  652         case SVR4_IPC_SET:
  653                 cmd = IPC_SET;
  654                 break;
  655         case SVR4_IPC_RMID:
  656                 cmd = IPC_RMID;
  657                 break;
  658         case SVR4_SHM_LOCK:
  659                 cmd = SHM_LOCK;
  660                 break;
  661         case SVR4_SHM_UNLOCK:
  662                 cmd = SHM_UNLOCK;
  663                 break;
  664         default:
  665                 return (EINVAL);
  666         }
  667                 
  668         error = kern_shmctl(td, uap->shmid, cmd, &bs, &bufsize);
  669         if (error)
  670                 return (error);
  671 
  672         switch (uap->cmd) {
  673         case SVR4_IPC_STAT:
  674                 if (uap->buf != NULL) {
  675                         bsd_to_svr4_shmid_ds(&bs, &ss);
  676                         error = copyout(&ss, uap->buf, sizeof(ss));
  677                 }
  678                 break;
  679         }
  680 
  681         return (error);
  682 }
  683 
  684 int
  685 svr4_sys_shmsys(td, uap)
  686         struct thread *td;
  687         struct svr4_sys_shmsys_args *uap;
  688 {
  689 
  690         DPRINTF(("svr4_shmsys(%d)\n", uap->what));
  691 
  692         switch (uap->what) {
  693         case SVR4_shmat:
  694                 return svr4_shmat(td, uap);
  695         case SVR4_shmdt:
  696                 return svr4_shmdt(td, uap);
  697         case SVR4_shmget:
  698                 return svr4_shmget(td, uap);
  699         case SVR4_shmctl:
  700                 return svr4_shmctl(td, uap);
  701         default:
  702                 return ENOSYS;
  703         }
  704 }
  705 
  706 MODULE_DEPEND(svr4elf, sysvshm, 1, 1, 1);
  707 #endif /* SYSVSHM */
Cache object: ffa6def019b059791d47e7eb711db345
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/compat/svr4/svr4_ipc.c

FreeBSD/Linux Kernel Cross Reference
sys/compat/svr4/svr4_ipc.c
