The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Cache object: bbdbe14d93d9b7ca50a0f034a4e545da


[ 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.