![[BACK]](/icons/back.gif){kind=icon}
Return to sysv_msg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to sysv_msg.c CVS log | Up to [local] / sys / kern |
1.1 ! nbrk 1: /* $OpenBSD: sysv_msg.c,v 1.19 2005/12/13 10:33:14 jsg Exp $ */
! 2: /* $NetBSD: sysv_msg.c,v 1.19 1996/02/09 19:00:18 christos Exp $ */
! 3:
! 4: /*
! 5: * Implementation of SVID messages
! 6: *
! 7: * Author: Daniel Boulet
! 8: *
! 9: * Copyright 1993 Daniel Boulet and RTMX Inc.
! 10: *
! 11: * This system call was implemented by Daniel Boulet under contract from RTMX.
! 12: *
! 13: * Redistribution and use in source forms, with and without modification,
! 14: * are permitted provided that this entire comment appears intact.
! 15: *
! 16: * Redistribution in binary form may occur without any restrictions.
! 17: * Obviously, it would be nice if you gave credit where credit is due
! 18: * but requiring it would be too onerous.
! 19: *
! 20: * This software is provided ``AS IS'' without any warranties of any kind.
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/kernel.h>
! 26: #include <sys/proc.h>
! 27: #include <sys/msg.h>
! 28: #include <sys/malloc.h>
! 29:
! 30: #include <sys/mount.h>
! 31: #include <sys/syscallargs.h>
! 32:
! 33: #ifdef MSG_DEBUG
! 34: #define DPRINTF(x) printf x
! 35: #else
! 36: #define DPRINTF(x)
! 37: #endif
! 38:
! 39: /* XXX - OpenBSD doesn't have EIDRM or ENOMSG */
! 40: #ifndef EIDRM
! 41: #define EIDRM EINVAL
! 42: #endif
! 43: #ifndef ENOMSG
! 44: #define ENOMSG EAGAIN
! 45: #endif
! 46:
! 47: int nfree_msgmaps; /* # of free map entries */
! 48: short free_msgmaps; /* head of linked list of free map entries */
! 49: struct msg *free_msghdrs; /* list of free msg headers */
! 50: char *msgpool; /* MSGMAX byte long msg buffer pool */
! 51: struct msgmap *msgmaps; /* MSGSEG msgmap structures */
! 52: struct msg *msghdrs; /* MSGTQL msg headers */
! 53: struct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */
! 54:
! 55: void msg_freehdr(struct msg *);
! 56:
! 57: void
! 58: msginit(void)
! 59: {
! 60: int i;
! 61:
! 62: /*
! 63: * msginfo.msgssz should be a power of two for efficiency reasons.
! 64: * It is also pretty silly if msginfo.msgssz is less than 8
! 65: * or greater than about 256 so ...
! 66: */
! 67:
! 68: i = 8;
! 69: while (i < 1024 && i != msginfo.msgssz)
! 70: i <<= 1;
! 71:
! 72: if (i != msginfo.msgssz)
! 73: panic("msginfo.msgssz %d not a small power of 2", msginfo.msgssz);
! 74: if (msginfo.msgseg > 32767)
! 75: panic("msginfo.msgseg %d > 32767", msginfo.msgseg);
! 76:
! 77: if (msgmaps == NULL)
! 78: panic("msgmaps is NULL");
! 79:
! 80: for (i = 0; i < msginfo.msgseg; i++) {
! 81: if (i > 0)
! 82: msgmaps[i-1].next = i;
! 83: msgmaps[i].next = -1; /* implies entry is available */
! 84: }
! 85: free_msgmaps = 0;
! 86: nfree_msgmaps = msginfo.msgseg;
! 87:
! 88: if (msghdrs == NULL)
! 89: panic("msghdrs is NULL");
! 90:
! 91: for (i = 0; i < msginfo.msgtql; i++) {
! 92: msghdrs[i].msg_type = 0;
! 93: if (i > 0)
! 94: msghdrs[i-1].msg_next = &msghdrs[i];
! 95: msghdrs[i].msg_next = NULL;
! 96: }
! 97: free_msghdrs = &msghdrs[0];
! 98:
! 99: if (msqids == NULL)
! 100: panic("msqids is NULL");
! 101:
! 102: for (i = 0; i < msginfo.msgmni; i++) {
! 103: msqids[i].msg_qbytes = 0; /* implies entry is available */
! 104: msqids[i].msg_perm.seq = 0; /* reset to a known value */
! 105: }
! 106: }
! 107:
! 108: void
! 109: msg_freehdr(struct msg *msghdr)
! 110: {
! 111: while (msghdr->msg_ts > 0) {
! 112: short next;
! 113:
! 114: #ifdef DIAGNOSTIC
! 115: if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg)
! 116: panic("msghdr->msg_spot out of range");
! 117: #endif
! 118: next = msgmaps[msghdr->msg_spot].next;
! 119: msgmaps[msghdr->msg_spot].next = free_msgmaps;
! 120: free_msgmaps = msghdr->msg_spot;
! 121: nfree_msgmaps++;
! 122: msghdr->msg_spot = next;
! 123: if (msghdr->msg_ts >= msginfo.msgssz)
! 124: msghdr->msg_ts -= msginfo.msgssz;
! 125: else
! 126: msghdr->msg_ts = 0;
! 127: }
! 128: #ifdef DIAGNOSTIC
! 129: if (msghdr->msg_spot != -1)
! 130: panic("msghdr->msg_spot != -1");
! 131: #endif
! 132: msghdr->msg_next = free_msghdrs;
! 133: free_msghdrs = msghdr;
! 134: }
! 135:
! 136: int
! 137: sys_msgctl(struct proc *p, void *v, register_t *retval)
! 138: {
! 139: struct sys_msgctl_args /* {
! 140: syscallarg(int) msqid;
! 141: syscallarg(int) cmd;
! 142: syscallarg(struct msqid_ds *) buf;
! 143: } */ *uap = v;
! 144:
! 145: return (msgctl1(p, SCARG(uap, msqid), SCARG(uap, cmd),
! 146: (caddr_t)SCARG(uap, buf), copyin, copyout));
! 147: }
! 148:
! 149: int
! 150: msgctl1(struct proc *p, int msqid, int cmd, caddr_t buf,
! 151: int (*ds_copyin)(const void *, void *, size_t),
! 152: int (*ds_copyout)(const void *, void *, size_t))
! 153: {
! 154: struct ucred *cred = p->p_ucred;
! 155: struct msqid_ds msqbuf, *msqptr;
! 156: struct msg *msghdr;
! 157: int ix, error = 0;
! 158:
! 159: DPRINTF(("call to msgctl(%d, %d, %p)\n", msqid, cmd, buf));
! 160:
! 161: ix = IPCID_TO_IX(msqid);
! 162:
! 163: if (ix < 0 || ix >= msginfo.msgmni) {
! 164: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", ix,
! 165: msginfo.msgmni));
! 166: return (EINVAL);
! 167: }
! 168:
! 169: msqptr = &msqids[ix];
! 170:
! 171: if (msqptr->msg_qbytes == 0) {
! 172: DPRINTF(("no such msqid\n"));
! 173: return (EINVAL);
! 174: }
! 175: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(msqid)) {
! 176: DPRINTF(("wrong sequence number\n"));
! 177: return (EINVAL);
! 178: }
! 179:
! 180: switch (cmd) {
! 181: case IPC_RMID:
! 182: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M)) != 0)
! 183: return (error);
! 184: /* Free the message headers */
! 185: msghdr = msqptr->msg_first;
! 186: while (msghdr != NULL) {
! 187: struct msg *msghdr_tmp;
! 188:
! 189: /* Free the segments of each message */
! 190: msqptr->msg_cbytes -= msghdr->msg_ts;
! 191: msqptr->msg_qnum--;
! 192: msghdr_tmp = msghdr;
! 193: msghdr = msghdr->msg_next;
! 194: msg_freehdr(msghdr_tmp);
! 195: }
! 196:
! 197: #ifdef DIAGNOSTIC
! 198: if (msqptr->msg_cbytes != 0)
! 199: panic("sys_msgctl: msg_cbytes is screwed up");
! 200: if (msqptr->msg_qnum != 0)
! 201: panic("sys_msgctl: msg_qnum is screwed up");
! 202: #endif
! 203: msqptr->msg_qbytes = 0; /* Mark it as free */
! 204: wakeup(msqptr);
! 205: break;
! 206:
! 207: case IPC_SET:
! 208: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M)))
! 209: return (error);
! 210: if ((error = ds_copyin(buf, &msqbuf, sizeof(msqbuf))) != 0)
! 211: return (error);
! 212: if (msqbuf.msg_qbytes > msqptr->msg_qbytes &&
! 213: cred->cr_uid != 0)
! 214: return (EPERM);
! 215: if (msqbuf.msg_qbytes > msginfo.msgmnb) {
! 216: DPRINTF(("can't increase msg_qbytes beyond %d "
! 217: "(truncating)\n", msginfo.msgmnb));
! 218: /* silently restrict qbytes to system limit */
! 219: msqbuf.msg_qbytes = msginfo.msgmnb;
! 220: }
! 221: if (msqbuf.msg_qbytes == 0) {
! 222: DPRINTF(("can't reduce msg_qbytes to 0\n"));
! 223: return (EINVAL); /* non-standard errno! */
! 224: }
! 225: msqptr->msg_perm.uid = msqbuf.msg_perm.uid;
! 226: msqptr->msg_perm.gid = msqbuf.msg_perm.gid;
! 227: msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) |
! 228: (msqbuf.msg_perm.mode & 0777);
! 229: msqptr->msg_qbytes = msqbuf.msg_qbytes;
! 230: msqptr->msg_ctime = time_second;
! 231: break;
! 232:
! 233: case IPC_STAT:
! 234: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
! 235: DPRINTF(("requester doesn't have read access\n"));
! 236: return (error);
! 237: }
! 238: error = ds_copyout(msqptr, buf, sizeof(struct msqid_ds));
! 239: break;
! 240:
! 241: default:
! 242: DPRINTF(("invalid command %d\n", cmd));
! 243: return (EINVAL);
! 244: }
! 245: return (error);
! 246: }
! 247:
! 248: int
! 249: sys_msgget(struct proc *p, void *v, register_t *retval)
! 250: {
! 251: struct sys_msgget_args /* {
! 252: syscallarg(key_t) key;
! 253: syscallarg(int) msgflg;
! 254: } */ *uap = v;
! 255: int msqid, eval;
! 256: int key = SCARG(uap, key);
! 257: int msgflg = SCARG(uap, msgflg);
! 258: struct ucred *cred = p->p_ucred;
! 259: struct msqid_ds *msqptr = NULL;
! 260:
! 261: DPRINTF(("msgget(0x%x, 0%o)\n", key, msgflg));
! 262:
! 263: if (key != IPC_PRIVATE) {
! 264: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
! 265: msqptr = &msqids[msqid];
! 266: if (msqptr->msg_qbytes != 0 &&
! 267: msqptr->msg_perm.key == key)
! 268: break;
! 269: }
! 270: if (msqid < msginfo.msgmni) {
! 271: DPRINTF(("found public key\n"));
! 272: if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) {
! 273: DPRINTF(("not exclusive\n"));
! 274: return (EEXIST);
! 275: }
! 276: if ((eval = ipcperm(cred, &msqptr->msg_perm, msgflg & 0700 ))) {
! 277: DPRINTF(("requester doesn't have 0%o access\n",
! 278: msgflg & 0700));
! 279: return (eval);
! 280: }
! 281: goto found;
! 282: }
! 283: }
! 284:
! 285: DPRINTF(("need to allocate the msqid_ds\n"));
! 286: if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) {
! 287: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
! 288: /*
! 289: * Look for an unallocated and unlocked msqid_ds.
! 290: * msqid_ds's can be locked by msgsnd or msgrcv while
! 291: * they are copying the message in/out. We can't
! 292: * re-use the entry until they release it.
! 293: */
! 294: msqptr = &msqids[msqid];
! 295: if (msqptr->msg_qbytes == 0 &&
! 296: (msqptr->msg_perm.mode & MSG_LOCKED) == 0)
! 297: break;
! 298: }
! 299: if (msqid == msginfo.msgmni) {
! 300: DPRINTF(("no more msqid_ds's available\n"));
! 301: return (ENOSPC);
! 302: }
! 303: DPRINTF(("msqid %d is available\n", msqid));
! 304: msqptr->msg_perm.key = key;
! 305: msqptr->msg_perm.cuid = cred->cr_uid;
! 306: msqptr->msg_perm.uid = cred->cr_uid;
! 307: msqptr->msg_perm.cgid = cred->cr_gid;
! 308: msqptr->msg_perm.gid = cred->cr_gid;
! 309: msqptr->msg_perm.mode = (msgflg & 0777);
! 310: /* Make sure that the returned msqid is unique */
! 311: msqptr->msg_perm.seq = (msqptr->msg_perm.seq + 1) & 0x7fff;
! 312: msqptr->msg_first = NULL;
! 313: msqptr->msg_last = NULL;
! 314: msqptr->msg_cbytes = 0;
! 315: msqptr->msg_qnum = 0;
! 316: msqptr->msg_qbytes = msginfo.msgmnb;
! 317: msqptr->msg_lspid = 0;
! 318: msqptr->msg_lrpid = 0;
! 319: msqptr->msg_stime = 0;
! 320: msqptr->msg_rtime = 0;
! 321: msqptr->msg_ctime = time_second;
! 322: } else {
! 323: DPRINTF(("didn't find it and wasn't asked to create it\n"));
! 324: return (ENOENT);
! 325: }
! 326:
! 327: found:
! 328: /* Construct the unique msqid */
! 329: *retval = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm);
! 330: return (0);
! 331: }
! 332:
! 333: int
! 334: sys_msgsnd(struct proc *p, void *v, register_t *retval)
! 335: {
! 336: struct sys_msgsnd_args /* {
! 337: syscallarg(int) msqid;
! 338: syscallarg(const void *) msgp;
! 339: syscallarg(size_t) msgsz;
! 340: syscallarg(int) msgflg;
! 341: } */ *uap = v;
! 342: int msqid = SCARG(uap, msqid);
! 343: const char *user_msgp = SCARG(uap, msgp);
! 344: size_t msgsz = SCARG(uap, msgsz);
! 345: int msgflg = SCARG(uap, msgflg);
! 346: int segs_needed, eval;
! 347: struct ucred *cred = p->p_ucred;
! 348: struct msqid_ds *msqptr;
! 349: struct msg *msghdr;
! 350: short next;
! 351:
! 352: DPRINTF(("call to msgsnd(%d, %p, %d, %d)\n", msqid, user_msgp, msgsz,
! 353: msgflg));
! 354:
! 355: msqid = IPCID_TO_IX(msqid);
! 356:
! 357: if (msqid < 0 || msqid >= msginfo.msgmni) {
! 358: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
! 359: msginfo.msgmni));
! 360: return (EINVAL);
! 361: }
! 362:
! 363: msqptr = &msqids[msqid];
! 364: if (msqptr->msg_qbytes == 0) {
! 365: DPRINTF(("no such message queue id\n"));
! 366: return (EINVAL);
! 367: }
! 368: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
! 369: DPRINTF(("wrong sequence number\n"));
! 370: return (EINVAL);
! 371: }
! 372:
! 373: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_W))) {
! 374: DPRINTF(("requester doesn't have write access\n"));
! 375: return (eval);
! 376: }
! 377:
! 378: segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz;
! 379: DPRINTF(("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz,
! 380: msginfo.msgssz, segs_needed));
! 381: for (;;) {
! 382: int need_more_resources = 0;
! 383:
! 384: /*
! 385: * check msgsz [cannot be negative since it is unsigned]
! 386: * (inside this loop in case msg_qbytes changes while we sleep)
! 387: */
! 388:
! 389: if (msgsz > msqptr->msg_qbytes) {
! 390: DPRINTF(("msgsz > msqptr->msg_qbytes\n"));
! 391: return (EINVAL);
! 392: }
! 393:
! 394: if (msqptr->msg_perm.mode & MSG_LOCKED) {
! 395: DPRINTF(("msqid is locked\n"));
! 396: need_more_resources = 1;
! 397: }
! 398: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) {
! 399: DPRINTF(("msgsz + msg_cbytes > msg_qbytes\n"));
! 400: need_more_resources = 1;
! 401: }
! 402: if (segs_needed > nfree_msgmaps) {
! 403: DPRINTF(("segs_needed > nfree_msgmaps\n"));
! 404: need_more_resources = 1;
! 405: }
! 406: if (free_msghdrs == NULL) {
! 407: DPRINTF(("no more msghdrs\n"));
! 408: need_more_resources = 1;
! 409: }
! 410:
! 411: if (need_more_resources) {
! 412: int we_own_it;
! 413:
! 414: if ((msgflg & IPC_NOWAIT) != 0) {
! 415: DPRINTF(("need more resources but caller "
! 416: "doesn't want to wait\n"));
! 417: return (EAGAIN);
! 418: }
! 419:
! 420: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) {
! 421: DPRINTF(("we don't own the msqid_ds\n"));
! 422: we_own_it = 0;
! 423: } else {
! 424: /* Force later arrivals to wait for our
! 425: request */
! 426: DPRINTF(("we own the msqid_ds\n"));
! 427: msqptr->msg_perm.mode |= MSG_LOCKED;
! 428: we_own_it = 1;
! 429: }
! 430: DPRINTF(("goodnight\n"));
! 431: eval = tsleep(msqptr, (PZERO - 4) | PCATCH,
! 432: "msgwait", 0);
! 433: DPRINTF(("good morning, eval=%d\n", eval));
! 434: if (we_own_it)
! 435: msqptr->msg_perm.mode &= ~MSG_LOCKED;
! 436: if (eval != 0) {
! 437: DPRINTF(("msgsnd: interrupted system call\n"));
! 438: return (EINTR);
! 439: }
! 440:
! 441: /*
! 442: * Make sure that the msq queue still exists
! 443: */
! 444:
! 445: if (msqptr->msg_qbytes == 0) {
! 446: DPRINTF(("msqid deleted\n"));
! 447: return (EIDRM);
! 448: }
! 449:
! 450: } else {
! 451: DPRINTF(("got all the resources that we need\n"));
! 452: break;
! 453: }
! 454: }
! 455:
! 456: /*
! 457: * We have the resources that we need.
! 458: * Make sure!
! 459: */
! 460:
! 461: #ifdef DIAGNOSTIC
! 462: if (msqptr->msg_perm.mode & MSG_LOCKED)
! 463: panic("msg_perm.mode & MSG_LOCKED");
! 464: if (segs_needed > nfree_msgmaps)
! 465: panic("segs_needed > nfree_msgmaps");
! 466: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes)
! 467: panic("msgsz + msg_cbytes > msg_qbytes");
! 468: if (free_msghdrs == NULL)
! 469: panic("no more msghdrs");
! 470: #endif
! 471:
! 472: /*
! 473: * Re-lock the msqid_ds in case we page-fault when copying in the
! 474: * message
! 475: */
! 476:
! 477: #ifdef DIAGNOSTIC
! 478: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0)
! 479: panic("msqid_ds is already locked");
! 480: #endif
! 481: msqptr->msg_perm.mode |= MSG_LOCKED;
! 482:
! 483: /*
! 484: * Allocate a message header
! 485: */
! 486:
! 487: msghdr = free_msghdrs;
! 488: free_msghdrs = msghdr->msg_next;
! 489: msghdr->msg_spot = -1;
! 490: msghdr->msg_ts = msgsz;
! 491:
! 492: /*
! 493: * Allocate space for the message
! 494: */
! 495:
! 496: while (segs_needed > 0) {
! 497: #ifdef DIAGNOSTIC
! 498: if (nfree_msgmaps <= 0)
! 499: panic("not enough msgmaps");
! 500: if (free_msgmaps == -1)
! 501: panic("nil free_msgmaps");
! 502: #endif
! 503: next = free_msgmaps;
! 504: #ifdef DIAGNOSTIC
! 505: if (next <= -1)
! 506: panic("next too low #1");
! 507: if (next >= msginfo.msgseg)
! 508: panic("next out of range #1");
! 509: #endif
! 510: DPRINTF(("allocating segment %d to message\n", next));
! 511: free_msgmaps = msgmaps[next].next;
! 512: nfree_msgmaps--;
! 513: msgmaps[next].next = msghdr->msg_spot;
! 514: msghdr->msg_spot = next;
! 515: segs_needed--;
! 516: }
! 517:
! 518: /*
! 519: * Copy in the message type
! 520: */
! 521:
! 522: if ((eval = copyin(user_msgp, &msghdr->msg_type,
! 523: sizeof(msghdr->msg_type))) != 0) {
! 524: DPRINTF(("error %d copying the message type\n", eval));
! 525: msg_freehdr(msghdr);
! 526: msqptr->msg_perm.mode &= ~MSG_LOCKED;
! 527: wakeup(msqptr);
! 528: return (eval);
! 529: }
! 530: user_msgp += sizeof(msghdr->msg_type);
! 531:
! 532: /*
! 533: * Validate the message type
! 534: */
! 535:
! 536: if (msghdr->msg_type < 1) {
! 537: msg_freehdr(msghdr);
! 538: msqptr->msg_perm.mode &= ~MSG_LOCKED;
! 539: wakeup(msqptr);
! 540: DPRINTF(("mtype (%d) < 1\n", msghdr->msg_type));
! 541: return (EINVAL);
! 542: }
! 543:
! 544: /*
! 545: * Copy in the message body
! 546: */
! 547:
! 548: next = msghdr->msg_spot;
! 549: while (msgsz > 0) {
! 550: size_t tlen;
! 551: if (msgsz > msginfo.msgssz)
! 552: tlen = msginfo.msgssz;
! 553: else
! 554: tlen = msgsz;
! 555: #ifdef DIAGNOSTIC
! 556: if (next <= -1)
! 557: panic("next too low #2");
! 558: if (next >= msginfo.msgseg)
! 559: panic("next out of range #2");
! 560: #endif
! 561: if ((eval = copyin(user_msgp, &msgpool[next * msginfo.msgssz],
! 562: tlen)) != 0) {
! 563: DPRINTF(("error %d copying in message segment\n",
! 564: eval));
! 565: msg_freehdr(msghdr);
! 566: msqptr->msg_perm.mode &= ~MSG_LOCKED;
! 567: wakeup(msqptr);
! 568: return (eval);
! 569: }
! 570: msgsz -= tlen;
! 571: user_msgp += tlen;
! 572: next = msgmaps[next].next;
! 573: }
! 574: #ifdef DIAGNOSTIC
! 575: if (next != -1)
! 576: panic("didn't use all the msg segments");
! 577: #endif
! 578: /*
! 579: * We've got the message. Unlock the msqid_ds.
! 580: */
! 581:
! 582: msqptr->msg_perm.mode &= ~MSG_LOCKED;
! 583:
! 584: /*
! 585: * Make sure that the msqid_ds is still allocated.
! 586: */
! 587:
! 588: if (msqptr->msg_qbytes == 0) {
! 589: msg_freehdr(msghdr);
! 590: wakeup(msqptr);
! 591: return (EIDRM);
! 592: }
! 593:
! 594: /*
! 595: * Put the message into the queue
! 596: */
! 597:
! 598: if (msqptr->msg_first == NULL) {
! 599: msqptr->msg_first = msghdr;
! 600: msqptr->msg_last = msghdr;
! 601: } else {
! 602: msqptr->msg_last->msg_next = msghdr;
! 603: msqptr->msg_last = msghdr;
! 604: }
! 605: msqptr->msg_last->msg_next = NULL;
! 606:
! 607: msqptr->msg_cbytes += msghdr->msg_ts;
! 608: msqptr->msg_qnum++;
! 609: msqptr->msg_lspid = p->p_pid;
! 610: msqptr->msg_stime = time_second;
! 611:
! 612: wakeup(msqptr);
! 613: *retval = 0;
! 614: return (0);
! 615: }
! 616:
! 617: int
! 618: sys_msgrcv(struct proc *p, void *v, register_t *retval)
! 619: {
! 620: struct sys_msgrcv_args /* {
! 621: syscallarg(int) msqid;
! 622: syscallarg(void *) msgp;
! 623: syscallarg(size_t) msgsz;
! 624: syscallarg(long) msgtyp;
! 625: syscallarg(int) msgflg;
! 626: } */ *uap = v;
! 627: int msqid = SCARG(uap, msqid);
! 628: char *user_msgp = SCARG(uap, msgp);
! 629: size_t msgsz = SCARG(uap, msgsz);
! 630: long msgtyp = SCARG(uap, msgtyp);
! 631: int msgflg = SCARG(uap, msgflg);
! 632: size_t len;
! 633: struct ucred *cred = p->p_ucred;
! 634: struct msqid_ds *msqptr;
! 635: struct msg *msghdr;
! 636: int eval;
! 637: short next;
! 638:
! 639: DPRINTF(("call to msgrcv(%d, %p, %d, %ld, %d)\n", msqid, user_msgp,
! 640: msgsz, msgtyp, msgflg));
! 641:
! 642: msqid = IPCID_TO_IX(msqid);
! 643:
! 644: if (msqid < 0 || msqid >= msginfo.msgmni) {
! 645: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
! 646: msginfo.msgmni));
! 647: return (EINVAL);
! 648: }
! 649:
! 650: msqptr = &msqids[msqid];
! 651: if (msqptr->msg_qbytes == 0) {
! 652: DPRINTF(("no such message queue id\n"));
! 653: return (EINVAL);
! 654: }
! 655: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
! 656: DPRINTF(("wrong sequence number\n"));
! 657: return (EINVAL);
! 658: }
! 659:
! 660: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
! 661: DPRINTF(("requester doesn't have read access\n"));
! 662: return (eval);
! 663: }
! 664:
! 665: #if 0
! 666: /* cannot happen, msgsz is unsigned */
! 667: if (msgsz < 0) {
! 668: DPRINTF(("msgsz < 0\n"));
! 669: return (EINVAL);
! 670: }
! 671: #endif
! 672:
! 673: msghdr = NULL;
! 674: while (msghdr == NULL) {
! 675: if (msgtyp == 0) {
! 676: msghdr = msqptr->msg_first;
! 677: if (msghdr != NULL) {
! 678: if (msgsz < msghdr->msg_ts &&
! 679: (msgflg & MSG_NOERROR) == 0) {
! 680: DPRINTF(("first message on the queue "
! 681: "is too big (want %d, got %d)\n",
! 682: msgsz, msghdr->msg_ts));
! 683: return (E2BIG);
! 684: }
! 685: if (msqptr->msg_first == msqptr->msg_last) {
! 686: msqptr->msg_first = NULL;
! 687: msqptr->msg_last = NULL;
! 688: } else {
! 689: msqptr->msg_first = msghdr->msg_next;
! 690: #ifdef DIAGNOSTIC
! 691: if (msqptr->msg_first == NULL)
! 692: panic("msg_first/last screwed up #1");
! 693: #endif
! 694: }
! 695: }
! 696: } else {
! 697: struct msg *previous;
! 698: struct msg **prev;
! 699:
! 700: for (previous = NULL, prev = &msqptr->msg_first;
! 701: (msghdr = *prev) != NULL;
! 702: previous = msghdr, prev = &msghdr->msg_next) {
! 703: /*
! 704: * Is this message's type an exact match or is
! 705: * this message's type less than or equal to
! 706: * the absolute value of a negative msgtyp?
! 707: * Note that the second half of this test can
! 708: * NEVER be true if msgtyp is positive since
! 709: * msg_type is always positive!
! 710: */
! 711:
! 712: if (msgtyp == msghdr->msg_type ||
! 713: msghdr->msg_type <= -msgtyp) {
! 714: DPRINTF(("found message type %d, "
! 715: "requested %d\n", msghdr->msg_type,
! 716: msgtyp));
! 717: if (msgsz < msghdr->msg_ts &&
! 718: (msgflg & MSG_NOERROR) == 0) {
! 719: DPRINTF(("requested message on "
! 720: "the queue is too big "
! 721: "(want %d, got %d)\n",
! 722: msgsz, msghdr->msg_ts));
! 723: return (E2BIG);
! 724: }
! 725: *prev = msghdr->msg_next;
! 726: if (msghdr == msqptr->msg_last) {
! 727: if (previous == NULL) {
! 728: #ifdef DIAGNOSTIC
! 729: if (prev !=
! 730: &msqptr->msg_first)
! 731: panic("msg_first/last screwed up #2");
! 732: #endif
! 733: msqptr->msg_first =
! 734: NULL;
! 735: msqptr->msg_last =
! 736: NULL;
! 737: } else {
! 738: #ifdef DIAGNOSTIC
! 739: if (prev ==
! 740: &msqptr->msg_first)
! 741: panic("msg_first/last screwed up #3");
! 742: #endif
! 743: msqptr->msg_last =
! 744: previous;
! 745: }
! 746: }
! 747: break;
! 748: }
! 749: }
! 750: }
! 751:
! 752: /*
! 753: * We've either extracted the msghdr for the appropriate
! 754: * message or there isn't one.
! 755: * If there is one then bail out of this loop.
! 756: */
! 757:
! 758: if (msghdr != NULL)
! 759: break;
! 760:
! 761: /*
! 762: * Hmph! No message found. Does the user want to wait?
! 763: */
! 764:
! 765: if ((msgflg & IPC_NOWAIT) != 0) {
! 766: DPRINTF(("no appropriate message found (msgtyp=%d)\n",
! 767: msgtyp));
! 768: return (ENOMSG);
! 769: }
! 770:
! 771: /*
! 772: * Wait for something to happen
! 773: */
! 774:
! 775: DPRINTF(("msgrcv: goodnight\n"));
! 776: eval = tsleep(msqptr, (PZERO - 4) | PCATCH, "msgwait",
! 777: 0);
! 778: DPRINTF(("msgrcv: good morning (eval=%d)\n", eval));
! 779:
! 780: if (eval != 0) {
! 781: DPRINTF(("msgsnd: interrupted system call\n"));
! 782: return (EINTR);
! 783: }
! 784:
! 785: /*
! 786: * Make sure that the msq queue still exists
! 787: */
! 788:
! 789: if (msqptr->msg_qbytes == 0 ||
! 790: msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
! 791: DPRINTF(("msqid deleted\n"));
! 792: return (EIDRM);
! 793: }
! 794: }
! 795:
! 796: /*
! 797: * Return the message to the user.
! 798: *
! 799: * First, do the bookkeeping (before we risk being interrupted).
! 800: */
! 801:
! 802: msqptr->msg_cbytes -= msghdr->msg_ts;
! 803: msqptr->msg_qnum--;
! 804: msqptr->msg_lrpid = p->p_pid;
! 805: msqptr->msg_rtime = time_second;
! 806:
! 807: /*
! 808: * Make msgsz the actual amount that we'll be returning.
! 809: * Note that this effectively truncates the message if it is too long
! 810: * (since msgsz is never increased).
! 811: */
! 812:
! 813: DPRINTF(("found a message, msgsz=%d, msg_ts=%d\n", msgsz,
! 814: msghdr->msg_ts));
! 815: if (msgsz > msghdr->msg_ts)
! 816: msgsz = msghdr->msg_ts;
! 817:
! 818: /*
! 819: * Return the type to the user.
! 820: */
! 821:
! 822: eval = copyout(&msghdr->msg_type, user_msgp,
! 823: sizeof(msghdr->msg_type));
! 824: if (eval != 0) {
! 825: DPRINTF(("error (%d) copying out message type\n", eval));
! 826: msg_freehdr(msghdr);
! 827: wakeup(msqptr);
! 828: return (eval);
! 829: }
! 830: user_msgp += sizeof(msghdr->msg_type);
! 831:
! 832: /*
! 833: * Return the segments to the user
! 834: */
! 835:
! 836: next = msghdr->msg_spot;
! 837: for (len = 0; len < msgsz; len += msginfo.msgssz) {
! 838: size_t tlen;
! 839:
! 840: if (msgsz - len > msginfo.msgssz)
! 841: tlen = msginfo.msgssz;
! 842: else
! 843: tlen = msgsz - len;
! 844: #ifdef DIAGNOSTIC
! 845: if (next <= -1)
! 846: panic("next too low #3");
! 847: if (next >= msginfo.msgseg)
! 848: panic("next out of range #3");
! 849: #endif
! 850: eval = copyout(&msgpool[next * msginfo.msgssz],
! 851: user_msgp, tlen);
! 852: if (eval != 0) {
! 853: DPRINTF(("error (%d) copying out message segment\n",
! 854: eval));
! 855: msg_freehdr(msghdr);
! 856: wakeup(msqptr);
! 857: return (eval);
! 858: }
! 859: user_msgp += tlen;
! 860: next = msgmaps[next].next;
! 861: }
! 862:
! 863: /*
! 864: * Done, return the actual number of bytes copied out.
! 865: */
! 866:
! 867: msg_freehdr(msghdr);
! 868: wakeup(msqptr);
! 869: *retval = msgsz;
! 870: return (0);
! 871: }