root/compat/common/kern_ipc_35.c

DEFINITIONS

1. compat_35_sys_shmget
2. compat_35_sys_semop
3. msqid_copyin
4. msqid_copyout
5. compat_35_sys_msgctl
6. semid_copyin
7. semid_copyout
8. compat_35_sys___semctl
9. shmid_copyin
10. shmid_copyout
11. compat_35_sys_shmctl

    1 /*      $OpenBSD: kern_ipc_35.c,v 1.3 2004/07/15 11:00:12 millert Exp $ */
    3 /*
    4  * Copyright (c) 2004 Todd C. Miller <Todd.Miller@courtesan.com>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 #include <sys/param.h>
   20 #include <sys/systm.h>
   21 #include <sys/kernel.h>
   22 #include <sys/proc.h>
   23 #include <sys/msg.h>
   24 #include <sys/sem.h>
   25 #include <sys/shm.h>
   27 #include <sys/mount.h>
   28 #include <sys/syscallargs.h>
   30 #ifdef SYSVMSG
   31 /*
   32  * Old-style shmget(2) used int for the size parameter, we now use size_t.
   33  */
   34 int
compat_35_sys_shmget(struct proc *p, void *v, register_t *retval)
   36 {
   37         struct compat_35_sys_shmget_args /* {
   38                 syscallarg(key_t) key;
   39                 syscallarg(int) size;
   40                 syscallarg(int) shmflg;
   41         } */ *uap = v;
   42         struct sys_shmget_args /* {
   43                 syscallarg(key_t) key;
   44                 syscallarg(size_t) size;
   45                 syscallarg(int) shmflg;
   46         } */ shmget_args;
SCARG(&shmget_args, key) = SCARG(uap, key);
SCARG(&shmget_args, size) = (size_t)SCARG(uap, size);
SCARG(&shmget_args, shmflg) = SCARG(uap, shmflg);
   52         return (sys_shmget(p, &shmget_args, retval));
   53 }
   54 #endif
   56 #ifdef SYSVSEM
   57 /*
   58  * Old-style shmget(2) used u_int for the nsops parameter, we now use size_t.
   59  */
   60 int
compat_35_sys_semop(struct proc *p, void *v, register_t *retval)
   62 {
   63         struct compat_35_sys_semop_args /* {
   64                 syscallarg(int) semid;
   65                 syscallarg(struct sembuf *) sops;
   66                 syscallarg(u_int) nsops;
   67         } */ *uap = v;
   68         struct sys_semop_args /* {
   69                 syscallarg(int) semid;
   70                 syscallarg(struct sembuf *) sops;
   71                 syscallarg(size_t) nsops;
   72         } */ semop_args;
SCARG(&semop_args, semid) = SCARG(uap, semid);
SCARG(&semop_args, sops) = SCARG(uap, sops);
SCARG(&semop_args, nsops) = (size_t)SCARG(uap, nsops);
   78         return (sys_semop(p, &semop_args, retval));
   79 }
   80 #endif
   82 /*
   83  * Convert between new and old struct {msq,sem,shm}id_ds (both ways)
   84  */
   85 #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM)
   86 #define cvt_ds(to, from, type, base) do {                               \
   87         (to)->type##_perm.cuid = (from)->type##_perm.cuid;              \
   88         (to)->type##_perm.cgid = (from)->type##_perm.cgid;              \
   89         (to)->type##_perm.uid = (from)->type##_perm.uid;                \
   90         (to)->type##_perm.gid = (from)->type##_perm.gid;                \
   91         (to)->type##_perm.mode = (from)->type##_perm.mode & 0xffffU;    \
   92         (to)->type##_perm.seq = (from)->type##_perm.seq;                \
   93         (to)->type##_perm.key = (from)->type##_perm.key;                \
bcopy((caddr_t)&(from)->base, (caddr_t)&(to)->base,             \
   95             sizeof(*(to)) - ((caddr_t)&(to)->base - (caddr_t)to));      \
   96 } while (0)
   97 #endif /* SYSVMSG || SYSVSEM || SYSVSHM */
   99 #ifdef SYSVMSG
  100 /*
  101  * Copy a struct msqid_ds35 from userland and convert to struct msqid_ds
  102  */
  103 static int
msqid_copyin(const void *uaddr, void *kaddr, size_t len)
  105 {
  106         struct msqid_ds *msqbuf = kaddr;
  107         struct msqid_ds35 omsqbuf;
  108         int error;
  110         if (len != sizeof(struct msqid_ds))
  111                 return (EFAULT);
  112         if ((error = copyin(uaddr, &omsqbuf, sizeof(omsqbuf))) == 0)
cvt_ds(msqbuf, &omsqbuf, msg, msg_first);
  114         return (error);
  115 }
  117 /*
  118  * Convert a struct msqid_ds to struct msqid_ds35 and copy to userland
  119  */
  120 static int
msqid_copyout(const void *kaddr, void *uaddr, size_t len)
  122 {
  123         const struct msqid_ds *msqbuf = kaddr;
  124         struct msqid_ds35 omsqbuf;
  126         if (len != sizeof(struct msqid_ds))
  127                 return (EFAULT);
cvt_ds(&omsqbuf, msqbuf, msg, msg_first);
  129         return (copyout(&omsqbuf, uaddr, sizeof(omsqbuf)));
  130 }
  132 /*
  133  * OpenBSD 3.5 msgctl(2) with 16bit mode_t in struct ipcperm.
  134  */
  135 int
