Annotation of sys/compat/linux/linux_ipc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: linux_ipc.c,v 1.10 2007/05/29 10:44:29 sturm Exp $ */
! 2: /* $NetBSD: linux_ipc.c,v 1.10 1996/04/05 00:01:44 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Frank van der Linden
! 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. 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 for the NetBSD Project
! 19: * by Frank van der Linden
! 20: * 4. The name of the author may not be used to endorse or promote products
! 21: * derived from this software without specific prior written permission
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35: #include <sys/types.h>
! 36: #include <sys/param.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/shm.h>
! 39: #include <sys/sem.h>
! 40: #include <sys/msg.h>
! 41: #include <sys/proc.h>
! 42: #include <sys/uio.h>
! 43: #include <sys/time.h>
! 44: #include <sys/malloc.h>
! 45: #include <sys/mman.h>
! 46: #include <sys/systm.h>
! 47: #include <sys/stat.h>
! 48:
! 49: #include <sys/mount.h>
! 50: #include <sys/syscallargs.h>
! 51:
! 52: #include <compat/linux/linux_types.h>
! 53: #include <compat/linux/linux_signal.h>
! 54: #include <compat/linux/linux_syscallargs.h>
! 55: #include <compat/linux/linux_util.h>
! 56: #include <compat/linux/linux_ipc.h>
! 57: #include <compat/linux/linux_msg.h>
! 58: #include <compat/linux/linux_shm.h>
! 59: #include <compat/linux/linux_sem.h>
! 60: #include <compat/linux/linux_ipccall.h>
! 61:
! 62: /*
! 63: * Stuff to deal with the SysV ipc/shm/semaphore interface in Linux.
! 64: * The main difference is, that Linux handles it all via one
! 65: * system call, which has the usual maximum amount of 5 arguments.
! 66: * This results in a kludge for calls that take 6 of them.
! 67: *
! 68: * The SYSVXXXX options have to be enabled to get the appropriate
! 69: * functions to work.
! 70: */
! 71:
! 72: #ifdef SYSVSEM
! 73: int linux_semop(struct proc *, void *, register_t *);
! 74: int linux_semget(struct proc *, void *, register_t *);
! 75: int linux_semctl(struct proc *, void *, register_t *);
! 76: void bsd_to_linux_semid_ds(struct semid_ds *, struct linux_semid_ds *);
! 77: void linux_to_bsd_semid_ds(struct linux_semid_ds *, struct semid_ds *);
! 78: #endif
! 79:
! 80: #ifdef SYSVMSG
! 81: int linux_msgsnd(struct proc *, void *, register_t *);
! 82: int linux_msgrcv(struct proc *, void *, register_t *);
! 83: int linux_msgget(struct proc *, void *, register_t *);
! 84: int linux_msgctl(struct proc *, void *, register_t *);
! 85: void linux_to_bsd_msqid_ds(struct linux_msqid_ds *, struct msqid_ds *);
! 86: void bsd_to_linux_msqid_ds(struct msqid_ds *, struct linux_msqid_ds *);
! 87: #endif
! 88:
! 89: #ifdef SYSVSHM
! 90: int linux_shmat(struct proc *, void *, register_t *);
! 91: int linux_shmdt(struct proc *, void *, register_t *);
! 92: int linux_shmget(struct proc *, void *, register_t *);
! 93: int linux_shmctl(struct proc *, void *, register_t *);
! 94: void linux_to_bsd_shmid_ds(struct linux_shmid_ds *, struct shmid_ds *);
! 95: void bsd_to_linux_shmid_ds(struct shmid_ds *, struct linux_shmid_ds *);
! 96: #endif
! 97:
! 98: #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM)
! 99: void linux_to_bsd_ipc_perm(struct linux_ipc_perm *, struct ipc_perm *);
! 100: void bsd_to_linux_ipc_perm(struct ipc_perm *, struct linux_ipc_perm *);
! 101: #endif
! 102:
! 103: int
! 104: linux_sys_ipc(p, v, retval)
! 105: struct proc *p;
! 106: void *v;
! 107: register_t *retval;
! 108: {
! 109: struct linux_sys_ipc_args /* {
! 110: syscallarg(int) what;
! 111: syscallarg(int) a1;
! 112: syscallarg(int) a2;
! 113: syscallarg(int) a3;
! 114: syscallarg(caddr_t) ptr;
! 115: } */ *uap = v;
! 116:
! 117: switch (SCARG(uap, what)) {
! 118: #ifdef SYSVSEM
! 119: case LINUX_SYS_semop:
! 120: return linux_semop(p, uap, retval);
! 121: case LINUX_SYS_semget:
! 122: return linux_semget(p, uap, retval);
! 123: case LINUX_SYS_semctl:
! 124: return linux_semctl(p, uap, retval);
! 125: #endif
! 126: #ifdef SYSVMSG
! 127: case LINUX_SYS_msgsnd:
! 128: return linux_msgsnd(p, uap, retval);
! 129: case LINUX_SYS_msgrcv:
! 130: return linux_msgrcv(p, uap, retval);
! 131: case LINUX_SYS_msgget:
! 132: return linux_msgget(p, uap, retval);
! 133: case LINUX_SYS_msgctl:
! 134: return linux_msgctl(p, uap, retval);
! 135: #endif
! 136: #ifdef SYSVSHM
! 137: case LINUX_SYS_shmat:
! 138: return linux_shmat(p, uap, retval);
! 139: case LINUX_SYS_shmdt:
! 140: return linux_shmdt(p, uap, retval);
! 141: case LINUX_SYS_shmget:
! 142: return linux_shmget(p, uap, retval);
! 143: case LINUX_SYS_shmctl:
! 144: return linux_shmctl(p, uap, retval);
! 145: #endif
! 146: default:
! 147: return ENOSYS;
! 148: }
! 149: }
! 150:
! 151: #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM)
! 152: /*
! 153: * Convert between Linux and OpenBSD ipc_perm structures. Only the
! 154: * order of the fields is different.
! 155: */
! 156: void
! 157: linux_to_bsd_ipc_perm(lpp, bpp)
! 158: struct linux_ipc_perm *lpp;
! 159: struct ipc_perm *bpp;
! 160: {
! 161:
! 162: bpp->key = lpp->l_key;
! 163: bpp->uid = lpp->l_uid;
! 164: bpp->gid = lpp->l_gid;
! 165: bpp->cuid = lpp->l_cuid;
! 166: bpp->cgid = lpp->l_cgid;
! 167: bpp->mode = lpp->l_mode;
! 168: bpp->seq = lpp->l_seq;
! 169: }
! 170:
! 171: void
! 172: bsd_to_linux_ipc_perm(bpp, lpp)
! 173: struct ipc_perm *bpp;
! 174: struct linux_ipc_perm *lpp;
! 175: {
! 176:
! 177: lpp->l_key = bpp->key;
! 178: lpp->l_uid = bpp->uid;
! 179: lpp->l_gid = bpp->gid;
! 180: lpp->l_cuid = bpp->cuid;
! 181: lpp->l_cgid = bpp->cgid;
! 182: lpp->l_mode = bpp->mode;
! 183: lpp->l_seq = bpp->seq;
! 184: }
! 185: #endif
! 186:
! 187: #ifdef SYSVSEM
! 188: /*
! 189: * Semaphore operations. Most constants and structures are the same on
! 190: * both systems. Only semctl() needs some extra work.
! 191: */
! 192:
! 193: /*
! 194: * Convert between Linux and OpenBSD semid_ds structures.
! 195: */
! 196: void
! 197: bsd_to_linux_semid_ds(bs, ls)
! 198: struct semid_ds *bs;
! 199: struct linux_semid_ds *ls;
! 200: {
! 201:
! 202: bsd_to_linux_ipc_perm(&bs->sem_perm, &ls->l_sem_perm);
! 203: ls->l_sem_otime = bs->sem_otime;
! 204: ls->l_sem_ctime = bs->sem_ctime;
! 205: ls->l_sem_nsems = bs->sem_nsems;
! 206: ls->l_sem_base = bs->sem_base;
! 207: }
! 208:
! 209: void
! 210: linux_to_bsd_semid_ds(ls, bs)
! 211: struct linux_semid_ds *ls;
! 212: struct semid_ds *bs;
! 213: {
! 214:
! 215: linux_to_bsd_ipc_perm(&ls->l_sem_perm, &bs->sem_perm);
! 216: bs->sem_otime = ls->l_sem_otime;
! 217: bs->sem_ctime = ls->l_sem_ctime;
! 218: bs->sem_nsems = ls->l_sem_nsems;
! 219: bs->sem_base = ls->l_sem_base;
! 220: }
! 221:
! 222: int
! 223: linux_semop(p, v, retval)
! 224: struct proc *p;
! 225: void *v;
! 226: register_t *retval;
! 227: {
! 228: struct linux_sys_ipc_args /* {
! 229: syscallarg(int) what;
! 230: syscallarg(int) a1;
! 231: syscallarg(int) a2;
! 232: syscallarg(int) a3;
! 233: syscallarg(caddr_t) ptr;
! 234: } */ *uap = v;
! 235: struct sys_semop_args bsa;
! 236:
! 237: SCARG(&bsa, semid) = SCARG(uap, a1);
! 238: SCARG(&bsa, sops) = (struct sembuf *)SCARG(uap, ptr);
! 239: SCARG(&bsa, nsops) = SCARG(uap, a2);
! 240:
! 241: return sys_semop(p, &bsa, retval);
! 242: }
! 243:
! 244: int
! 245: linux_semget(p, v, retval)
! 246: struct proc *p;
! 247: void *v;
! 248: register_t *retval;
! 249: {
! 250: struct linux_sys_ipc_args /* {
! 251: syscallarg(int) what;
! 252: syscallarg(int) a1;
! 253: syscallarg(int) a2;
! 254: syscallarg(int) a3;
! 255: syscallarg(caddr_t) ptr;
! 256: } */ *uap = v;
! 257: struct sys_semget_args bsa;
! 258:
! 259: SCARG(&bsa, key) = (key_t)SCARG(uap, a1);
! 260: SCARG(&bsa, nsems) = SCARG(uap, a2);
! 261: SCARG(&bsa, semflg) = SCARG(uap, a3);
! 262:
! 263: return sys_semget(p, &bsa, retval);
! 264: }
! 265:
! 266: /*
! 267: * Most of this can be handled by directly passing the arguments on,
! 268: * buf IPC_* require a lot of copy{in,out} because of the extra indirection
! 269: * (we are passed a pointer to a union cointaining a pointer to a semid_ds
! 270: * structure.
! 271: */
! 272: int
! 273: linux_semctl(p, v, retval)
! 274: struct proc *p;
! 275: void *v;
! 276: register_t *retval;
! 277: {
! 278: struct linux_sys_ipc_args /* {
! 279: syscallarg(int) what;
! 280: syscallarg(int) a1;
! 281: syscallarg(int) a2;
! 282: syscallarg(int) a3;
! 283: syscallarg(caddr_t) ptr;
! 284: } */ *uap = v;
! 285: caddr_t sg, unptr, dsp, ldsp;
! 286: int error, cmd;
! 287: struct sys___semctl_args bsa;
! 288: struct linux_semid_ds lm;
! 289: struct semid_ds bm;
! 290:
! 291: SCARG(&bsa, semid) = SCARG(uap, a1);
! 292: SCARG(&bsa, semnum) = SCARG(uap, a2);
! 293: SCARG(&bsa, cmd) = SCARG(uap, a3);
! 294: SCARG(&bsa, arg) = (union semun *)SCARG(uap, ptr);
! 295: switch(SCARG(uap, a3)) {
! 296: case LINUX_GETVAL:
! 297: cmd = GETVAL;
! 298: break;
! 299: case LINUX_GETPID:
! 300: cmd = GETPID;
! 301: break;
! 302: case LINUX_GETNCNT:
! 303: cmd = GETNCNT;
! 304: break;
! 305: case LINUX_GETZCNT:
! 306: cmd = GETZCNT;
! 307: break;
! 308: case LINUX_SETVAL:
! 309: cmd = SETVAL;
! 310: break;
! 311: case LINUX_IPC_RMID:
! 312: cmd = IPC_RMID;
! 313: break;
! 314: case LINUX_IPC_SET:
! 315: if ((error = copyin(SCARG(uap, ptr), &ldsp, sizeof ldsp)))
! 316: return error;
! 317: if ((error = copyin(ldsp, (caddr_t)&lm, sizeof lm)))
! 318: return error;
! 319: linux_to_bsd_semid_ds(&lm, &bm);
! 320: sg = stackgap_init(p->p_emul);
! 321: unptr = stackgap_alloc(&sg, sizeof (union semun));
! 322: dsp = stackgap_alloc(&sg, sizeof (struct semid_ds));
! 323: if ((error = copyout((caddr_t)&bm, dsp, sizeof bm)))
! 324: return error;
! 325: if ((error = copyout((caddr_t)&dsp, unptr, sizeof dsp)))
! 326: return error;
! 327: SCARG(&bsa, arg) = (union semun *)unptr;
! 328: return sys___semctl(p, &bsa, retval);
! 329: case LINUX_IPC_STAT:
! 330: sg = stackgap_init(p->p_emul);
! 331: unptr = stackgap_alloc(&sg, sizeof (union semun *));
! 332: dsp = stackgap_alloc(&sg, sizeof (struct semid_ds));
! 333: if ((error = copyout((caddr_t)&dsp, unptr, sizeof dsp)))
! 334: return error;
! 335: SCARG(&bsa, arg) = (union semun *)unptr;
! 336: if ((error = sys___semctl(p, &bsa, retval)))
! 337: return error;
! 338: if ((error = copyin(dsp, (caddr_t)&bm, sizeof bm)))
! 339: return error;
! 340: bsd_to_linux_semid_ds(&bm, &lm);
! 341: if ((error = copyin(SCARG(uap, ptr), &ldsp, sizeof ldsp)))
! 342: return error;
! 343: return copyout((caddr_t)&lm, ldsp, sizeof lm);
! 344: default:
! 345: return EINVAL;
! 346: }
! 347: SCARG(&bsa, cmd) = cmd;
! 348:
! 349: return sys___semctl(p, &bsa, retval);
! 350: }
! 351: #endif /* SYSVSEM */
! 352:
! 353: #ifdef SYSVMSG
! 354:
! 355: void
! 356: linux_to_bsd_msqid_ds(lmp, bmp)
! 357: struct linux_msqid_ds *lmp;
! 358: struct msqid_ds *bmp;
! 359: {
! 360:
! 361: linux_to_bsd_ipc_perm(&lmp->l_msg_perm, &bmp->msg_perm);
! 362: bmp->msg_first = lmp->l_msg_first;
! 363: bmp->msg_last = lmp->l_msg_last;
! 364: bmp->msg_cbytes = lmp->l_msg_cbytes;
! 365: bmp->msg_qnum = lmp->l_msg_qnum;
! 366: bmp->msg_qbytes = lmp->l_msg_qbytes;
! 367: bmp->msg_lspid = lmp->l_msg_lspid;
! 368: bmp->msg_lrpid = lmp->l_msg_lrpid;
! 369: bmp->msg_stime = lmp->l_msg_stime;
! 370: bmp->msg_rtime = lmp->l_msg_rtime;
! 371: bmp->msg_ctime = lmp->l_msg_ctime;
! 372: }
! 373:
! 374: void
! 375: bsd_to_linux_msqid_ds(bmp, lmp)
! 376: struct msqid_ds *bmp;
! 377: struct linux_msqid_ds *lmp;
! 378: {
! 379:
! 380: bsd_to_linux_ipc_perm(&bmp->msg_perm, &lmp->l_msg_perm);
! 381: lmp->l_msg_first = bmp->msg_first;
! 382: lmp->l_msg_last = bmp->msg_last;
! 383: lmp->l_msg_cbytes = bmp->msg_cbytes;
! 384: lmp->l_msg_qnum = bmp->msg_qnum;
! 385: lmp->l_msg_qbytes = bmp->msg_qbytes;
! 386: lmp->l_msg_lspid = bmp->msg_lspid;
! 387: lmp->l_msg_lrpid = bmp->msg_lrpid;
! 388: lmp->l_msg_stime = bmp->msg_stime;
! 389: lmp->l_msg_rtime = bmp->msg_rtime;
! 390: lmp->l_msg_ctime = bmp->msg_ctime;
! 391: }
! 392:
! 393: int
! 394: linux_msgsnd(p, v, retval)
! 395: struct proc *p;
! 396: void *v;
! 397: register_t *retval;
! 398: {
! 399: struct linux_sys_ipc_args /* {
! 400: syscallarg(int) what;
! 401: syscallarg(int) a1;
! 402: syscallarg(int) a2;
! 403: syscallarg(int) a3;
! 404: syscallarg(caddr_t) ptr;
! 405: } */ *uap = v;
! 406: struct sys_msgsnd_args bma;
! 407:
! 408: SCARG(&bma, msqid) = SCARG(uap, a1);
! 409: SCARG(&bma, msgp) = SCARG(uap, ptr);
! 410: SCARG(&bma, msgsz) = SCARG(uap, a2);
! 411: SCARG(&bma, msgflg) = SCARG(uap, a3);
! 412:
! 413: return sys_msgsnd(p, &bma, retval);
! 414: }
! 415:
! 416: int
! 417: linux_msgrcv(p, v, retval)
! 418: struct proc *p;
! 419: void *v;
! 420: register_t *retval;
! 421: {
! 422: struct linux_sys_ipc_args /* {
! 423: syscallarg(int) what;
! 424: syscallarg(int) a1;
! 425: syscallarg(int) a2;
! 426: syscallarg(int) a3;
! 427: syscallarg(caddr_t) ptr;
! 428: } */ *uap = v;
! 429: struct sys_msgrcv_args bma;
! 430: struct linux_msgrcv_msgarg kluge;
! 431: int error;
! 432:
! 433: if ((error = copyin(SCARG(uap, ptr), &kluge, sizeof kluge)))
! 434: return error;
! 435:
! 436: SCARG(&bma, msqid) = SCARG(uap, a1);
! 437: SCARG(&bma, msgp) = kluge.msg;
! 438: SCARG(&bma, msgsz) = SCARG(uap, a2);
! 439: SCARG(&bma, msgtyp) = kluge.type;
! 440: SCARG(&bma, msgflg) = SCARG(uap, a3);
! 441:
! 442: return sys_msgrcv(p, &bma, retval);
! 443: }
! 444:
! 445: int
! 446: linux_msgget(p, v, retval)
! 447: struct proc *p;
! 448: void *v;
! 449: register_t *retval;
! 450: {
! 451: struct linux_sys_ipc_args /* {
! 452: syscallarg(int) what;
! 453: syscallarg(int) a1;
! 454: syscallarg(int) a2;
! 455: syscallarg(int) a3;
! 456: syscallarg(caddr_t) ptr;
! 457: } */ *uap = v;
! 458: struct sys_msgget_args bma;
! 459:
! 460: SCARG(&bma, key) = (key_t)SCARG(uap, a1);
! 461: SCARG(&bma, msgflg) = SCARG(uap, a2);
! 462:
! 463: return sys_msgget(p, &bma, retval);
! 464: }
! 465:
! 466: int
! 467: linux_msgctl(p, v, retval)
! 468: struct proc *p;
! 469: void *v;
! 470: register_t *retval;
! 471: {
! 472: struct linux_sys_ipc_args /* {
! 473: syscallarg(int) what;
! 474: syscallarg(int) a1;
! 475: syscallarg(int) a2;
! 476: syscallarg(int) a3;
! 477: syscallarg(caddr_t) ptr;
! 478: } */ *uap = v;
! 479: struct sys_msgctl_args bma;
! 480: caddr_t umsgptr, sg;
! 481: struct linux_msqid_ds lm;
! 482: struct msqid_ds bm;
! 483: int error;
! 484:
! 485: SCARG(&bma, msqid) = SCARG(uap, a1);
! 486: SCARG(&bma, cmd) = SCARG(uap, a2);
! 487: switch (SCARG(uap, a2)) {
! 488: case LINUX_IPC_RMID:
! 489: return sys_msgctl(p, &bma, retval);
! 490: case LINUX_IPC_SET:
! 491: if ((error = copyin(SCARG(uap, ptr), (caddr_t)&lm, sizeof lm)))
! 492: return error;
! 493: linux_to_bsd_msqid_ds(&lm, &bm);
! 494: sg = stackgap_init(p->p_emul);
! 495: umsgptr = stackgap_alloc(&sg, sizeof bm);
! 496: if ((error = copyout((caddr_t)&bm, umsgptr, sizeof bm)))
! 497: return error;
! 498: SCARG(&bma, buf) = (struct msqid_ds *)umsgptr;
! 499: return sys_msgctl(p, &bma, retval);
! 500: case LINUX_IPC_STAT:
! 501: sg = stackgap_init(p->p_emul);
! 502: umsgptr = stackgap_alloc(&sg, sizeof (struct msqid_ds));
! 503: SCARG(&bma, buf) = (struct msqid_ds *)umsgptr;
! 504: if ((error = sys_msgctl(p, &bma, retval)))
! 505: return error;
! 506: if ((error = copyin(umsgptr, (caddr_t)&bm, sizeof bm)))
! 507: return error;
! 508: bsd_to_linux_msqid_ds(&bm, &lm);
! 509: return copyout((caddr_t)&lm, SCARG(uap, ptr), sizeof lm);
! 510: }
! 511: return EINVAL;
! 512: }
! 513: #endif /* SYSVMSG */
! 514:
! 515: #ifdef SYSVSHM
! 516: /*
! 517: * shmat(2). Very straightforward, except that Linux passes a pointer
! 518: * in which the return value is to be passed. This is subsequently
! 519: * handled by libc, apparently.
! 520: */
! 521: int
! 522: linux_shmat(p, v, retval)
! 523: struct proc *p;
! 524: void *v;
! 525: register_t *retval;
! 526: {
! 527: struct linux_sys_ipc_args /* {
! 528: syscallarg(int) what;
! 529: syscallarg(int) a1;
! 530: syscallarg(int) a2;
! 531: syscallarg(int) a3;
! 532: syscallarg(caddr_t) ptr;
! 533: } */ *uap = v;
! 534: struct sys_shmat_args bsa;
! 535: int error;
! 536:
! 537: SCARG(&bsa, shmid) = SCARG(uap, a1);
! 538: SCARG(&bsa, shmaddr) = SCARG(uap, ptr);
! 539: SCARG(&bsa, shmflg) = SCARG(uap, a2);
! 540:
! 541: if ((error = sys_shmat(p, &bsa, retval)))
! 542: return error;
! 543:
! 544: if ((error = copyout(&retval[0], (caddr_t) SCARG(uap, a3),
! 545: sizeof retval[0])))
! 546: return error;
! 547:
! 548: retval[0] = 0;
! 549: return 0;
! 550: }
! 551:
! 552: /*
! 553: * shmdt(): this could have been mapped directly, if it wasn't for
! 554: * the extra indirection by the linux_ipc system call.
! 555: */
! 556: int
! 557: linux_shmdt(p, v, retval)
! 558: struct proc *p;
! 559: void *v;
! 560: register_t *retval;
! 561: {
! 562: struct linux_sys_ipc_args /* {
! 563: syscallarg(int) what;
! 564: syscallarg(int) a1;
! 565: syscallarg(int) a2;
! 566: syscallarg(int) a3;
! 567: syscallarg(caddr_t) ptr;
! 568: } */ *uap = v;
! 569: struct sys_shmdt_args bsa;
! 570:
! 571: SCARG(&bsa, shmaddr) = SCARG(uap, ptr);
! 572:
! 573: return sys_shmdt(p, &bsa, retval);
! 574: }
! 575:
! 576: /*
! 577: * Same story as shmdt.
! 578: */
! 579: int
! 580: linux_shmget(p, v, retval)
! 581: struct proc *p;
! 582: void *v;
! 583: register_t *retval;
! 584: {
! 585: struct linux_sys_ipc_args /* {
! 586: syscallarg(int) what;
! 587: syscallarg(int) a1;
! 588: syscallarg(int) a2;
! 589: syscallarg(int) a3;
! 590: syscallarg(caddr_t) ptr;
! 591: } */ *uap = v;
! 592: struct sys_shmget_args bsa;
! 593:
! 594: SCARG(&bsa, key) = SCARG(uap, a1);
! 595: SCARG(&bsa, size) = SCARG(uap, a2);
! 596: SCARG(&bsa, shmflg) = SCARG(uap, a3);
! 597:
! 598: SCARG(&bsa, shmflg) |= _SHM_RMLINGER;
! 599:
! 600: return sys_shmget(p, &bsa, retval);
! 601: }
! 602:
! 603: /*
! 604: * Convert between Linux and OpenBSD shmid_ds structures.
! 605: * The order of the fields is once again the difference, and
! 606: * we also need a place to store the internal data pointer
! 607: * in, which is unfortunately stored in this structure.
! 608: *
! 609: * We abuse a Linux internal field for that.
! 610: */
! 611: void
! 612: linux_to_bsd_shmid_ds(lsp, bsp)
! 613: struct linux_shmid_ds *lsp;
! 614: struct shmid_ds *bsp;
! 615: {
! 616:
! 617: linux_to_bsd_ipc_perm(&lsp->l_shm_perm, &bsp->shm_perm);
! 618: bsp->shm_segsz = lsp->l_shm_segsz;
! 619: bsp->shm_lpid = lsp->l_shm_lpid;
! 620: bsp->shm_cpid = lsp->l_shm_cpid;
! 621: bsp->shm_nattch = lsp->l_shm_nattch;
! 622: bsp->shm_atime = lsp->l_shm_atime;
! 623: bsp->shm_dtime = lsp->l_shm_dtime;
! 624: bsp->shm_ctime = lsp->l_shm_ctime;
! 625: bsp->shm_internal = lsp->l_private2; /* XXX Oh well. */
! 626: }
! 627:
! 628: void
! 629: bsd_to_linux_shmid_ds(bsp, lsp)
! 630: struct shmid_ds *bsp;
! 631: struct linux_shmid_ds *lsp;
! 632: {
! 633:
! 634: bsd_to_linux_ipc_perm(&bsp->shm_perm, &lsp->l_shm_perm);
! 635: lsp->l_shm_segsz = bsp->shm_segsz;
! 636: lsp->l_shm_lpid = bsp->shm_lpid;
! 637: lsp->l_shm_cpid = bsp->shm_cpid;
! 638: lsp->l_shm_nattch = bsp->shm_nattch;
! 639: lsp->l_shm_atime = bsp->shm_atime;
! 640: lsp->l_shm_dtime = bsp->shm_dtime;
! 641: lsp->l_shm_ctime = bsp->shm_ctime;
! 642: lsp->l_private2 = bsp->shm_internal; /* XXX */
! 643: }
! 644:
! 645: /*
! 646: * shmctl. Not implemented (for now): IPC_INFO, SHM_INFO, SHM_STAT
! 647: * SHM_LOCK and SHM_UNLOCK are passed on, but currently not implemented
! 648: * by OpenBSD itself.
! 649: *
! 650: * The usual structure conversion and massaging is done.
! 651: */
! 652: int
! 653: linux_shmctl(p, v, retval)
! 654: struct proc *p;
! 655: void *v;
! 656: register_t *retval;
! 657: {
! 658: struct linux_sys_ipc_args /* {
! 659: syscallarg(int) what;
! 660: syscallarg(int) a1;
! 661: syscallarg(int) a2;
! 662: syscallarg(int) a3;
! 663: syscallarg(caddr_t) ptr;
! 664: } */ *uap = v;
! 665: int error;
! 666: caddr_t sg;
! 667: struct sys_shmctl_args bsa;
! 668: struct shmid_ds *bsp, bs;
! 669: struct linux_shmid_ds lseg;
! 670:
! 671: switch (SCARG(uap, a2)) {
! 672: case LINUX_IPC_STAT:
! 673: sg = stackgap_init(p->p_emul);
! 674: bsp = stackgap_alloc(&sg, sizeof (struct shmid_ds));
! 675: SCARG(&bsa, shmid) = SCARG(uap, a1);
! 676: SCARG(&bsa, cmd) = IPC_STAT;
! 677: SCARG(&bsa, buf) = bsp;
! 678: if ((error = sys_shmctl(p, &bsa, retval)))
! 679: return error;
! 680: if ((error = copyin((caddr_t) bsp, (caddr_t) &bs, sizeof bs)))
! 681: return error;
! 682: bsd_to_linux_shmid_ds(&bs, &lseg);
! 683: return copyout((caddr_t) &lseg, SCARG(uap, ptr), sizeof lseg);
! 684: case LINUX_IPC_SET:
! 685: if ((error = copyin(SCARG(uap, ptr), (caddr_t) &lseg,
! 686: sizeof lseg)))
! 687: return error;
! 688: linux_to_bsd_shmid_ds(&lseg, &bs);
! 689: sg = stackgap_init(p->p_emul);
! 690: bsp = stackgap_alloc(&sg, sizeof (struct shmid_ds));
! 691: if ((error = copyout((caddr_t) &bs, (caddr_t) bsp, sizeof bs)))
! 692: return error;
! 693: SCARG(&bsa, shmid) = SCARG(uap, a1);
! 694: SCARG(&bsa, cmd) = IPC_SET;
! 695: SCARG(&bsa, buf) = bsp;
! 696: return sys_shmctl(p, &bsa, retval);
! 697: case LINUX_IPC_RMID:
! 698: case LINUX_SHM_LOCK:
! 699: case LINUX_SHM_UNLOCK:
! 700: SCARG(&bsa, shmid) = SCARG(uap, a1);
! 701: switch (SCARG(uap, a2)) {
! 702: case LINUX_IPC_RMID:
! 703: SCARG(&bsa, cmd) = IPC_RMID;
! 704: break;
! 705: case LINUX_SHM_LOCK:
! 706: SCARG(&bsa, cmd) = SHM_LOCK;
! 707: break;
! 708: case LINUX_SHM_UNLOCK:
! 709: SCARG(&bsa, cmd) = SHM_UNLOCK;
! 710: break;
! 711: }
! 712: SCARG(&bsa, buf) = NULL;
! 713: return sys_shmctl(p, &bsa, retval);
! 714: case LINUX_IPC_INFO:
! 715: case LINUX_SHM_STAT:
! 716: case LINUX_SHM_INFO:
! 717: default:
! 718: return EINVAL;
! 719: }
! 720: }
! 721: #endif /* SYSVSHM */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_ipc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux