msgutil.c 3.6 KB

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