Annotation of sys/compat/svr4/svr4_ipc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: svr4_ipc.c,v 1.9 2002/03/14 01:26:51 millert Exp $ */
! 2: /* $NetBSD: svr4_ipc.c,v 1.3 1997/03/30 17:21:02 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Christos Zoulas. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Christos Zoulas.
! 18: * 4. The name of the author may not be used to endorse or promote products
! 19: * derived from this software without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 31: *
! 32: * Mostly stolen from: linux_ipc.c,v 1.4 1995/06/24 20:20:22 christos Exp
! 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/msg.h>
! 40: #include <sys/sem.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/svr4/svr4_types.h>
! 53: #include <compat/svr4/svr4_signal.h>
! 54: #include <compat/svr4/svr4_syscallargs.h>
! 55: #include <compat/svr4/svr4_util.h>
! 56: #include <compat/svr4/svr4_ipc.h>
! 57:
! 58: #if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
! 59: static void svr4_to_bsd_ipc_perm(const struct svr4_ipc_perm *,
! 60: struct ipc_perm *);
! 61: static void bsd_to_svr4_ipc_perm(const struct ipc_perm *,
! 62: struct svr4_ipc_perm *);
! 63: #endif
! 64:
! 65: #ifdef SYSVSEM
! 66: static void bsd_to_svr4_semid_ds(const struct semid_ds *,
! 67: struct svr4_semid_ds *);
! 68: static void svr4_to_bsd_semid_ds(const struct svr4_semid_ds *,
! 69: struct semid_ds *);
! 70: static int svr4_semop(struct proc *, void *, register_t *);
! 71: static int svr4_semget(struct proc *, void *, register_t *);
! 72: static int svr4_semctl(struct proc *, void *, register_t *);
! 73: #endif
! 74:
! 75: #ifdef SYSVMSG
! 76: static void bsd_to_svr4_msqid_ds(const struct msqid_ds *,
! 77: struct svr4_msqid_ds *);
! 78: static void svr4_to_bsd_msqid_ds(const struct svr4_msqid_ds *,
! 79: struct msqid_ds *);
! 80: static int svr4_msgsnd(struct proc *, void *, register_t *);
! 81: static int svr4_msgrcv(struct proc *, void *, register_t *);
! 82: static int svr4_msgget(struct proc *, void *, register_t *);
! 83: static int svr4_msgctl(struct proc *, void *, register_t *);
! 84: #endif
! 85:
! 86: #ifdef SYSVSHM
! 87: static void bsd_to_svr4_shmid_ds(const struct shmid_ds *,
! 88: struct svr4_shmid_ds *);
! 89: static void svr4_to_bsd_shmid_ds(const struct svr4_shmid_ds *,
! 90: struct shmid_ds *);
! 91: static int svr4_shmat(struct proc *, void *, register_t *);
! 92: static int svr4_shmdt(struct proc *, void *, register_t *);
! 93: static int svr4_shmget(struct proc *, void *, register_t *);
! 94: static int svr4_shmctl(struct proc *, void *, register_t *);
! 95: #endif
! 96:
! 97: #if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
! 98:
! 99: static void
! 100: svr4_to_bsd_ipc_perm(spp, bpp)
! 101: const struct svr4_ipc_perm *spp;
! 102: struct ipc_perm *bpp;
! 103: {
! 104: bpp->key = spp->key;
! 105: bpp->uid = spp->uid;
! 106: bpp->gid = spp->gid;
! 107: bpp->cuid = spp->cuid;
! 108: bpp->cgid = spp->cgid;
! 109: bpp->mode = spp->mode;
! 110: bpp->seq = spp->seq;
! 111: }
! 112:
! 113: static void
! 114: bsd_to_svr4_ipc_perm(bpp, spp)
! 115: const struct ipc_perm *bpp;
! 116: struct svr4_ipc_perm *spp;
! 117: {
! 118: spp->key = bpp->key;
! 119: spp->uid = bpp->uid;
! 120: spp->gid = bpp->gid;
! 121: spp->cuid = bpp->cuid;
! 122: spp->cgid = bpp->cgid;
! 123: spp->mode = bpp->mode;
! 124: spp->seq = bpp->seq;
! 125: }
! 126: #endif
! 127:
! 128: #ifdef SYSVSEM
! 129: static void
! 130: bsd_to_svr4_semid_ds(bds, sds)
! 131: const struct semid_ds *bds;
! 132: struct svr4_semid_ds *sds;
! 133: {
! 134: bsd_to_svr4_ipc_perm(&bds->sem_perm, &sds->sem_perm);
! 135: sds->sem_base = (struct svr4_sem *) bds->sem_base;
! 136: sds->sem_nsems = bds->sem_nsems;
! 137: sds->sem_otime = bds->sem_otime;
! 138: sds->sem_pad1 = bds->sem_pad1;
! 139: sds->sem_ctime = bds->sem_ctime;
! 140: sds->sem_pad2 = bds->sem_pad2;
! 141: }
! 142:
! 143: static void
! 144: svr4_to_bsd_semid_ds(sds, bds)
! 145: const struct svr4_semid_ds *sds;
! 146: struct semid_ds *bds;
! 147: {
! 148: svr4_to_bsd_ipc_perm(&sds->sem_perm, &bds->sem_perm);
! 149: bds->sem_base = (struct sem *) sds->sem_base;
! 150: bds->sem_nsems = sds->sem_nsems;
! 151: bds->sem_otime = sds->sem_otime;
! 152: bds->sem_pad1 = sds->sem_pad1;
! 153: bds->sem_ctime = sds->sem_ctime;
! 154: bds->sem_pad2 = sds->sem_pad2;
! 155: }
! 156:
! 157: struct svr4_sys_semctl_args {
! 158: syscallarg(int) what;
! 159: syscallarg(int) semid;
! 160: syscallarg(int) semnum;
! 161: syscallarg(int) cmd;
! 162: syscallarg(void *) arg;
! 163: };
! 164:
! 165: static int
! 166: svr4_semctl(p, v, retval)
! 167: struct proc *p;
! 168: void *v;
! 169: register_t *retval;
! 170: {
! 171: int error;
! 172: struct svr4_sys_semctl_args *uap = v;
! 173: struct sys___semctl_args ap;
! 174: struct svr4_semid_ds ss;
! 175: struct semid_ds bs;
! 176: caddr_t sg = stackgap_init(p->p_emul);
! 177:
! 178: SCARG(&ap, semid) = SCARG(uap, semid);
! 179: SCARG(&ap, semnum) = SCARG(uap, semnum);
! 180:
! 181: switch (SCARG(uap, cmd)) {
! 182: case SVR4_SEM_GETZCNT:
! 183: case SVR4_SEM_GETNCNT:
! 184: case SVR4_SEM_GETPID:
! 185: case SVR4_SEM_GETVAL:
! 186: switch (SCARG(uap, cmd)) {
! 187: case SVR4_SEM_GETZCNT:
! 188: SCARG(&ap, cmd) = GETZCNT;
! 189: break;
! 190: case SVR4_SEM_GETNCNT:
! 191: SCARG(&ap, cmd) = GETNCNT;
! 192: break;
! 193: case SVR4_SEM_GETPID:
! 194: SCARG(&ap, cmd) = GETPID;
! 195: break;
! 196: case SVR4_SEM_GETVAL:
! 197: SCARG(&ap, cmd) = GETVAL;
! 198: break;
! 199: }
! 200: return sys___semctl(p, &ap, retval);
! 201:
! 202: case SVR4_SEM_SETVAL:
! 203: SCARG(&ap, arg)->val = (int) SCARG(uap, arg);
! 204: SCARG(&ap, cmd) = SETVAL;
! 205: return sys___semctl(p, &ap, retval);
! 206:
! 207: case SVR4_SEM_GETALL:
! 208: SCARG(&ap, arg)->array = SCARG(uap, arg);
! 209: SCARG(&ap, cmd) = GETVAL;
! 210: return sys___semctl(p, &ap, retval);
! 211:
! 212: case SVR4_SEM_SETALL:
! 213: SCARG(&ap, arg)->array = SCARG(uap, arg);
! 214: SCARG(&ap, cmd) = SETVAL;
! 215: return sys___semctl(p, &ap, retval);
! 216:
! 217: case SVR4_IPC_STAT:
! 218: SCARG(&ap, cmd) = IPC_STAT;
! 219: SCARG(&ap, arg)->buf = stackgap_alloc(&sg, sizeof(bs));
! 220: if ((error = sys___semctl(p, &ap, retval)) != 0)
! 221: return error;
! 222: error = copyin(SCARG(&ap, arg)->buf, &bs, sizeof bs);
! 223: if (error)
! 224: return error;
! 225: bsd_to_svr4_semid_ds(&bs, &ss);
! 226: return copyout(&ss, SCARG(uap, arg), sizeof ss);
! 227:
! 228: case SVR4_IPC_SET:
! 229: SCARG(&ap, cmd) = IPC_SET;
! 230: SCARG(&ap, arg)->buf = stackgap_alloc(&sg, sizeof(bs));
! 231: error = copyin(SCARG(uap, arg), (caddr_t) &ss, sizeof ss);
! 232: if (error)
! 233: return error;
! 234: svr4_to_bsd_semid_ds(&ss, &bs);
! 235: error = copyout(&bs, SCARG(&ap, arg)->buf, sizeof bs);
! 236: if (error)
! 237: return error;
! 238: return sys___semctl(p, &ap, retval);
! 239:
! 240: case SVR4_IPC_RMID:
! 241: SCARG(&ap, cmd) = IPC_RMID;
! 242: SCARG(&ap, arg)->buf = stackgap_alloc(&sg, sizeof(bs));
! 243: error = copyin(SCARG(uap, arg), &ss, sizeof ss);
! 244: if (error)
! 245: return error;
! 246: svr4_to_bsd_semid_ds(&ss, &bs);
! 247: error = copyout(&bs, SCARG(&ap, arg)->buf, sizeof bs);
! 248: if (error)
! 249: return error;
! 250: return sys___semctl(p, &ap, retval);
! 251:
! 252: default:
! 253: return EINVAL;
! 254: }
! 255: }
! 256:
! 257: struct svr4_sys_semget_args {
! 258: syscallarg(int) what;
! 259: syscallarg(svr4_key_t) key;
! 260: syscallarg(int) nsems;
! 261: syscallarg(int) semflg;
! 262: };
! 263:
! 264: static int
! 265: svr4_semget(p, v, retval)
! 266: struct proc *p;
! 267: void *v;
! 268: register_t *retval;
! 269: {
! 270: struct svr4_sys_semget_args *uap = v;
! 271: struct sys_semget_args ap;
! 272:
! 273: SCARG(&ap, key) = SCARG(uap, key);
! 274: SCARG(&ap, nsems) = SCARG(uap, nsems);
! 275: SCARG(&ap, semflg) = SCARG(uap, semflg);
! 276:
! 277: return sys_semget(p, &ap, retval);
! 278: }
! 279:
! 280: struct svr4_sys_semop_args {
! 281: syscallarg(int) what;
! 282: syscallarg(int) semid;
! 283: syscallarg(struct svr4_sembuf *) sops;
! 284: syscallarg(u_int) nsops;
! 285: };
! 286:
! 287: static int
! 288: svr4_semop(p, v, retval)
! 289: struct proc *p;
! 290: void *v;
! 291: register_t *retval;
! 292: {
! 293: struct svr4_sys_semop_args *uap = v;
! 294: struct sys_semop_args ap;
! 295:
! 296: SCARG(&ap, semid) = SCARG(uap, semid);
! 297: /* These are the same */
! 298: SCARG(&ap, sops) = (struct sembuf *) SCARG(uap, sops);
! 299: SCARG(&ap, nsops) = SCARG(uap, nsops);
! 300:
! 301: return sys_semop(p, &ap, retval);
! 302: }
! 303:
! 304: int
! 305: svr4_sys_semsys(p, v, retval)
! 306: struct proc *p;
! 307: void *v;
! 308: register_t *retval;
! 309: {
! 310: struct svr4_sys_semsys_args *uap = v;
! 311:
! 312: DPRINTF(("svr4_semsys(%d)\n", SCARG(uap, what)));
! 313:
! 314: switch (SCARG(uap, what)) {
! 315: case SVR4_semctl:
! 316: return svr4_semctl(p, v, retval);
! 317: case SVR4_semget:
! 318: return svr4_semget(p, v, retval);
! 319: case SVR4_semop:
! 320: return svr4_semop(p, v, retval);
! 321: default:
! 322: return EINVAL;
! 323: }
! 324: }
! 325: #endif
! 326:
! 327: #ifdef SYSVMSG
! 328: static void
! 329: bsd_to_svr4_msqid_ds(bds, sds)
! 330: const struct msqid_ds *bds;
! 331: struct svr4_msqid_ds *sds;
! 332: {
! 333: bsd_to_svr4_ipc_perm(&bds->msg_perm, &sds->msg_perm);
! 334: sds->msg_first = (struct svr4_msg *) bds->msg_first;
! 335: sds->msg_last = (struct svr4_msg *) bds->msg_last;
! 336: sds->msg_cbytes = bds->msg_cbytes;
! 337: sds->msg_qnum = bds->msg_qnum;
! 338: sds->msg_qbytes = bds->msg_qbytes;
! 339: sds->msg_lspid = bds->msg_lspid;
! 340: sds->msg_lrpid = bds->msg_lrpid;
! 341: sds->msg_stime = bds->msg_stime;
! 342: sds->msg_pad1 = bds->msg_pad1;
! 343: sds->msg_rtime = bds->msg_rtime;
! 344: sds->msg_pad2 = bds->msg_pad2;
! 345: sds->msg_ctime = bds->msg_ctime;
! 346: sds->msg_pad3 = bds->msg_pad3;
! 347:
! 348: /* use the padding for the rest of the fields */
! 349: {
! 350: const short *pad = (const short *) bds->msg_pad4;
! 351: sds->msg_cv = pad[0];
! 352: sds->msg_qnum_cv = pad[1];
! 353: }
! 354: }
! 355:
! 356: static void
! 357: svr4_to_bsd_msqid_ds(sds, bds)
! 358: const struct svr4_msqid_ds *sds;
! 359: struct msqid_ds *bds;
! 360: {
! 361: svr4_to_bsd_ipc_perm(&sds->msg_perm, &bds->msg_perm);
! 362: bds->msg_first = (struct msg *) sds->msg_first;
! 363: bds->msg_last = (struct msg *) sds->msg_last;
! 364: bds->msg_cbytes = sds->msg_cbytes;
! 365: bds->msg_qnum = sds->msg_qnum;
! 366: bds->msg_qbytes = sds->msg_qbytes;
! 367: bds->msg_lspid = sds->msg_lspid;
! 368: bds->msg_lrpid = sds->msg_lrpid;
! 369: bds->msg_stime = sds->msg_stime;
! 370: bds->msg_pad1 = sds->msg_pad1;
! 371: bds->msg_rtime = sds->msg_rtime;
! 372: bds->msg_pad2 = sds->msg_pad2;
! 373: bds->msg_ctime = sds->msg_ctime;
! 374: bds->msg_pad3 = sds->msg_pad3;
! 375:
! 376: /* use the padding for the rest of the fields */
! 377: {
! 378: short *pad = (short *) bds->msg_pad4;
! 379: pad[0] = sds->msg_cv;
! 380: pad[1] = sds->msg_qnum_cv;
! 381: }
! 382: }
! 383:
! 384: struct svr4_sys_msgsnd_args {
! 385: syscallarg(int) what;
! 386: syscallarg(int) msqid;
! 387: syscallarg(void *) msgp;
! 388: syscallarg(size_t) msgsz;
! 389: syscallarg(int) msgflg;
! 390: };
! 391:
! 392: static int
! 393: svr4_msgsnd(p, v, retval)
! 394: struct proc *p;
! 395: void *v;
! 396: register_t *retval;
! 397: {
! 398: struct svr4_sys_msgsnd_args *uap = v;
! 399: struct sys_msgsnd_args ap;
! 400:
! 401: SCARG(&ap, msqid) = SCARG(uap, msqid);
! 402: SCARG(&ap, msgp) = SCARG(uap, msgp);
! 403: SCARG(&ap, msgsz) = SCARG(uap, msgsz);
! 404: SCARG(&ap, msgflg) = SCARG(uap, msgflg);
! 405:
! 406: return sys_msgsnd(p, &ap, retval);
! 407: }
! 408:
! 409: struct svr4_sys_msgrcv_args {
! 410: syscallarg(int) what;
! 411: syscallarg(int) msqid;
! 412: syscallarg(void *) msgp;
! 413: syscallarg(size_t) msgsz;
! 414: syscallarg(long) msgtyp;
! 415: syscallarg(int) msgflg;
! 416: };
! 417:
! 418: static int
! 419: svr4_msgrcv(p, v, retval)
! 420: struct proc *p;
! 421: void *v;
! 422: register_t *retval;
! 423: {
! 424: struct svr4_sys_msgrcv_args *uap = v;
! 425: struct sys_msgrcv_args ap;
! 426:
! 427: SCARG(&ap, msqid) = SCARG(uap, msqid);
! 428: SCARG(&ap, msgp) = SCARG(uap, msgp);
! 429: SCARG(&ap, msgsz) = SCARG(uap, msgsz);
! 430: SCARG(&ap, msgtyp) = SCARG(uap, msgtyp);
! 431: SCARG(&ap, msgflg) = SCARG(uap, msgflg);
! 432:
! 433: return sys_msgrcv(p, &ap, retval);
! 434: }
! 435:
! 436: struct svr4_sys_msgget_args {
! 437: syscallarg(int) what;
! 438: syscallarg(svr4_key_t) key;
! 439: syscallarg(int) msgflg;
! 440: };
! 441:
! 442: static int
! 443: svr4_msgget(p, v, retval)
! 444: struct proc *p;
! 445: void *v;
! 446: register_t *retval;
! 447: {
! 448: struct svr4_sys_msgget_args *uap = v;
! 449: struct sys_msgget_args ap;
! 450:
! 451: SCARG(&ap, key) = SCARG(uap, key);
! 452: SCARG(&ap, msgflg) = SCARG(uap, msgflg);
! 453:
! 454: return sys_msgget(p, &ap, retval);
! 455: }
! 456:
! 457: struct svr4_sys_msgctl_args {
! 458: syscallarg(int) what;
! 459: syscallarg(int) msqid;
! 460: syscallarg(int) cmd;
! 461: syscallarg(struct svr4_msqid_ds *) buf;
! 462: };
! 463:
! 464: static int
! 465: svr4_msgctl(p, v, retval)
! 466: struct proc *p;
! 467: void *v;
! 468: register_t *retval;
! 469: {
! 470: int error;
! 471: struct svr4_sys_msgctl_args *uap = v;
! 472: struct sys_msgctl_args ap;
! 473: struct svr4_msqid_ds ss;
! 474: struct msqid_ds bs;
! 475: caddr_t sg = stackgap_init(p->p_emul);
! 476:
! 477: SCARG(&ap, msqid) = SCARG(uap, msqid);
! 478: SCARG(&ap, cmd) = SCARG(uap, cmd);
! 479: SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof(bs));
! 480:
! 481: switch (SCARG(uap, cmd)) {
! 482: case SVR4_IPC_STAT:
! 483: SCARG(&ap, cmd) = IPC_STAT;
! 484: if ((error = sys_msgctl(p, &ap, retval)) != 0)
! 485: return error;
! 486: error = copyin(SCARG(&ap, buf), &bs, sizeof bs);
! 487: if (error)
! 488: return error;
! 489: bsd_to_svr4_msqid_ds(&bs, &ss);
! 490: return copyout(&ss, SCARG(uap, buf), sizeof ss);
! 491:
! 492: case SVR4_IPC_SET:
! 493: SCARG(&ap, cmd) = IPC_SET;
! 494: error = copyin(SCARG(uap, buf), &ss, sizeof ss);
! 495: if (error)
! 496: return error;
! 497: svr4_to_bsd_msqid_ds(&ss, &bs);
! 498: error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
! 499: if (error)
! 500: return error;
! 501: return sys_msgctl(p, &ap, retval);
! 502:
! 503: case SVR4_IPC_RMID:
! 504: SCARG(&ap, cmd) = IPC_RMID;
! 505: error = copyin(SCARG(uap, buf), &ss, sizeof ss);
! 506: if (error)
! 507: return error;
! 508: svr4_to_bsd_msqid_ds(&ss, &bs);
! 509: error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
! 510: if (error)
! 511: return error;
! 512: return sys_msgctl(p, &ap, retval);
! 513:
! 514: default:
! 515: return EINVAL;
! 516: }
! 517: }
! 518:
! 519: int
! 520: svr4_sys_msgsys(p, v, retval)
! 521: struct proc *p;
! 522: void *v;
! 523: register_t *retval;
! 524: {
! 525: struct svr4_sys_msgsys_args *uap = v;
! 526:
! 527: DPRINTF(("svr4_msgsys(%d)\n", SCARG(uap, what)));
! 528:
! 529: switch (SCARG(uap, what)) {
! 530: case SVR4_msgsnd:
! 531: return svr4_msgsnd(p, v, retval);
! 532: case SVR4_msgrcv:
! 533: return svr4_msgrcv(p, v, retval);
! 534: case SVR4_msgget:
! 535: return svr4_msgget(p, v, retval);
! 536: case SVR4_msgctl:
! 537: return svr4_msgctl(p, v, retval);
! 538: default:
! 539: return EINVAL;
! 540: }
! 541: }
! 542: #endif
! 543:
! 544: #ifdef SYSVSHM
! 545:
! 546: static void
! 547: bsd_to_svr4_shmid_ds(bds, sds)
! 548: const struct shmid_ds *bds;
! 549: struct svr4_shmid_ds *sds;
! 550: {
! 551: bsd_to_svr4_ipc_perm(&bds->shm_perm, &sds->shm_perm);
! 552: sds->shm_segsz = bds->shm_segsz;
! 553: sds->shm_lkcnt = 0;
! 554: sds->shm_lpid = bds->shm_lpid;
! 555: sds->shm_cpid = bds->shm_cpid;
! 556: sds->shm_amp = bds->shm_internal;
! 557: sds->shm_nattch = bds->shm_nattch;
! 558: sds->shm_cnattch = 0;
! 559: sds->shm_atime = bds->shm_atime;
! 560: sds->shm_pad1 = 0;
! 561: sds->shm_dtime = bds->shm_dtime;
! 562: sds->shm_pad2 = 0;
! 563: sds->shm_ctime = bds->shm_ctime;
! 564: sds->shm_pad3 = 0;
! 565: }
! 566:
! 567: static void
! 568: svr4_to_bsd_shmid_ds(sds, bds)
! 569: const struct svr4_shmid_ds *sds;
! 570: struct shmid_ds *bds;
! 571: {
! 572: svr4_to_bsd_ipc_perm(&sds->shm_perm, &bds->shm_perm);
! 573: bds->shm_segsz = sds->shm_segsz;
! 574: bds->shm_lpid = sds->shm_lpid;
! 575: bds->shm_cpid = sds->shm_cpid;
! 576: bds->shm_internal = sds->shm_amp;
! 577: bds->shm_nattch = sds->shm_nattch;
! 578: bds->shm_atime = sds->shm_atime;
! 579: bds->shm_dtime = sds->shm_dtime;
! 580: bds->shm_ctime = sds->shm_ctime;
! 581: }
! 582:
! 583: struct svr4_sys_shmat_args {
! 584: syscallarg(int) what;
! 585: syscallarg(int) shmid;
! 586: syscallarg(void *) shmaddr;
! 587: syscallarg(int) shmflg;
! 588: };
! 589:
! 590: static int
! 591: svr4_shmat(p, v, retval)
! 592: struct proc *p;
! 593: void *v;
! 594: register_t *retval;
! 595: {
! 596: struct svr4_sys_shmat_args *uap = v;
! 597: struct sys_shmat_args ap;
! 598:
! 599: SCARG(&ap, shmid) = SCARG(uap, shmid);
! 600: SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
! 601: SCARG(&ap, shmflg) = SCARG(uap, shmflg);
! 602:
! 603: return sys_shmat(p, &ap, retval);
! 604: }
! 605:
! 606: struct svr4_sys_shmdt_args {
! 607: syscallarg(int) what;
! 608: syscallarg(void *) shmaddr;
! 609: };
! 610:
! 611: static int
! 612: svr4_shmdt(p, v, retval)
! 613: struct proc *p;
! 614: void *v;
! 615: register_t *retval;
! 616: {
! 617: struct svr4_sys_shmdt_args *uap = v;
! 618: struct sys_shmdt_args ap;
! 619:
! 620: SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
! 621:
! 622: return sys_shmdt(p, &ap, retval);
! 623: }
! 624:
! 625: struct svr4_sys_shmget_args {
! 626: syscallarg(int) what;
! 627: syscallarg(key_t) key;
! 628: syscallarg(int) size;
! 629: syscallarg(int) shmflg;
! 630: };
! 631:
! 632: static int
! 633: svr4_shmget(p, v, retval)
! 634: struct proc *p;
! 635: void *v;
! 636: register_t *retval;
! 637: {
! 638: struct svr4_sys_shmget_args *uap = v;
! 639: struct sys_shmget_args ap;
! 640:
! 641: SCARG(&ap, key) = SCARG(uap, key);
! 642: SCARG(&ap, size) = SCARG(uap, size);
! 643: SCARG(&ap, shmflg) = SCARG(uap, shmflg);
! 644:
! 645: return sys_shmget(p, &ap, retval);
! 646: }
! 647:
! 648: struct svr4_sys_shmctl_args {
! 649: syscallarg(int) what;
! 650: syscallarg(int) shmid;
! 651: syscallarg(int) cmd;
! 652: syscallarg(struct svr4_shmid_ds *) buf;
! 653: };
! 654:
! 655: int
! 656: svr4_shmctl(p, v, retval)
! 657: struct proc *p;
! 658: void *v;
! 659: register_t *retval;
! 660: {
! 661: struct svr4_sys_shmctl_args *uap = v;
! 662: int error;
! 663: caddr_t sg = stackgap_init(p->p_emul);
! 664: struct sys_shmctl_args ap;
! 665: struct shmid_ds bs;
! 666: struct svr4_shmid_ds ss;
! 667:
! 668: SCARG(&ap, shmid) = SCARG(uap, shmid);
! 669:
! 670: if (SCARG(uap, buf) != NULL) {
! 671: SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof (struct shmid_ds));
! 672: switch (SCARG(uap, cmd)) {
! 673: case SVR4_IPC_SET:
! 674: case SVR4_IPC_RMID:
! 675: case SVR4_SHM_LOCK:
! 676: case SVR4_SHM_UNLOCK:
! 677: error = copyin(SCARG(uap, buf), (caddr_t) &ss,
! 678: sizeof ss);
! 679: if (error)
! 680: return error;
! 681: svr4_to_bsd_shmid_ds(&ss, &bs);
! 682: error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
! 683: if (error)
! 684: return error;
! 685: break;
! 686: default:
! 687: break;
! 688: }
! 689: }
! 690: else
! 691: SCARG(&ap, buf) = NULL;
! 692:
! 693:
! 694: switch (SCARG(uap, cmd)) {
! 695: case SVR4_IPC_STAT:
! 696: SCARG(&ap, cmd) = IPC_STAT;
! 697: if ((error = sys_shmctl(p, &ap, retval)) != 0)
! 698: return error;
! 699: if (SCARG(uap, buf) == NULL)
! 700: return 0;
! 701: error = copyin(SCARG(&ap, buf), &bs, sizeof bs);
! 702: if (error)
! 703: return error;
! 704: bsd_to_svr4_shmid_ds(&bs, &ss);
! 705: return copyout(&ss, SCARG(uap, buf), sizeof ss);
! 706:
! 707: case SVR4_IPC_SET:
! 708: SCARG(&ap, cmd) = IPC_SET;
! 709: return sys_shmctl(p, &ap, retval);
! 710:
! 711: case SVR4_IPC_RMID:
! 712: case SVR4_SHM_LOCK:
! 713: case SVR4_SHM_UNLOCK:
! 714: switch (SCARG(uap, cmd)) {
! 715: case SVR4_IPC_RMID:
! 716: SCARG(&ap, cmd) = IPC_RMID;
! 717: break;
! 718: case SVR4_SHM_LOCK:
! 719: SCARG(&ap, cmd) = SHM_LOCK;
! 720: break;
! 721: case SVR4_SHM_UNLOCK:
! 722: SCARG(&ap, cmd) = SHM_UNLOCK;
! 723: break;
! 724: default:
! 725: return EINVAL;
! 726: }
! 727: return sys_shmctl(p, &ap, retval);
! 728:
! 729: default:
! 730: return EINVAL;
! 731: }
! 732: }
! 733:
! 734: int
! 735: svr4_sys_shmsys(p, v, retval)
! 736: struct proc *p;
! 737: void *v;
! 738: register_t *retval;
! 739: {
! 740: struct svr4_sys_shmsys_args *uap = v;
! 741:
! 742: DPRINTF(("svr4_shmsys(%d)\n", SCARG(uap, what)));
! 743:
! 744: switch (SCARG(uap, what)) {
! 745: case SVR4_shmat:
! 746: return svr4_shmat(p, v, retval);
! 747: case SVR4_shmdt:
! 748: return svr4_shmdt(p, v, retval);
! 749: case SVR4_shmget:
! 750: return svr4_shmget(p, v, retval);
! 751: case SVR4_shmctl:
! 752: return svr4_shmctl(p, v, retval);
! 753: default:
! 754: return ENOSYS;
! 755: }
! 756: }
! 757: #endif /* SYSVSHM */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to svr4_ipc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4