compat_35_sys_msgctl(struct proc *p, void *v, register_t *retval)
  137 {
  138         struct compat_35_sys_msgctl_args /* {
  139                 syscallarg(int) msqid;
  140                 syscallarg(int) cmd;
  141                 syscallarg(struct msqid_ds35 *) buf;
  142         } */ *uap = v;
  144         return (msgctl1(p, SCARG(uap, msqid), SCARG(uap, cmd),
  145             (caddr_t)SCARG(uap, buf), msqid_copyin, msqid_copyout));
  146 }
  147 #endif /* SYSVMSG */
  149 #ifdef SYSVSEM
  150 /*
  151  * Copy a struct semid_ds35 from userland and convert to struct semid_ds
  152  */
  153 static int
semid_copyin(const void *uaddr, void *kaddr, size_t len)
  155 {
  156         struct semid_ds *sembuf = kaddr;
  157         struct semid_ds35 osembuf;
  158         int error;
  160         if (len != sizeof(struct semid_ds))
  161                 return (EFAULT);
  162         if ((error = copyin(uaddr, &osembuf, sizeof(osembuf))) == 0)
cvt_ds(sembuf, &osembuf, sem, sem_base);
  164         return (error);
  165 }
  167 /*
  168  * Convert a struct semid_ds to struct semid_ds35 and copy to userland
  169  */
  170 static int
semid_copyout(const void *kaddr, void *uaddr, size_t len)
  172 {
  173         const struct semid_ds *sembuf = kaddr;
  174         struct semid_ds35 osembuf;
  176         if (len != sizeof(struct semid_ds))
  177                 return (EFAULT);
cvt_ds(&osembuf, sembuf, sem, sem_base);
  179         return (copyout(&osembuf, uaddr, sizeof(osembuf)));
  180 }
  182 /*
  183  * OpenBSD 3.5 semctl(2) with 16bit mode_t in struct ipcperm.
  184  */
  185 int
compat_35_sys___semctl(struct proc *p, void *v, register_t *retval)
  187 {
  188         struct compat_35_sys___semctl_args /* {
  189                 syscallarg(int) semid;
  190                 syscallarg(int) semnum;
  191                 syscallarg(int) cmd;
  192                 syscallarg(union semun *) arg;
  193         } */ *uap = v;
  194         union semun arg;
  195         int error = 0, cmd = SCARG(uap, cmd);
  197         switch (cmd) {
  198         case IPC_SET:
  199         case IPC_STAT:
  200         case GETALL:
  201         case SETVAL:
  202         case SETALL:
error = copyin(SCARG(uap, arg), &arg, sizeof(arg));
  204                 break;
  205         }
  206         if (error == 0) {
error = semctl1(p, SCARG(uap, semid), SCARG(uap, semnum),
cmd, &arg, retval, semid_copyin, semid_copyout);
  209         }
  210         return (error);
  211 }
  212 #endif /* SYSVSEM */
  214 #ifdef SYSVSHM
  215 /*
  216  * Copy a struct shmid_ds35 from userland and convert to struct shmid_ds
  217  */
  218 static int
shmid_copyin(const void *uaddr, void *kaddr, size_t len)
  220 {
  221         struct shmid_ds *shmbuf = kaddr;
  222         struct shmid_ds35 oshmbuf;
  223         int error;
  225         if (len != sizeof(struct shmid_ds))
  226                 return (EFAULT);
  227         if ((error = copyin(uaddr, &oshmbuf, sizeof(oshmbuf))) == 0)
cvt_ds(shmbuf, &oshmbuf, shm, shm_segsz);
  229         return (error);
  230 }
  232 /*
  233  * Convert a struct shmid_ds to struct shmid_ds35 and copy to userland
  234  */
  235 static int
shmid_copyout(const void *kaddr, void *uaddr, size_t len)
  237 {
  238         const struct shmid_ds *shmbuf = kaddr;
  239         struct shmid_ds35 oshmbuf;
  241         if (len != sizeof(struct shmid_ds))
  242                 return (EFAULT);
cvt_ds(&oshmbuf, shmbuf, shm, shm_segsz);
  244         return (copyout(&oshmbuf, uaddr, sizeof(oshmbuf)));
  245 }
  247 /*
  248  * OpenBSD 3.5 shmctl(2) with 16bit mode_t in struct ipcperm.
  249  */
  250 int
compat_35_sys_shmctl(struct proc *p, void *v, register_t *retval)
  252 {
  253         struct compat_35_sys_shmctl_args /* {
  254                 syscallarg(int) shmid;
  255                 syscallarg(int) cmd;
  256                 syscallarg(struct shmid_ds35 *) buf;
  257         } */ *uap = v;
  259         return (shmctl1(p, SCARG(uap, shmid), SCARG(uap, cmd),
  260             (caddr_t)SCARG(uap, buf), shmid_copyin, shmid_copyout));
  261 }
  262 #endif /* SYSVSHM */