ipc/msgutil.c

   1 /*
   2  * linux/ipc/msgutil.c
   3  * Copyright (C) 1999, 2004 Manfred Spraul
   4  *
   5  * This file is released under GNU General Public Licence version 2 or
   6  * (at your option) any later version.
   7  *
   8  * See the file COPYING for more details.
   9  */
  10
  11 #include <linux/spinlock.h>
  12 #include <linux/init.h>
  13 #include <linux/security.h>
  14 #include <linux/slab.h>
  15 #include <linux/ipc.h>
  16 #include <linux/msg.h>
  17 #include <linux/ipc_namespace.h>
  18 #include <linux/utsname.h>
  19 #include <linux/proc_ns.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/sched.h>
  22
  23 #include "util.h"
  24
  25 DEFINE_SPINLOCK(mq_lock);
  26
  27 /*
  28  * The next 2 defines are here bc this is the only file
  29  * compiled when either CONFIG_SYSVIPC and CONFIG_POSIX_MQUEUE
  30  * and not CONFIG_IPC_NS.
  31  */
  32 struct ipc_namespace init_ipc_ns = {
  33         .count          = ATOMIC_INIT(1),
  34         .user_ns = &init_user_ns,
  35         .ns.inum = PROC_IPC_INIT_INO,
  36 #ifdef CONFIG_IPC_NS
  37         .ns.ops = &ipcns_operations,
  38 #endif
  39 };
  40
  41 atomic_t nr_ipc_ns = ATOMIC_INIT(1);
  42
  43 struct msg_msgseg {
  44         struct msg_msgseg *next;
  45         /* the next part of the message follows immediately */
  46 };
  47
  48 #define DATALEN_MSG     ((size_t)PAGE_SIZE-sizeof(struct msg_msg))
  49 #define DATALEN_SEG     ((size_t)PAGE_SIZE-sizeof(struct msg_msgseg))
  50
  51
  52 static struct msg_msg *alloc_msg(size_t len)
  53 {
  54         struct msg_msg *msg;
  55         struct msg_msgseg **pseg;
  56         size_t alen;
  57
  58         alen = min(len, DATALEN_MSG);
  59         msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL);
  60         if (msg == NULL)
  61                 return NULL;
  62
  63         msg->next = NULL;
  64         msg->security = NULL;
  65
  66         len -= alen;
  67         pseg = &msg->next;
  68         while (len > 0) {
  69                 struct msg_msgseg *seg;
  70
  71                 cond_resched();
  72
  73                 alen = min(len, DATALEN_SEG);
  74                 seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL);
  75                 if (seg == NULL)
  76                         goto out_err;
  77                 *pseg = seg;
  78                 seg->next = NULL;
  79                 pseg = &seg->next;
  80                 len -= alen;
  81         }
  82
  83         return msg;
  84
  85 out_err:
  86         free_msg(msg);
  87         return NULL;
  88 }
  89
  90 struct msg_msg *load_msg(const void __user *src, size_t len)
  91 {
  92         struct msg_msg *msg;
  93         struct msg_msgseg *seg;
  94         int err = -EFAULT;
  95         size_t alen;
  96
  97         msg = alloc_msg(len);
  98         if (msg == NULL)
  99                 return ERR_PTR(-ENOMEM);
 100
 101         alen = min(len, DATALEN_MSG);
 102         if (copy_from_user(msg + 1, src, alen))
 103                 goto out_err;
 104
 105         for (seg = msg->next; seg != NULL; seg = seg->next) {
 106                 len -= alen;
 107                 src = (char __user *)src + alen;
 108                 alen = min(len, DATALEN_SEG);
 109                 if (copy_from_user(seg + 1, src, alen))
 110                         goto out_err;
 111         }
 112
 113         err = security_msg_msg_alloc(msg);
 114         if (err)
 115                 goto out_err;
 116
 117         return msg;
 118
 119 out_err:
 120         free_msg(msg);
 121         return ERR_PTR(err);
 122 }
 123 #ifdef CONFIG_CHECKPOINT_RESTORE
 124 struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst)
 125 {
 126         struct msg_msgseg *dst_pseg, *src_pseg;
 127         size_t len = src->m_ts;
 128         size_t alen;
 129
 130         if (src->m_ts > dst->m_ts)
 131                 return ERR_PTR(-EINVAL);
 132
 133         alen = min(len, DATALEN_MSG);
 134         memcpy(dst + 1, src + 1, alen);
 135
 136         for (dst_pseg = dst->next, src_pseg = src->next;
 137              src_pseg != NULL;
 138              dst_pseg = dst_pseg->next, src_pseg = src_pseg->next) {
 139
 140                 len -= alen;
 141                 alen = min(len, DATALEN_SEG);
 142                 memcpy(dst_pseg + 1, src_pseg + 1, alen);
 143         }
 144
 145         dst->m_type = src->m_type;
 146         dst->m_ts = src->m_ts;
 147
 148         return dst;
 149 }
 150 #else
 151 struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst)
 152 {
 153         return ERR_PTR(-ENOSYS);
 154 }
 155 #endif
 156 int store_msg(void __user *dest, struct msg_msg *msg, size_t len)
 157 {
 158         size_t alen;
 159         struct msg_msgseg *seg;
 160
 161         alen = min(len, DATALEN_MSG);
 162         if (copy_to_user(dest, msg + 1, alen))
 163                 return -1;
 164
 165         for (seg = msg->next; seg != NULL; seg = seg->next) {
 166                 len -= alen;
 167                 dest = (char __user *)dest + alen;
 168                 alen = min(len, DATALEN_SEG);
 169                 if (copy_to_user(dest, seg + 1, alen))
 170                         return -1;
 171         }
 172         return 0;
 173 }
 174
 175 void free_msg(struct msg_msg *msg)
 176 {
 177         struct msg_msgseg *seg;
 178
 179         security_msg_msg_free(msg);
 180
 181         seg = msg->next;
 182         kfree(msg);
 183         while (seg != NULL) {
 184                 struct msg_msgseg *tmp = seg->next;
 185
 186                 cond_resched();
 187                 kfree(seg);
 188                 seg = tmp;
 189         }
 190 }