SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <manfred@colorfullife.com>
  16  *
  17  * support for audit of ipc object properties and permission changes
  18  * Dustin Kirkland <dustin.kirkland@us.ibm.com>
  19  *
  20  * namespaces support
  21  * OpenVZ, SWsoft Inc.
  22  * Pavel Emelianov <xemul@openvz.org>
  23  */
  24
  25 #include <linux/capability.h>
  26 #include <linux/slab.h>
  27 #include <linux/msg.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/init.h>
  30 #include <linux/proc_fs.h>
  31 #include <linux/list.h>
  32 #include <linux/security.h>
  33 #include <linux/sched.h>
  34 #include <linux/syscalls.h>
  35 #include <linux/audit.h>
  36 #include <linux/seq_file.h>
  37 #include <linux/rwsem.h>
  38 #include <linux/nsproxy.h>
  39
  40 #include <asm/current.h>
  41 #include <asm/uaccess.h>
  42 #include "util.h"
  43
  44 /*
  45  * one msg_receiver structure for each sleeping receiver:
  46  */
  47 struct msg_receiver {
  48         struct list_head        r_list;
  49         struct task_struct      *r_tsk;
  50
  51         int                     r_mode;
  52         long                    r_msgtype;
  53         long                    r_maxsize;
  54
  55         struct msg_msg          *volatile r_msg;
  56 };
  57
  58 /* one msg_sender for each sleeping sender */
  59 struct msg_sender {
  60         struct list_head        list;
  61         struct task_struct      *tsk;
  62 };
  63
  64 #define SEARCH_ANY              1
  65 #define SEARCH_EQUAL            2
  66 #define SEARCH_NOTEQUAL         3
  67 #define SEARCH_LESSEQUAL        4
  68
  69 static atomic_t msg_bytes =     ATOMIC_INIT(0);
  70 static atomic_t msg_hdrs =      ATOMIC_INIT(0);
  71
  72 static struct ipc_ids init_msg_ids;
  73
  74 #define msg_ids(ns)     (*((ns)->ids[IPC_MSG_IDS]))
  75
  76 #define msg_unlock(msq)         ipc_unlock(&(msq)->q_perm)
  77 #define msg_buildid(id, seq)    ipc_buildid(id, seq)
  78
  79 static void freeque(struct ipc_namespace *, struct msg_queue *);
  80 static int newque(struct ipc_namespace *, struct ipc_params *);
  81 #ifdef CONFIG_PROC_FS
  82 static int sysvipc_msg_proc_show(struct seq_file *s, void *it);
  83 #endif
  84
  85 static void __msg_init_ns(struct ipc_namespace *ns, struct ipc_ids *ids)
  86 {
  87         ns->ids[IPC_MSG_IDS] = ids;
  88         ns->msg_ctlmax = MSGMAX;
  89         ns->msg_ctlmnb = MSGMNB;
  90         ns->msg_ctlmni = MSGMNI;
  91         ipc_init_ids(ids);
  92 }
  93
  94 int msg_init_ns(struct ipc_namespace *ns)
  95 {
  96         struct ipc_ids *ids;
  97
  98         ids = kmalloc(sizeof(struct ipc_ids), GFP_KERNEL);
  99         if (ids == NULL)
 100                 return -ENOMEM;
 101
 102         __msg_init_ns(ns, ids);
 103         return 0;
 104 }
 105
 106 void msg_exit_ns(struct ipc_namespace *ns)
 107 {
 108         struct msg_queue *msq;
 109         int next_id;
 110         int total, in_use;
 111
 112         down_write(&msg_ids(ns).rw_mutex);
 113
 114         in_use = msg_ids(ns).in_use;
 115
 116         for (total = 0, next_id = 0; total < in_use; next_id++) {
 117                 msq = idr_find(&msg_ids(ns).ipcs_idr, next_id);
 118                 if (msq == NULL)
 119                         continue;
 120                 ipc_lock_by_ptr(&msq->q_perm);
 121                 freeque(ns, msq);
 122                 total++;
 123         }
 124
 125         up_write(&msg_ids(ns).rw_mutex);
 126
 127         kfree(ns->ids[IPC_MSG_IDS]);
 128         ns->ids[IPC_MSG_IDS] = NULL;
 129 }
 130
 131 void __init msg_init(void)
 132 {
 133         __msg_init_ns(&init_ipc_ns, &init_msg_ids);
 134         ipc_init_proc_interface("sysvipc/msg",
 135                                 "       key      msqid perms      cbytes       qnum lspid lrpid   uid   gid  cuid  cgid      stime      rtime      ctime\n",
 136                                 IPC_MSG_IDS, sysvipc_msg_proc_show);
 137 }
 138
 139 /*
 140  * This routine is called in the paths where the rw_mutex is held to protect
 141  * access to the idr tree.
 142  */
 143 static inline struct msg_queue *msg_lock_check_down(struct ipc_namespace *ns,
 144                                                 int id)
 145 {
 146         struct kern_ipc_perm *ipcp = ipc_lock_check_down(&msg_ids(ns), id);
 147
 148         return container_of(ipcp, struct msg_queue, q_perm);
 149 }
 150
 151 /*
 152  * msg_lock_(check_) routines are called in the paths where the rw_mutex
 153  * is not held.
 154  */
 155 static inline struct msg_queue *msg_lock(struct ipc_namespace *ns, int id)
 156 {
 157         struct kern_ipc_perm *ipcp = ipc_lock(&msg_ids(ns), id);
 158
 159         return container_of(ipcp, struct msg_queue, q_perm);
 160 }
 161
 162 static inline struct msg_queue *msg_lock_check(struct ipc_namespace *ns,
 163                                                 int id)
 164 {
 165         struct kern_ipc_perm *ipcp = ipc_lock_check(&msg_ids(ns), id);
 166
 167         return container_of(ipcp, struct msg_queue, q_perm);
 168 }
 169
 170 static inline void msg_rmid(struct ipc_namespace *ns, struct msg_queue *s)
 171 {
 172         ipc_rmid(&msg_ids(ns), &s->q_perm);
 173 }
 174
 175 /**
 176  * newque - Create a new msg queue
 177  * @ns: namespace
 178  * @params: ptr to the structure that contains the key and msgflg
 179  *
 180  * Called with msg_ids.rw_mutex held (writer)
 181  */
 182 static int newque(struct ipc_namespace *ns, struct ipc_params *params)
 183 {
 184         struct msg_queue *msq;
 185         int id, retval;
 186         key_t key = params->key;
 187         int msgflg = params->flg;
 188
 189         msq = ipc_rcu_alloc(sizeof(*msq));
 190         if (!msq)
 191                 return -ENOMEM;
 192
 193         msq->q_perm.mode = msgflg & S_IRWXUGO;
 194         msq->q_perm.key = key;
 195
 196         msq->q_perm.security = NULL;
 197         retval = security_msg_queue_alloc(msq);
 198         if (retval) {
 199                 ipc_rcu_putref(msq);
 200                 return retval;
 201         }
 202
 203         /*
 204          * ipc_addid() locks msq
 205          */
 206         id = ipc_addid(&msg_ids(ns), &msq->q_perm, ns->msg_ctlmni);
 207         if (id == -1) {
 208                 security_msg_queue_free(msq);
 209                 ipc_rcu_putref(msq);
 210                 return -ENOSPC;
 211         }
 212
 213         msq->q_perm.id = msg_buildid(id, msq->q_perm.seq);
 214         msq->q_stime = msq->q_rtime = 0;
 215         msq->q_ctime = get_seconds();
 216         msq->q_cbytes = msq->q_qnum = 0;
 217         msq->q_qbytes = ns->msg_ctlmnb;
 218         msq->q_lspid = msq->q_lrpid = 0;
 219         INIT_LIST_HEAD(&msq->q_messages);
 220         INIT_LIST_HEAD(&msq->q_receivers);
 221         INIT_LIST_HEAD(&msq->q_senders);
 222
 223         msg_unlock(msq);
 224
 225         return msq->q_perm.id;
 226 }
 227
 228 static inline void ss_add(struct msg_queue *msq, struct msg_sender *mss)
 229 {
 230         mss->tsk = current;
 231         current->state = TASK_INTERRUPTIBLE;
 232         list_add_tail(&mss->list, &msq->q_senders);
 233 }
 234
 235 static inline void ss_del(struct msg_sender *mss)
 236 {
 237         if (mss->list.next != NULL)
 238                 list_del(&mss->list);
 239 }
 240
 241 static void ss_wakeup(struct list_head *h, int kill)
 242 {
 243         struct list_head *tmp;
 244
 245         tmp = h->next;
 246         while (tmp != h) {
 247                 struct msg_sender *mss;
 248
 249                 mss = list_entry(tmp, struct msg_sender, list);
 250                 tmp = tmp->next;
 251                 if (kill)
 252                         mss->list.next = NULL;
 253                 wake_up_process(mss->tsk);
 254         }
 255 }
 256
 257 static void expunge_all(struct msg_queue *msq, int res)
 258 {
 259         struct list_head *tmp;
 260
 261         tmp = msq->q_receivers.next;
 262         while (tmp != &msq->q_receivers) {
 263                 struct msg_receiver *msr;
 264
 265                 msr = list_entry(tmp, struct msg_receiver, r_list);
 266                 tmp = tmp->next;
 267                 msr->r_msg = NULL;
 268                 wake_up_process(msr->r_tsk);
 269                 smp_mb();
 270                 msr->r_msg = ERR_PTR(res);
 271         }
 272 }
 273
 274 /*
 275  * freeque() wakes up waiters on the sender and receiver waiting queue,
 276  * removes the message queue from message queue ID IDR, and cleans up all the
 277  * messages associated with this queue.
 278  *
 279  * msg_ids.rw_mutex (writer) and the spinlock for this message queue are held
 280  * before freeque() is called. msg_ids.rw_mutex remains locked on exit.
 281  */
 282 static void freeque(struct ipc_namespace *ns, struct msg_queue *msq)
 283 {
 284         struct list_head *tmp;
 285
 286         expunge_all(msq, -EIDRM);
 287         ss_wakeup(&msq->q_senders, 1);
 288         msg_rmid(ns, msq);
 289         msg_unlock(msq);
 290
 291         tmp = msq->q_messages.next;
 292         while (tmp != &msq->q_messages) {
 293                 struct msg_msg *msg = list_entry(tmp, struct msg_msg, m_list);
 294
 295                 tmp = tmp->next;
 296                 atomic_dec(&msg_hdrs);
 297                 free_msg(msg);
 298         }
 299         atomic_sub(msq->q_cbytes, &msg_bytes);
 300         security_msg_queue_free(msq);
 301         ipc_rcu_putref(msq);
 302 }
 303
 304 /*
 305  * Called with msg_ids.rw_mutex and ipcp locked.
 306  */
 307 static inline int msg_security(struct kern_ipc_perm *ipcp, int msgflg)
 308 {
 309         struct msg_queue *msq = container_of(ipcp, struct msg_queue, q_perm);
 310
 311         return security_msg_queue_associate(msq, msgflg);
 312 }
 313
 314 asmlinkage long sys_msgget(key_t key, int msgflg)
 315 {
 316         struct ipc_namespace *ns;
 317         struct ipc_ops msg_ops;
 318         struct ipc_params msg_params;
 319
 320         ns = current->nsproxy->ipc_ns;
 321
 322         msg_ops.getnew = newque;
 323         msg_ops.associate = msg_security;
 324         msg_ops.more_checks = NULL;
 325
 326         msg_params.key = key;
 327         msg_params.flg = msgflg;
 328
 329         return ipcget(ns, &msg_ids(ns), &msg_ops, &msg_params);
 330 }
 331
 332 static inline unsigned long
 333 copy_msqid_to_user(void __user *buf, struct msqid64_ds *in, int version)
 334 {
 335         switch(version) {
 336         case IPC_64:
 337                 return copy_to_user(buf, in, sizeof(*in));
 338         case IPC_OLD:
 339         {
 340                 struct msqid_ds out;
 341
 342                 memset(&out, 0, sizeof(out));
 343
 344                 ipc64_perm_to_ipc_perm(&in->msg_perm, &out.msg_perm);
 345
 346                 out.msg_stime           = in->msg_stime;
 347                 out.msg_rtime           = in->msg_rtime;
 348                 out.msg_ctime           = in->msg_ctime;
 349
 350                 if (in->msg_cbytes > USHRT_MAX)
 351                         out.msg_cbytes  = USHRT_MAX;
 352                 else
 353                         out.msg_cbytes  = in->msg_cbytes;
 354                 out.msg_lcbytes         = in->msg_cbytes;
 355
 356                 if (in->msg_qnum > USHRT_MAX)
 357                         out.msg_qnum    = USHRT_MAX;
 358                 else
 359                         out.msg_qnum    = in->msg_qnum;
 360
 361                 if (in->msg_qbytes > USHRT_MAX)
 362                         out.msg_qbytes  = USHRT_MAX;
 363                 else
 364                         out.msg_qbytes  = in->msg_qbytes;
 365                 out.msg_lqbytes         = in->msg_qbytes;
 366
 367                 out.msg_lspid           = in->msg_lspid;
 368                 out.msg_lrpid           = in->msg_lrpid;
 369
 370                 return copy_to_user(buf, &out, sizeof(out));
 371         }
 372         default:
 373                 return -EINVAL;
 374         }
 375 }
 376
 377 struct msq_setbuf {
 378         unsigned long   qbytes;
 379         uid_t           uid;
 380         gid_t           gid;
 381         mode_t          mode;
 382 };
 383
 384 static inline unsigned long
 385 copy_msqid_from_user(struct msq_setbuf *out, void __user *buf, int version)
 386 {
 387         switch(version) {
 388         case IPC_64:
 389         {
 390                 struct msqid64_ds tbuf;
 391
 392                 if (copy_from_user(&tbuf, buf, sizeof(tbuf)))
 393                         return -EFAULT;
 394
 395                 out->qbytes             = tbuf.msg_qbytes;
 396                 out->uid                = tbuf.msg_perm.uid;
 397                 out->gid                = tbuf.msg_perm.gid;
 398                 out->mode               = tbuf.msg_perm.mode;
 399
 400                 return 0;
 401         }
 402         case IPC_OLD:
 403         {
 404                 struct msqid_ds tbuf_old;
 405
 406                 if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))
 407                         return -EFAULT;
 408
 409                 out->uid                = tbuf_old.msg_perm.uid;
 410                 out->gid                = tbuf_old.msg_perm.gid;
 411                 out->mode               = tbuf_old.msg_perm.mode;
 412
 413                 if (tbuf_old.msg_qbytes == 0)
 414                         out->qbytes     = tbuf_old.msg_lqbytes;
 415                 else
 416                         out->qbytes     = tbuf_old.msg_qbytes;
 417
 418                 return 0;
 419         }
 420         default:
 421                 return -EINVAL;
 422         }
 423 }
 424
 425 asmlinkage long sys_msgctl(int msqid, int cmd, struct msqid_ds __user *buf)
 426 {
 427         struct kern_ipc_perm *ipcp;
 428         struct msq_setbuf uninitialized_var(setbuf);
 429         struct msg_queue *msq;
 430         int err, version;
 431         struct ipc_namespace *ns;
 432
 433         if (msqid < 0 || cmd < 0)
 434                 return -EINVAL;
 435
 436         version = ipc_parse_version(&cmd);
 437         ns = current->nsproxy->ipc_ns;
 438
 439         switch (cmd) {
 440         case IPC_INFO:
 441         case MSG_INFO:
 442         {
 443                 struct msginfo msginfo;
 444                 int max_id;
 445
 446                 if (!buf)
 447                         return -EFAULT;
 448                 /*
 449                  * We must not return kernel stack data.
 450                  * due to padding, it's not enough
 451                  * to set all member fields.
 452                  */
 453                 err = security_msg_queue_msgctl(NULL, cmd);
 454                 if (err)
 455                         return err;
 456
 457                 memset(&msginfo, 0, sizeof(msginfo));
 458                 msginfo.msgmni = ns->msg_ctlmni;
 459                 msginfo.msgmax = ns->msg_ctlmax;
 460                 msginfo.msgmnb = ns->msg_ctlmnb;
 461                 msginfo.msgssz = MSGSSZ;
 462                 msginfo.msgseg = MSGSEG;
 463                 down_read(&msg_ids(ns).rw_mutex);
 464                 if (cmd == MSG_INFO) {
 465                         msginfo.msgpool = msg_ids(ns).in_use;
 466                         msginfo.msgmap = atomic_read(&msg_hdrs);
 467                         msginfo.msgtql = atomic_read(&msg_bytes);
 468                 } else {
 469                         msginfo.msgmap = MSGMAP;
 470                         msginfo.msgpool = MSGPOOL;
 471                         msginfo.msgtql = MSGTQL;
 472                 }
 473                 max_id = ipc_get_maxid(&msg_ids(ns));
 474                 up_read(&msg_ids(ns).rw_mutex);
 475                 if (copy_to_user(buf, &msginfo, sizeof(struct msginfo)))
 476                         return -EFAULT;
 477                 return (max_id < 0) ? 0 : max_id;
 478         }
 479         case MSG_STAT:  /* msqid is an index rather than a msg queue id */
 480         case IPC_STAT:
 481         {
 482                 struct msqid64_ds tbuf;
 483                 int success_return;
 484
 485                 if (!buf)
 486                         return -EFAULT;
 487
 488                 if (cmd == MSG_STAT) {
 489                         msq = msg_lock(ns, msqid);
 490                         if (IS_ERR(msq))
 491                                 return PTR_ERR(msq);
 492                         success_return = msq->q_perm.id;
 493                 } else {
 494                         msq = msg_lock_check(ns, msqid);
 495                         if (IS_ERR(msq))
 496                                 return PTR_ERR(msq);
 497                         success_return = 0;
 498                 }
 499                 err = -EACCES;
 500                 if (ipcperms(&msq->q_perm, S_IRUGO))
 501                         goto out_unlock;
 502
 503                 err = security_msg_queue_msgctl(msq, cmd);
 504                 if (err)
 505                         goto out_unlock;
 506
 507                 memset(&tbuf, 0, sizeof(tbuf));
 508
 509                 kernel_to_ipc64_perm(&msq->q_perm, &tbuf.msg_perm);
 510                 tbuf.msg_stime  = msq->q_stime;
 511                 tbuf.msg_rtime  = msq->q_rtime;
 512                 tbuf.msg_ctime  = msq->q_ctime;
 513                 tbuf.msg_cbytes = msq->q_cbytes;
 514                 tbuf.msg_qnum   = msq->q_qnum;
 515                 tbuf.msg_qbytes = msq->q_qbytes;
 516                 tbuf.msg_lspid  = msq->q_lspid;
 517                 tbuf.msg_lrpid  = msq->q_lrpid;
 518                 msg_unlock(msq);
 519                 if (copy_msqid_to_user(buf, &tbuf, version))
 520                         return -EFAULT;
 521                 return success_return;
 522         }
 523         case IPC_SET:
 524                 if (!buf)
 525                         return -EFAULT;
 526                 if (copy_msqid_from_user(&setbuf, buf, version))
 527                         return -EFAULT;
 528                 break;
 529         case IPC_RMID:
 530                 break;
 531         default:
 532                 return  -EINVAL;
 533         }
 534
 535         down_write(&msg_ids(ns).rw_mutex);
 536         msq = msg_lock_check_down(ns, msqid);
 537         if (IS_ERR(msq)) {
 538                 err = PTR_ERR(msq);
 539                 goto out_up;
 540         }
 541
 542         ipcp = &msq->q_perm;
 543
 544         err = audit_ipc_obj(ipcp);
 545         if (err)
 546                 goto out_unlock_up;
 547         if (cmd == IPC_SET) {
 548                 err = audit_ipc_set_perm(setbuf.qbytes, setbuf.uid, setbuf.gid,
 549                                          setbuf.mode);
 550                 if (err)
 551                         goto out_unlock_up;
 552         }
 553
 554         err = -EPERM;
 555         if (current->euid != ipcp->cuid &&
 556             current->euid != ipcp->uid && !capable(CAP_SYS_ADMIN))
 557                 /* We _could_ check for CAP_CHOWN above, but we don't */
 558                 goto out_unlock_up;
 559
 560         err = security_msg_queue_msgctl(msq, cmd);
 561         if (err)
 562                 goto out_unlock_up;
 563
 564         switch (cmd) {
 565         case IPC_SET:
 566         {
 567                 err = -EPERM;
 568                 if (setbuf.qbytes > ns->msg_ctlmnb && !capable(CAP_SYS_RESOURCE))
 569                         goto out_unlock_up;
 570
 571                 msq->q_qbytes = setbuf.qbytes;
 572
 573                 ipcp->uid = setbuf.uid;
 574                 ipcp->gid = setbuf.gid;
 575                 ipcp->mode = (ipcp->mode & ~S_IRWXUGO) |
 576                              (S_IRWXUGO & setbuf.mode);
 577                 msq->q_ctime = get_seconds();
 578                 /* sleeping receivers might be excluded by
 579                  * stricter permissions.
 580                  */
 581                 expunge_all(msq, -EAGAIN);
 582                 /* sleeping senders might be able to send
 583                  * due to a larger queue size.
 584                  */
 585                 ss_wakeup(&msq->q_senders, 0);
 586                 msg_unlock(msq);
 587                 break;
 588         }
 589         case IPC_RMID:
 590                 freeque(ns, msq);
 591                 break;
 592         }
 593         err = 0;
 594 out_up:
 595         up_write(&msg_ids(ns).rw_mutex);
 596         return err;
 597 out_unlock_up:
 598         msg_unlock(msq);
 599         goto out_up;
 600 out_unlock:
 601         msg_unlock(msq);
 602         return err;
 603 }
 604
 605 static int testmsg(struct msg_msg *msg, long type, int mode)
 606 {
 607         switch(mode)
 608         {
 609                 case SEARCH_ANY:
 610                         return 1;
 611                 case SEARCH_LESSEQUAL:
 612                         if (msg->m_type <=type)
 613                                 return 1;
 614                         break;
 615                 case SEARCH_EQUAL:
 616                         if (msg->m_type == type)
 617                                 return 1;
 618                         break;
 619                 case SEARCH_NOTEQUAL:
 620                         if (msg->m_type != type)
 621                                 return 1;
 622                         break;
 623         }
 624         return 0;
 625 }
 626
 627 static inline int pipelined_send(struct msg_queue *msq, struct msg_msg *msg)
 628 {
 629         struct list_head *tmp;
 630
 631         tmp = msq->q_receivers.next;
 632         while (tmp != &msq->q_receivers) {
 633                 struct msg_receiver *msr;
 634
 635                 msr = list_entry(tmp, struct msg_receiver, r_list);
 636                 tmp = tmp->next;
 637                 if (testmsg(msg, msr->r_msgtype, msr->r_mode) &&
 638                     !security_msg_queue_msgrcv(msq, msg, msr->r_tsk,
 639                                                msr->r_msgtype, msr->r_mode)) {
 640
 641                         list_del(&msr->r_list);
 642                         if (msr->r_maxsize < msg->m_ts) {
 643                                 msr->r_msg = NULL;
 644                                 wake_up_process(msr->r_tsk);
 645                                 smp_mb();
 646                                 msr->r_msg = ERR_PTR(-E2BIG);
 647                         } else {
 648                                 msr->r_msg = NULL;
 649                                 msq->q_lrpid = task_pid_vnr(msr->r_tsk);
 650                                 msq->q_rtime = get_seconds();
 651                                 wake_up_process(msr->r_tsk);
 652                                 smp_mb();
 653                                 msr->r_msg = msg;
 654
 655                                 return 1;
 656                         }
 657                 }
 658         }
 659         return 0;
 660 }
 661
 662 long do_msgsnd(int msqid, long mtype, void __user *mtext,
 663                 size_t msgsz, int msgflg)
 664 {
 665         struct msg_queue *msq;
 666         struct msg_msg *msg;
 667         int err;
 668         struct ipc_namespace *ns;
 669
 670         ns = current->nsproxy->ipc_ns;
 671
 672         if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)
 673                 return -EINVAL;
 674         if (mtype < 1)
 675                 return -EINVAL;
 676
 677         msg = load_msg(mtext, msgsz);
 678         if (IS_ERR(msg))
 679                 return PTR_ERR(msg);
 680
 681         msg->m_type = mtype;
 682         msg->m_ts = msgsz;
 683
 684         msq = msg_lock_check(ns, msqid);
 685         if (IS_ERR(msq)) {
 686                 err = PTR_ERR(msq);
 687                 goto out_free;
 688         }
 689
 690         for (;;) {
 691                 struct msg_sender s;
 692
 693                 err = -EACCES;
 694                 if (ipcperms(&msq->q_perm, S_IWUGO))
 695                         goto out_unlock_free;
 696
 697                 err = security_msg_queue_msgsnd(msq, msg, msgflg);
 698                 if (err)
 699                         goto out_unlock_free;
 700
 701                 if (msgsz + msq->q_cbytes <= msq->q_qbytes &&
 702                                 1 + msq->q_qnum <= msq->q_qbytes) {
 703                         break;
 704                 }
 705
 706                 /* queue full, wait: */
 707                 if (msgflg & IPC_NOWAIT) {
 708                         err = -EAGAIN;
 709                         goto out_unlock_free;
 710                 }
 711                 ss_add(msq, &s);
 712                 ipc_rcu_getref(msq);
 713                 msg_unlock(msq);
 714                 schedule();
 715
 716                 ipc_lock_by_ptr(&msq->q_perm);
 717                 ipc_rcu_putref(msq);
 718                 if (msq->q_perm.deleted) {
 719                         err = -EIDRM;
 720                         goto out_unlock_free;
 721                 }
 722                 ss_del(&s);
 723
 724                 if (signal_pending(current)) {
 725                         err = -ERESTARTNOHAND;
 726                         goto out_unlock_free;
 727                 }
 728         }
 729
 730         msq->q_lspid = task_tgid_vnr(current);
 731         msq->q_stime = get_seconds();
 732
 733         if (!pipelined_send(msq, msg)) {
 734                 /* noone is waiting for this message, enqueue it */
 735                 list_add_tail(&msg->m_list, &msq->q_messages);
 736                 msq->q_cbytes += msgsz;
 737                 msq->q_qnum++;
 738                 atomic_add(msgsz, &msg_bytes);
 739                 atomic_inc(&msg_hdrs);
 740         }
 741
 742         err = 0;
 743         msg = NULL;
 744
 745 out_unlock_free:
 746         msg_unlock(msq);
 747 out_free:
 748         if (msg != NULL)
 749                 free_msg(msg);
 750         return err;
 751 }
 752
 753 asmlinkage long
 754 sys_msgsnd(int msqid, struct msgbuf __user *msgp, size_t msgsz, int msgflg)
 755 {
 756         long mtype;
 757
 758         if (get_user(mtype, &msgp->mtype))
 759                 return -EFAULT;
 760         return do_msgsnd(msqid, mtype, msgp->mtext, msgsz, msgflg);
 761 }
 762
 763 static inline int convert_mode(long *msgtyp, int msgflg)
 764 {
 765         /*
 766          *  find message of correct type.
 767          *  msgtyp = 0 => get first.
 768          *  msgtyp > 0 => get first message of matching type.
 769          *  msgtyp < 0 => get message with least type must be < abs(msgtype).
 770          */
 771         if (*msgtyp == 0)
 772                 return SEARCH_ANY;
 773         if (*msgtyp < 0) {
 774                 *msgtyp = -*msgtyp;
 775                 return SEARCH_LESSEQUAL;
 776         }
 777         if (msgflg & MSG_EXCEPT)
 778                 return SEARCH_NOTEQUAL;
 779         return SEARCH_EQUAL;
 780 }
 781
 782 long do_msgrcv(int msqid, long *pmtype, void __user *mtext,
 783                 size_t msgsz, long msgtyp, int msgflg)
 784 {
 785         struct msg_queue *msq;
 786         struct msg_msg *msg;
 787         int mode;
 788         struct ipc_namespace *ns;
 789
 790         if (msqid < 0 || (long) msgsz < 0)
 791                 return -EINVAL;
 792         mode = convert_mode(&msgtyp, msgflg);
 793         ns = current->nsproxy->ipc_ns;
 794
 795         msq = msg_lock_check(ns, msqid);
 796         if (IS_ERR(msq))
 797                 return PTR_ERR(msq);
 798
 799         for (;;) {
 800                 struct msg_receiver msr_d;
 801                 struct list_head *tmp;
 802
 803                 msg = ERR_PTR(-EACCES);
 804                 if (ipcperms(&msq->q_perm, S_IRUGO))
 805                         goto out_unlock;
 806
 807                 msg = ERR_PTR(-EAGAIN);
 808                 tmp = msq->q_messages.next;
 809                 while (tmp != &msq->q_messages) {
 810                         struct msg_msg *walk_msg;
 811
 812                         walk_msg = list_entry(tmp, struct msg_msg, m_list);
 813                         if (testmsg(walk_msg, msgtyp, mode) &&
 814                             !security_msg_queue_msgrcv(msq, walk_msg, current,
 815                                                        msgtyp, mode)) {
 816
 817                                 msg = walk_msg;
 818                                 if (mode == SEARCH_LESSEQUAL &&
 819                                                 walk_msg->m_type != 1) {
 820                                         msg = walk_msg;
 821                                         msgtyp = walk_msg->m_type - 1;
 822                                 } else {
 823                                         msg = walk_msg;
 824                                         break;
 825                                 }
 826                         }
 827                         tmp = tmp->next;
 828                 }
 829                 if (!IS_ERR(msg)) {
 830                         /*
 831                          * Found a suitable message.
 832                          * Unlink it from the queue.
 833                          */
 834                         if ((msgsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) {
 835                                 msg = ERR_PTR(-E2BIG);
 836                                 goto out_unlock;
 837                         }
 838                         list_del(&msg->m_list);
 839                         msq->q_qnum--;
 840                         msq->q_rtime = get_seconds();
 841                         msq->q_lrpid = task_tgid_vnr(current);
 842                         msq->q_cbytes -= msg->m_ts;
 843                         atomic_sub(msg->m_ts, &msg_bytes);
 844                         atomic_dec(&msg_hdrs);
 845                         ss_wakeup(&msq->q_senders, 0);
 846                         msg_unlock(msq);
 847                         break;
 848                 }
 849                 /* No message waiting. Wait for a message */
 850                 if (msgflg & IPC_NOWAIT) {
 851                         msg = ERR_PTR(-ENOMSG);
 852                         goto out_unlock;
 853                 }
 854                 list_add_tail(&msr_d.r_list, &msq->q_receivers);
 855                 msr_d.r_tsk = current;
 856                 msr_d.r_msgtype = msgtyp;
 857                 msr_d.r_mode = mode;
 858                 if (msgflg & MSG_NOERROR)
 859                         msr_d.r_maxsize = INT_MAX;
 860                 else
 861                         msr_d.r_maxsize = msgsz;
 862                 msr_d.r_msg = ERR_PTR(-EAGAIN);
 863                 current->state = TASK_INTERRUPTIBLE;
 864                 msg_unlock(msq);
 865
 866                 schedule();
 867
 868                 /* Lockless receive, part 1:
 869                  * Disable preemption.  We don't hold a reference to the queue
 870                  * and getting a reference would defeat the idea of a lockless
 871                  * operation, thus the code relies on rcu to guarantee the
 872                  * existance of msq:
 873                  * Prior to destruction, expunge_all(-EIRDM) changes r_msg.
 874                  * Thus if r_msg is -EAGAIN, then the queue not yet destroyed.
 875                  * rcu_read_lock() prevents preemption between reading r_msg
 876                  * and the spin_lock() inside ipc_lock_by_ptr().
 877                  */
 878                 rcu_read_lock();
 879
 880                 /* Lockless receive, part 2:
 881                  * Wait until pipelined_send or expunge_all are outside of
 882                  * wake_up_process(). There is a race with exit(), see
 883                  * ipc/mqueue.c for the details.
 884                  */
 885                 msg = (struct msg_msg*)msr_d.r_msg;
 886                 while (msg == NULL) {
 887                         cpu_relax();
 888                         msg = (struct msg_msg *)msr_d.r_msg;
 889                 }
 890
 891                 /* Lockless receive, part 3:
 892                  * If there is a message or an error then accept it without
 893                  * locking.
 894                  */
 895                 if (msg != ERR_PTR(-EAGAIN)) {
 896                         rcu_read_unlock();
 897                         break;
 898                 }
 899
 900                 /* Lockless receive, part 3:
 901                  * Acquire the queue spinlock.
 902                  */
 903                 ipc_lock_by_ptr(&msq->q_perm);
 904                 rcu_read_unlock();
 905
 906                 /* Lockless receive, part 4:
 907                  * Repeat test after acquiring the spinlock.
 908                  */
 909                 msg = (struct msg_msg*)msr_d.r_msg;
 910                 if (msg != ERR_PTR(-EAGAIN))
 911                         goto out_unlock;
 912
 913                 list_del(&msr_d.r_list);
 914                 if (signal_pending(current)) {
 915                         msg = ERR_PTR(-ERESTARTNOHAND);
 916 out_unlock:
 917                         msg_unlock(msq);
 918                         break;
 919                 }
 920         }
 921         if (IS_ERR(msg))
 922                 return PTR_ERR(msg);
 923
 924         msgsz = (msgsz > msg->m_ts) ? msg->m_ts : msgsz;
 925         *pmtype = msg->m_type;
 926         if (store_msg(mtext, msg, msgsz))
 927                 msgsz = -EFAULT;
 928
 929         free_msg(msg);
 930
 931         return msgsz;
 932 }
 933
 934 asmlinkage long sys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz,
 935                            long msgtyp, int msgflg)
 936 {
 937         long err, mtype;
 938
 939         err =  do_msgrcv(msqid, &mtype, msgp->mtext, msgsz, msgtyp, msgflg);
 940         if (err < 0)
 941                 goto out;
 942
 943         if (put_user(mtype, &msgp->mtype))
 944                 err = -EFAULT;
 945 out:
 946         return err;
 947 }
 948
 949 #ifdef CONFIG_PROC_FS
 950 static int sysvipc_msg_proc_show(struct seq_file *s, void *it)
 951 {
 952         struct msg_queue *msq = it;
 953
 954         return seq_printf(s,
 955                         "%10d %10d  %4o  %10lu %10lu %5u %5u %5u %5u %5u %5u %10lu %10lu %10lu\n",
 956                         msq->q_perm.key,
 957                         msq->q_perm.id,
 958                         msq->q_perm.mode,
 959                         msq->q_cbytes,
 960                         msq->q_qnum,
 961                         msq->q_lspid,
 962                         msq->q_lrpid,
 963                         msq->q_perm.uid,
 964                         msq->q_perm.gid,
 965                         msq->q_perm.cuid,
 966                         msq->q_perm.cgid,
 967                         msq->q_stime,
 968                         msq->q_rtime,
 969                         msq->q_ctime);
 970 }
 971 #endif