ipc/msg.c

   1 /*
   2  * linux/ipc/msg.c
   3  * Copyright (C) 1992 Krishna Balasubramanian
   4  *
   5  * Removed all the remaining kerneld mess
   6  * Catch the -EFAULT stuff properly
   7  * Use GFP_KERNEL for messages as in 1.2
   8  * Fixed up the unchecked user space derefs
   9  * Copyright (C) 1998 Alan Cox & Andi Kleen
  10  *
  11  * /proc/sysvipc/msg support (c) 1999 Dragos Acostachioaie <dragos@iname.com>
  12  *
  13  * mostly rewritten, threaded and wake-one semantics added
  14  * MSGMAX limit removed, sysctl's added
  15  * (c) 1999 Manfred Spraul <manfreds@colorfullife.com>
  16  */
  17
  18 #include <linux/config.h>
  19 #include <linux/slab.h>
  20 #include <linux/msg.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/init.h>
  23 #include <linux/proc_fs.h>
  24 #include <linux/list.h>
  25 #include <linux/security.h>
  26 #include <linux/sched.h>
  27 #include <linux/vs_base.h>
  28
  29 #include <asm/current.h>
  30 #include <asm/uaccess.h>
  31 #include "util.h"
  32
  33 /* sysctl: */
  34 int msg_ctlmax = MSGMAX;
  35 int msg_ctlmnb = MSGMNB;
  36 int msg_ctlmni = MSGMNI;
  37
  38 /* one msg_receiver structure for each sleeping receiver */
  39 struct msg_receiver {
  40         struct list_head r_list;
  41         struct task_struct* r_tsk;
  42
  43         int r_mode;
  44         long r_msgtype;
  45         long r_maxsize;
  46
  47         struct msg_msg* volatile r_msg;
  48 };
  49
  50 /* one msg_sender for each sleeping sender */
  51 struct msg_sender {
  52         struct list_head list;
  53         struct task_struct* tsk;
  54 };
  55
  56 #define SEARCH_ANY              1
  57 #define SEARCH_EQUAL            2
  58 #define SEARCH_NOTEQUAL         3
  59 #define SEARCH_LESSEQUAL        4
  60
  61 static atomic_t msg_bytes = ATOMIC_INIT(0);
  62 static atomic_t msg_hdrs = ATOMIC_INIT(0);
  63
  64 static struct ipc_ids msg_ids;
  65
  66 #define msg_lock(id)    ((struct msg_queue*)ipc_lock(&msg_ids,id))
  67 #define msg_unlock(msq) ipc_unlock(&(msq)->q_perm)
  68 #define msg_rmid(id)    ((struct msg_queue*)ipc_rmid(&msg_ids,id))
  69 #define msg_checkid(msq, msgid) \
  70         ipc_checkid(&msg_ids,&msq->q_perm,msgid)
  71 #define msg_buildid(id, seq) \
  72         ipc_buildid(&msg_ids, id, seq)
  73
  74 static void freeque (struct msg_queue *msq, int id);
  75 static int newque (key_t key, int msgflg);
  76 #ifdef CONFIG_PROC_FS
  77 static int sysvipc_msg_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data);
  78 #endif
  79
  80 void __init msg_init (void)
  81 {
  82         ipc_init_ids(&msg_ids,msg_ctlmni);
  83
  84 #ifdef CONFIG_PROC_FS
  85         create_proc_read_entry("sysvipc/msg", 0, 0, sysvipc_msg_read_proc, NULL);
  86 #endif
  87 }
  88
  89 static int newque (key_t key, int msgflg)
  90 {
  91         int id;
  92         int retval;
  93         struct msg_queue *msq;
  94
  95         msq  = ipc_rcu_alloc(sizeof(*msq));
  96         if (!msq)
  97                 return -ENOMEM;
  98
  99         msq->q_perm.mode = (msgflg & S_IRWXUGO);
 100         msq->q_perm.key = key;
 101         msq->q_perm.xid = current->xid;
 102
 103         msq->q_perm.security = NULL;
 104         retval = security_msg_queue_alloc(msq);
 105         if (retval) {
 106                 ipc_rcu_free(msq, sizeof(*msq));
 107                 return retval;
 108         }
 109
 110         id = ipc_addid(&msg_ids, &msq->q_perm, msg_ctlmni);
 111         if(id == -1) {
 112                 security_msg_queue_free(msq);
 113                 ipc_rcu_free(msq, sizeof(*msq));
 114                 return -ENOSPC;
 115         }
 116
 117         msq->q_stime = msq->q_rtime = 0;
 118         msq->q_ctime = get_seconds();
 119         msq->q_cbytes = msq->q_qnum = 0;
 120         msq->q_qbytes = msg_ctlmnb;
 121         msq->q_lspid = msq->q_lrpid = 0;
 122         INIT_LIST_HEAD(&msq->q_messages);
 123         INIT_LIST_HEAD(&msq->q_receivers);
 124         INIT_LIST_HEAD(&msq->q_senders);
 125         msg_unlock(msq);
 126
 127         return msg_buildid(id,msq->q_perm.seq);
 128 }
 129
 130 static inline void ss_add(struct msg_queue* msq, struct msg_sender* mss)
 131 {
 132         mss->tsk=current;
 133         current->state=TASK_INTERRUPTIBLE;
 134         list_add_tail(&mss->list,&msq->q_senders);
 135 }
 136
 137 static inline void ss_del(struct msg_sender* mss)
 138 {
 139         if(mss->list.next != NULL)
 140                 list_del(&mss->list);
 141 }
 142
 143 static void ss_wakeup(struct list_head* h, int kill)
 144 {
 145         struct list_head *tmp;
 146
 147         tmp = h->next;
 148         while (tmp != h) {
 149                 struct msg_sender* mss;
 150
 151                 mss = list_entry(tmp,struct msg_sender,list);
 152                 tmp = tmp->next;
 153                 if(kill)
 154                         mss->list.next=NULL;
 155                 wake_up_process(mss->tsk);
 156         }
 157 }
 158
 159 static void expunge_all(struct msg_queue* msq, int res)
 160 {
 161         struct list_head *tmp;
 162
 163         tmp = msq->q_receivers.next;
 164         while (tmp != &msq->q_receivers) {
 165                 struct msg_receiver* msr;
 166
 167                 msr = list_entry(tmp,struct msg_receiver,r_list);
 168                 tmp = tmp->next;
 169                 msr->r_msg = ERR_PTR(res);
 170                 wake_up_process(msr->r_tsk);
 171         }
 172 }
 173 /*
 174  * freeque() wakes up waiters on the sender and receiver waiting queue,
 175  * removes the message queue from message queue ID
 176  * array, and cleans up all the messages associated with this queue.
 177  *
 178  * msg_ids.sem and the spinlock for this message queue is hold
 179  * before freeque() is called. msg_ids.sem remains locked on exit.
 180  */
 181 static void freeque (struct msg_queue *msq, int id)
 182 {
 183         struct list_head *tmp;
 184
 185         expunge_all(msq,-EIDRM);
 186         ss_wakeup(&msq->q_senders,1);
 187         msq = msg_rmid(id);
 188         msg_unlock(msq);
 189
 190         tmp = msq->q_messages.next;
 191         while(tmp != &msq->q_messages) {
 192                 struct msg_msg* msg = list_entry(tmp,struct msg_msg,m_list);
 193                 tmp = tmp->next;
 194                 atomic_dec(&msg_hdrs);
 195                 free_msg(msg);
 196         }
 197         atomic_sub(msq->q_cbytes, &msg_bytes);
 198         security_msg_queue_free(msq);
 199         ipc_rcu_free(msq, sizeof(struct msg_queue));
 200 }
 201
 202 asmlinkage long sys_msgget (key_t key, int msgflg)
 203 {
 204         int id, ret = -EPERM;
 205         struct msg_queue *msq;
 206
 207         down(&msg_ids.sem);
 208         if (key == IPC_PRIVATE)
 209                 ret = newque(key, msgflg);
 210         else if ((id = ipc_findkey(&msg_ids, key)) == -1) { /* key not used */
 211                 if (!(msgflg & IPC_CREAT))
 212                         ret = -ENOENT;
 213                 else
 214                         ret = newque(key, msgflg);
 215         } else if (msgflg & IPC_CREAT && msgflg & IPC_EXCL) {
 216                 ret = -EEXIST;
 217         } else {
 218                 msq = msg_lock(id);
 219                 if(msq==NULL)
 220                         BUG();
 221                 if (ipcperms(&msq->q_perm, msgflg))
 222                         ret = -EACCES;
 223                 else {
 224                         int qid = msg_buildid(id, msq->q_perm.seq);
 225                         ret = security_msg_queue_associate(msq, msgflg);
 226                         if (!ret)
 227                                 ret = qid;
 228                 }
 229                 msg_unlock(msq);
 230         }
 231         up(&msg_ids.sem);
 232         return ret;
 233 }
 234
 235 static inline unsigned long copy_msqid_to_user(void __user *buf, struct msqid64_ds *in, int version)
 236 {
 237         switch(version) {
 238         case IPC_64:
 239                 return copy_to_user (buf, in, sizeof(*in));
 240         case IPC_OLD:
 241             {
 242                 struct msqid_ds out;
 243
 244                 memset(&out,0,sizeof(out));
 245
 246                 ipc64_perm_to_ipc_perm(&in->msg_perm, &out.msg_perm);
 247
 248                 out.msg_stime           = in->msg_stime;
 249                 out.msg_rtime           = in->msg_rtime;
 250                 out.msg_ctime           = in->msg_ctime;
 251
 252                 if(in->msg_cbytes > USHRT_MAX)
 253                         out.msg_cbytes  = USHRT_MAX;
 254                 else
 255                         out.msg_cbytes  = in->msg_cbytes;
 256                 out.msg_lcbytes         = in->msg_cbytes;
 257
 258                 if(in->msg_qnum > USHRT_MAX)
 259                         out.msg_qnum    = USHRT_MAX;
 260                 else
 261                         out.msg_qnum    = in->msg_qnum;
 262
 263                 if(in->msg_qbytes > USHRT_MAX)
 264                         out.msg_qbytes  = USHRT_MAX;
 265                 else
 266                         out.msg_qbytes  = in->msg_qbytes;
 267                 out.msg_lqbytes         = in->msg_qbytes;
 268
 269                 out.msg_lspid           = in->msg_lspid;
 270                 out.msg_lrpid           = in->msg_lrpid;
 271
 272                 return copy_to_user (buf, &out, sizeof(out));
 273             }
 274         default:
 275                 return -EINVAL;
 276         }
 277 }
 278
 279 struct msq_setbuf {
 280         unsigned long   qbytes;
 281         uid_t           uid;
 282         gid_t           gid;
 283         mode_t          mode;
 284 };
 285
 286 static inline unsigned long copy_msqid_from_user(struct msq_setbuf *out, void __user *buf, int version)
 287 {
 288         switch(version) {
 289         case IPC_64:
 290             {
 291                 struct msqid64_ds tbuf;
 292
 293                 if (copy_from_user (&tbuf, buf, sizeof (tbuf)))
 294                         return -EFAULT;
 295
 296                 out->qbytes             = tbuf.msg_qbytes;
 297                 out->uid                = tbuf.msg_perm.uid;
 298                 out->gid                = tbuf.msg_perm.gid;
 299                 out->mode               = tbuf.msg_perm.mode;
 300
 301                 return 0;
 302             }
 303         case IPC_OLD:
 304             {
 305                 struct msqid_ds tbuf_old;
 306
 307                 if (copy_from_user (&tbuf_old, buf, sizeof (tbuf_old)))
 308                         return -EFAULT;
 309
 310                 out->uid                = tbuf_old.msg_perm.uid;
 311                 out->gid                = tbuf_old.msg_perm.gid;
 312                 out->mode               = tbuf_old.msg_perm.mode;
 313
 314                 if(tbuf_old.msg_qbytes == 0)
 315                         out->qbytes     = tbuf_old.msg_lqbytes;
 316                 else
 317                         out->qbytes     = tbuf_old.msg_qbytes;
 318
 319                 return 0;
 320             }
 321         default:
 322                 return -EINVAL;
 323         }
 324 }
 325
 326 asmlinkage long sys_msgctl (int msqid, int cmd, struct msqid_ds __user *buf)
 327 {
 328         int err, version;
 329         struct msg_queue *msq;
 330         struct msq_setbuf setbuf;
 331         struct kern_ipc_perm *ipcp;
 332
 333         if (msqid < 0 || cmd < 0)
 334                 return -EINVAL;
 335
 336         version = ipc_parse_version(&cmd);
 337
 338         switch (cmd) {
 339         case IPC_INFO:
 340         case MSG_INFO:
 341         {
 342                 struct msginfo msginfo;
 343                 int max_id;
 344                 if (!buf)
 345                         return -EFAULT;
 346                 /* We must not return kernel stack data.
 347                  * due to padding, it's not enough
 348                  * to set all member fields.
 349                  */
 350
 351                 err = security_msg_queue_msgctl(NULL, cmd);
 352                 if (err)
 353                         return err;
 354
 355                 memset(&msginfo,0,sizeof(msginfo));
 356                 msginfo.msgmni = msg_ctlmni;
 357                 msginfo.msgmax = msg_ctlmax;
 358                 msginfo.msgmnb = msg_ctlmnb;
 359                 msginfo.msgssz = MSGSSZ;
 360                 msginfo.msgseg = MSGSEG;
 361                 down(&msg_ids.sem);
 362                 if (cmd == MSG_INFO) {
 363                         msginfo.msgpool = msg_ids.in_use;
 364                         msginfo.msgmap = atomic_read(&msg_hdrs);
 365                         msginfo.msgtql = atomic_read(&msg_bytes);
 366                 } else {
 367                         msginfo.msgmap = MSGMAP;
 368                         msginfo.msgpool = MSGPOOL;
 369                         msginfo.msgtql = MSGTQL;
 370                 }
 371                 max_id = msg_ids.max_id;
 372                 up(&msg_ids.sem);
 373                 if (copy_to_user (buf, &msginfo, sizeof(struct msginfo)))
 374                         return -EFAULT;
 375                 return (max_id < 0) ? 0: max_id;
 376         }
 377         case MSG_STAT:
 378         case IPC_STAT:
 379         {
 380                 struct msqid64_ds tbuf;
 381                 int success_return;
 382                 if (!buf)
 383                         return -EFAULT;
 384                 if(cmd == MSG_STAT && msqid >= msg_ids.size)
 385                         return -EINVAL;
 386
 387                 memset(&tbuf,0,sizeof(tbuf));
 388
 389                 msq = msg_lock(msqid);
 390                 if (msq == NULL)
 391                         return -EINVAL;
 392
 393                 if(cmd == MSG_STAT) {
 394                         success_return = msg_buildid(msqid, msq->q_perm.seq);
 395                 } else {
 396                         err = -EIDRM;
 397                         if (msg_checkid(msq,msqid))
 398                                 goto out_unlock;
 399                         success_return = 0;
 400                 }
 401                 err = -EACCES;
 402                 if (ipcperms (&msq->q_perm, S_IRUGO))
 403                         goto out_unlock;
 404
 405                 err = security_msg_queue_msgctl(msq, cmd);
 406                 if (err)
 407                         goto out_unlock;
 408
 409                 kernel_to_ipc64_perm(&msq->q_perm, &tbuf.msg_perm);
 410                 tbuf.msg_stime  = msq->q_stime;
 411                 tbuf.msg_rtime  = msq->q_rtime;
 412                 tbuf.msg_ctime  = msq->q_ctime;
 413                 tbuf.msg_cbytes = msq->q_cbytes;
 414                 tbuf.msg_qnum   = msq->q_qnum;
 415                 tbuf.msg_qbytes = msq->q_qbytes;
 416                 tbuf.msg_lspid  = msq->q_lspid;
 417                 tbuf.msg_lrpid  = msq->q_lrpid;
 418                 msg_unlock(msq);
 419                 if (copy_msqid_to_user(buf, &tbuf, version))
 420                         return -EFAULT;
 421                 return success_return;
 422         }
 423         case IPC_SET:
 424                 if (!buf)
 425                         return -EFAULT;
 426                 if (copy_msqid_from_user (&setbuf, buf, version))
 427                         return -EFAULT;
 428                 break;
 429         case IPC_RMID:
 430                 break;
 431         default:
 432                 return  -EINVAL;
 433         }
 434
 435         down(&msg_ids.sem);
 436         msq = msg_lock(msqid);
 437         err=-EINVAL;
 438         if (msq == NULL)
 439                 goto out_up;
 440
 441         err = -EIDRM;
 442         if (msg_checkid(msq,msqid))
 443                 goto out_unlock_up;
 444         ipcp = &msq->q_perm;
 445         err = -EPERM;
 446         if (current->euid != ipcp->cuid &&
 447             current->euid != ipcp->uid && !capable(CAP_SYS_ADMIN))
 448             /* We _could_ check for CAP_CHOWN above, but we don't */
 449                 goto out_unlock_up;
 450
 451         err = security_msg_queue_msgctl(msq, cmd);
 452         if (err)
 453                 goto out_unlock_up;
 454
 455         switch (cmd) {
 456         case IPC_SET:
 457         {
 458                 err = -EPERM;
 459                 if (setbuf.qbytes > msg_ctlmnb && !capable(CAP_SYS_RESOURCE))
 460                         goto out_unlock_up;
 461
 462                 msq->q_qbytes = setbuf.qbytes;
 463
 464                 ipcp->uid = setbuf.uid;
 465                 ipcp->gid = setbuf.gid;
 466                 ipcp->mode = (ipcp->mode & ~S_IRWXUGO) |
 467                         (S_IRWXUGO & setbuf.mode);
 468                 msq->q_ctime = get_seconds();
 469                 /* sleeping receivers might be excluded by
 470                  * stricter permissions.
 471                  */
 472                 expunge_all(msq,-EAGAIN);
 473                 /* sleeping senders might be able to send
 474                  * due to a larger queue size.
 475                  */
 476                 ss_wakeup(&msq->q_senders,0);
 477                 msg_unlock(msq);
 478                 break;
 479         }
 480         case IPC_RMID:
 481                 freeque (msq, msqid);
 482                 break;
 483         }
 484         err = 0;
 485 out_up:
 486         up(&msg_ids.sem);
 487         return err;
 488 out_unlock_up:
 489         msg_unlock(msq);
 490         goto out_up;
 491 out_unlock:
 492         msg_unlock(msq);
 493         return err;
 494 }
 495
 496 static int testmsg(struct msg_msg* msg,long type,int mode)
 497 {
 498         switch(mode)
 499         {
 500                 case SEARCH_ANY:
 501                         return 1;
 502                 case SEARCH_LESSEQUAL:
 503                         if(msg->m_type <=type)
 504                                 return 1;
 505                         break;
 506                 case SEARCH_EQUAL:
 507                         if(msg->m_type == type)
 508                                 return 1;
 509                         break;
 510                 case SEARCH_NOTEQUAL:
 511                         if(msg->m_type != type)
 512                                 return 1;
 513                         break;
 514         }
 515         return 0;
 516 }
 517
 518 static inline int pipelined_send(struct msg_queue* msq, struct msg_msg* msg)
 519 {
 520         struct list_head* tmp;
 521
 522         tmp = msq->q_receivers.next;
 523         while (tmp != &msq->q_receivers) {
 524                 struct msg_receiver* msr;
 525                 msr = list_entry(tmp,struct msg_receiver,r_list);
 526                 tmp = tmp->next;
 527                 if(testmsg(msg,msr->r_msgtype,msr->r_mode) &&
 528                    !security_msg_queue_msgrcv(msq, msg, msr->r_tsk, msr->r_msgtype, msr->r_mode)) {
 529                         list_del(&msr->r_list);
 530                         if(msr->r_maxsize < msg->m_ts) {
 531                                 msr->r_msg = ERR_PTR(-E2BIG);
 532                                 wake_up_process(msr->r_tsk);
 533                         } else {
 534                                 msr->r_msg = msg;
 535                                 msq->q_lrpid = msr->r_tsk->pid;
 536                                 msq->q_rtime = get_seconds();
 537                                 wake_up_process(msr->r_tsk);
 538                                 return 1;
 539                         }
 540                 }
 541         }
 542         return 0;
 543 }
 544
 545 asmlinkage long sys_msgsnd (int msqid, struct msgbuf __user *msgp, size_t msgsz, int msgflg)
 546 {
 547         struct msg_queue *msq;
 548         struct msg_msg *msg;
 549         long mtype;
 550         int err;
 551
 552         if (msgsz > msg_ctlmax || (long) msgsz < 0 || msqid < 0)
 553                 return -EINVAL;
 554         if (get_user(mtype, &msgp->mtype))
 555                 return -EFAULT;
 556         if (mtype < 1)
 557                 return -EINVAL;
 558
 559         msg = load_msg(msgp->mtext, msgsz);
 560         if(IS_ERR(msg))
 561                 return PTR_ERR(msg);
 562
 563         msg->m_type = mtype;
 564         msg->m_ts = msgsz;
 565
 566         msq = msg_lock(msqid);
 567         err=-EINVAL;
 568         if(msq==NULL)
 569                 goto out_free;
 570 retry:
 571         err= -EIDRM;
 572         if (msg_checkid(msq,msqid))
 573                 goto out_unlock_free;
 574
 575         err=-EACCES;
 576         if (ipcperms(&msq->q_perm, S_IWUGO))
 577                 goto out_unlock_free;
 578
 579         err = security_msg_queue_msgsnd(msq, msg, msgflg);
 580         if (err)
 581                 goto out_unlock_free;
 582
 583         if(msgsz + msq->q_cbytes > msq->q_qbytes ||
 584                 1 + msq->q_qnum > msq->q_qbytes) {
 585                 struct msg_sender s;
 586
 587                 if(msgflg&IPC_NOWAIT) {
 588                         err=-EAGAIN;
 589                         goto out_unlock_free;
 590                 }
 591                 ss_add(msq, &s);
 592                 msg_unlock(msq);
 593                 schedule();
 594                 current->state= TASK_RUNNING;
 595
 596                 msq = msg_lock(msqid);
 597                 err = -EIDRM;
 598                 if(msq==NULL)
 599                         goto out_free;
 600                 ss_del(&s);
 601
 602                 if (signal_pending(current)) {
 603                         err=-EINTR;
 604                         goto out_unlock_free;
 605                 }
 606                 goto retry;
 607         }
 608
 609         msq->q_lspid = current->tgid;
 610         msq->q_stime = get_seconds();
 611
 612         if(!pipelined_send(msq,msg)) {
 613                 /* noone is waiting for this message, enqueue it */
 614                 list_add_tail(&msg->m_list,&msq->q_messages);
 615                 msq->q_cbytes += msgsz;
 616                 msq->q_qnum++;
 617                 atomic_add(msgsz,&msg_bytes);
 618                 atomic_inc(&msg_hdrs);
 619         }
 620
 621         err = 0;
 622         msg = NULL;
 623
 624 out_unlock_free:
 625         msg_unlock(msq);
 626 out_free:
 627         if(msg!=NULL)
 628                 free_msg(msg);
 629         return err;
 630 }
 631
 632 static inline int convert_mode(long* msgtyp, int msgflg)
 633 {
 634         /*
 635          *  find message of correct type.
 636          *  msgtyp = 0 => get first.
 637          *  msgtyp > 0 => get first message of matching type.
 638          *  msgtyp < 0 => get message with least type must be < abs(msgtype).
 639          */
 640         if(*msgtyp==0)
 641                 return SEARCH_ANY;
 642         if(*msgtyp<0) {
 643                 *msgtyp=-(*msgtyp);
 644                 return SEARCH_LESSEQUAL;
 645         }
 646         if(msgflg & MSG_EXCEPT)
 647                 return SEARCH_NOTEQUAL;
 648         return SEARCH_EQUAL;
 649 }
 650
 651 asmlinkage long sys_msgrcv (int msqid, struct msgbuf __user *msgp, size_t msgsz,
 652                             long msgtyp, int msgflg)
 653 {
 654         struct msg_queue *msq;
 655         struct msg_receiver msr_d;
 656         struct list_head* tmp;
 657         struct msg_msg* msg, *found_msg;
 658         int err;
 659         int mode;
 660
 661         if (msqid < 0 || (long) msgsz < 0)
 662                 return -EINVAL;
 663         mode = convert_mode(&msgtyp,msgflg);
 664
 665         msq = msg_lock(msqid);
 666         if(msq==NULL)
 667                 return -EINVAL;
 668 retry:
 669         err = -EIDRM;
 670         if (msg_checkid(msq,msqid))
 671                 goto out_unlock;
 672
 673         err=-EACCES;
 674         if (ipcperms (&msq->q_perm, S_IRUGO))
 675                 goto out_unlock;
 676
 677         tmp = msq->q_messages.next;
 678         found_msg=NULL;
 679         while (tmp != &msq->q_messages) {
 680                 msg = list_entry(tmp,struct msg_msg,m_list);
 681                 if(testmsg(msg,msgtyp,mode) &&
 682                    !security_msg_queue_msgrcv(msq, msg, current, msgtyp, mode)) {
 683                         found_msg = msg;
 684                         if(mode == SEARCH_LESSEQUAL && msg->m_type != 1) {
 685                                 found_msg=msg;
 686                                 msgtyp=msg->m_type-1;
 687                         } else {
 688                                 found_msg=msg;
 689                                 break;
 690                         }
 691                 }
 692                 tmp = tmp->next;
 693         }
 694         if(found_msg) {
 695                 msg=found_msg;
 696                 if ((msgsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) {
 697                         err=-E2BIG;
 698                         goto out_unlock;
 699                 }
 700                 list_del(&msg->m_list);
 701                 msq->q_qnum--;
 702                 msq->q_rtime = get_seconds();
 703                 msq->q_lrpid = current->tgid;
 704                 msq->q_cbytes -= msg->m_ts;
 705                 atomic_sub(msg->m_ts,&msg_bytes);
 706                 atomic_dec(&msg_hdrs);
 707                 ss_wakeup(&msq->q_senders,0);
 708                 msg_unlock(msq);
 709 out_success:
 710                 msgsz = (msgsz > msg->m_ts) ? msg->m_ts : msgsz;
 711                 if (put_user (msg->m_type, &msgp->mtype) ||
 712                     store_msg(msgp->mtext, msg, msgsz)) {
 713                             msgsz = -EFAULT;
 714                 }
 715                 free_msg(msg);
 716                 return msgsz;
 717         } else
 718         {
 719                 /* no message waiting. Prepare for pipelined
 720                  * receive.
 721                  */
 722                 if (msgflg & IPC_NOWAIT) {
 723                         err=-ENOMSG;
 724                         goto out_unlock;
 725                 }
 726                 list_add_tail(&msr_d.r_list,&msq->q_receivers);
 727                 msr_d.r_tsk = current;
 728                 msr_d.r_msgtype = msgtyp;
 729                 msr_d.r_mode = mode;
 730                 if(msgflg & MSG_NOERROR)
 731                         msr_d.r_maxsize = INT_MAX;
 732                  else
 733                         msr_d.r_maxsize = msgsz;
 734                 msr_d.r_msg = ERR_PTR(-EAGAIN);
 735                 current->state = TASK_INTERRUPTIBLE;
 736                 msg_unlock(msq);
 737
 738                 schedule();
 739
 740                 /*
 741                  * The below optimisation is buggy.  A sleeping thread that is
 742                  * woken up checks if it got a message and if so, copies it to
 743                  * userspace and just returns without taking any locks.
 744                  * But this return to user space can be faster than the message
 745                  * send, and if the receiver immediately exits the
 746                  * wake_up_process performed by the sender will oops.
 747                  */
 748 #if 0
 749                 msg = (struct msg_msg*) msr_d.r_msg;
 750                 if(!IS_ERR(msg))
 751                         goto out_success;
 752 #endif
 753
 754                 msq = msg_lock(msqid);
 755                 msg = (struct msg_msg*)msr_d.r_msg;
 756                 if(!IS_ERR(msg)) {
 757                         /* our message arived while we waited for
 758                          * the spinlock. Process it.
 759                          */
 760                         if(msq)
 761                                 msg_unlock(msq);
 762                         goto out_success;
 763                 }
 764                 err = PTR_ERR(msg);
 765                 if(err == -EAGAIN) {
 766                         if(!msq)
 767                                 BUG();
 768                         list_del(&msr_d.r_list);
 769                         if (signal_pending(current))
 770                                 err=-EINTR;
 771                          else
 772                                 goto retry;
 773                 }
 774         }
 775 out_unlock:
 776         if(msq)
 777                 msg_unlock(msq);
 778         return err;
 779 }
 780
 781 #ifdef CONFIG_PROC_FS
 782 static int sysvipc_msg_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
 783 {
 784         off_t pos = 0;
 785         off_t begin = 0;
 786         int i, len = 0;
 787
 788         down(&msg_ids.sem);
 789         len += sprintf(buffer, "       key      msqid perms      cbytes       qnum lspid lrpid   uid   gid  cuid  cgid      stime      rtime      ctime\n");
 790
 791         for(i = 0; i <= msg_ids.max_id; i++) {
 792                 struct msg_queue * msq;
 793                 msq = msg_lock(i);
 794                 if (msq) {
 795                         if (!vx_check(msq->q_perm.xid, VX_IDENT)) {
 796                                 msg_unlock(msq);
 797                                 continue;
 798                         }
 799                         len += sprintf(buffer + len, "%10d %10d  %4o  %10lu %10lu %5u %5u %5u %5u %5u %5u %10lu %10lu %10lu\n",
 800                                 msq->q_perm.key,
 801                                 msg_buildid(i,msq->q_perm.seq),
 802                                 msq->q_perm.mode,
 803                                 msq->q_cbytes,
 804                                 msq->q_qnum,
 805                                 msq->q_lspid,
 806                                 msq->q_lrpid,
 807                                 msq->q_perm.uid,
 808                                 msq->q_perm.gid,
 809                                 msq->q_perm.cuid,
 810                                 msq->q_perm.cgid,
 811                                 msq->q_stime,
 812                                 msq->q_rtime,
 813                                 msq->q_ctime);
 814                         msg_unlock(msq);
 815
 816                         pos += len;
 817                         if(pos < offset) {
 818                                 len = 0;
 819                                 begin = pos;
 820                         }
 821                         if(pos > offset + length)
 822                                 goto done;
 823                 }
 824
 825         }
 826         *eof = 1;
 827 done:
 828         up(&msg_ids.sem);
 829         *start = buffer + (offset - begin);
 830         len -= (offset - begin);
 831         if(len > length)
 832                 len = length;
 833         if(len < 0)
 834                 len = 0;
 835         return len;
 836 }
 837 #endif