1/* Copyright (C) 1995-2021 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, August 1995.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19#include <sys/msg.h>
20#include <ipc_priv.h>
21#include <sysdep.h>
22#include <shlib-compat.h>
23#include <errno.h>
24#include <linux/posix_types.h> /* For __kernel_mode_t. */
25
26/* POSIX states ipc_perm mode should have type of mode_t. */
27_Static_assert (sizeof ((struct msqid_ds){0}.msg_perm.mode)
28 == sizeof (mode_t),
29 "sizeof (msqid_ds.msg_perm.mode) != sizeof (mode_t)");
30
31#if __IPC_TIME64 == 0
32typedef struct msqid_ds msgctl_arg_t;
33#else
34# include <struct_kernel_msqid64_ds.h>
35
36static void
37msqid64_to_kmsqid64 (const struct __msqid64_ds *msqid64,
38 struct kernel_msqid64_ds *kmsqid)
39{
40 kmsqid->msg_perm = msqid64->msg_perm;
41 kmsqid->msg_stime = msqid64->msg_stime;
42 kmsqid->msg_stime_high = msqid64->msg_stime >> 32;
43 kmsqid->msg_rtime = msqid64->msg_rtime;
44 kmsqid->msg_rtime_high = msqid64->msg_rtime >> 32;
45 kmsqid->msg_ctime = msqid64->msg_ctime;
46 kmsqid->msg_ctime_high = msqid64->msg_ctime >> 32;
47 kmsqid->msg_cbytes = msqid64->msg_cbytes;
48 kmsqid->msg_qnum = msqid64->msg_qnum;
49 kmsqid->msg_qbytes = msqid64->msg_qbytes;
50 kmsqid->msg_lspid = msqid64->msg_lspid;
51 kmsqid->msg_lrpid = msqid64->msg_lrpid;
52}
53
54static void
55kmsqid64_to_msqid64 (const struct kernel_msqid64_ds *kmsqid,
56 struct __msqid64_ds *msqid64)
57{
58 msqid64->msg_perm = kmsqid->msg_perm;
59 msqid64->msg_stime = kmsqid->msg_stime
60 | ((__time64_t) kmsqid->msg_stime_high << 32);
61 msqid64->msg_rtime = kmsqid->msg_rtime
62 | ((__time64_t) kmsqid->msg_rtime_high << 32);
63 msqid64->msg_ctime = kmsqid->msg_ctime
64 | ((__time64_t) kmsqid->msg_ctime_high << 32);
65 msqid64->msg_cbytes = kmsqid->msg_cbytes;
66 msqid64->msg_qnum = kmsqid->msg_qnum;
67 msqid64->msg_qbytes = kmsqid->msg_qbytes;
68 msqid64->msg_lspid = kmsqid->msg_lspid;
69 msqid64->msg_lrpid = kmsqid->msg_lrpid;
70}
71
72typedef struct kernel_msqid64_ds msgctl_arg_t;
73#endif
74
75static int
76msgctl_syscall (int msqid, int cmd, msgctl_arg_t *buf)
77{
78#ifdef __ASSUME_DIRECT_SYSVIPC_SYSCALLS
79 return INLINE_SYSCALL_CALL (msgctl, msqid, cmd | __IPC_64, buf);
80#else
81 return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd | __IPC_64, 0,
82 buf);
83#endif
84}
85
86int
87__msgctl64 (int msqid, int cmd, struct __msqid64_ds *buf)
88{
89#if __IPC_TIME64
90 struct kernel_msqid64_ds ksemid, *arg = NULL;
91#else
92 msgctl_arg_t *arg;
93#endif
94
95 switch (cmd)
96 {
97 case IPC_RMID:
98 arg = NULL;
99 break;
100
101 case IPC_SET:
102 case IPC_STAT:
103 case MSG_STAT:
104 case MSG_STAT_ANY:
105#if __IPC_TIME64
106 if (buf != NULL)
107 {
108 msqid64_to_kmsqid64 (buf, &ksemid);
109 arg = &ksemid;
110 }
111# ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
112 if (cmd == IPC_SET)
113 arg->msg_perm.mode *= 0x10000U;
114# endif
115#else
116 arg = buf;
117#endif
118 break;
119
120 case IPC_INFO:
121 case MSG_INFO:
122 /* This is a Linux extension where kernel returns a 'struct msginfo'
123 instead. */
124 arg = (__typeof__ (arg)) buf;
125 break;
126
127 default:
128 __set_errno (EINVAL);
129 return -1;
130 }
131
132 int ret = msgctl_syscall (msqid, cmd, arg);
133 if (ret < 0)
134 return ret;
135
136 switch (cmd)
137 {
138 case IPC_STAT:
139 case MSG_STAT:
140 case MSG_STAT_ANY:
141#ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
142 arg->msg_perm.mode >>= 16;
143#else
144 /* Old Linux kernel versions might not clear the mode padding. */
145 if (sizeof ((struct msqid_ds){0}.msg_perm.mode)
146 != sizeof (__kernel_mode_t))
147 arg->msg_perm.mode &= 0xFFFF;
148#endif
149
150#if __IPC_TIME64
151 kmsqid64_to_msqid64 (arg, buf);
152#endif
153 }
154
155 return ret;
156}
157#if __TIMESIZE != 64
158libc_hidden_def (__msgctl64)
159
160static void
161msqid_to_msqid64 (struct __msqid64_ds *mq64, const struct msqid_ds *mq)
162{
163 mq64->msg_perm = mq->msg_perm;
164 mq64->msg_stime = mq->msg_stime
165 | ((__time64_t) mq->__msg_stime_high << 32);
166 mq64->msg_rtime = mq->msg_rtime
167 | ((__time64_t) mq->__msg_rtime_high << 32);
168 mq64->msg_ctime = mq->msg_ctime
169 | ((__time64_t) mq->__msg_ctime_high << 32);
170 mq64->msg_cbytes = mq->msg_cbytes;
171 mq64->msg_qnum = mq->msg_qnum;
172 mq64->msg_qbytes = mq->msg_qbytes;
173 mq64->msg_lspid = mq->msg_lspid;
174 mq64->msg_lrpid = mq->msg_lrpid;
175}
176
177static void
178msqid64_to_msqid (struct msqid_ds *mq, const struct __msqid64_ds *mq64)
179{
180 mq->msg_perm = mq64->msg_perm;
181 mq->msg_stime = mq64->msg_stime;
182 mq->__msg_stime_high = 0;
183 mq->msg_rtime = mq64->msg_rtime;
184 mq->__msg_rtime_high = 0;
185 mq->msg_ctime = mq64->msg_ctime;
186 mq->__msg_ctime_high = 0;
187 mq->msg_cbytes = mq64->msg_cbytes;
188 mq->msg_qnum = mq64->msg_qnum;
189 mq->msg_qbytes = mq64->msg_qbytes;
190 mq->msg_lspid = mq64->msg_lspid;
191 mq->msg_lrpid = mq64->msg_lrpid;
192}
193
194int
195__msgctl (int msqid, int cmd, struct msqid_ds *buf)
196{
197 struct __msqid64_ds msqid64, *buf64 = NULL;
198 if (buf != NULL)
199 {
200 /* This is a Linux extension where kernel returns a 'struct msginfo'
201 instead. */
202 if (cmd == IPC_INFO || cmd == MSG_INFO)
203 buf64 = (struct __msqid64_ds *) buf;
204 else
205 {
206 msqid_to_msqid64 (&msqid64, buf);
207 buf64 = &msqid64;
208 }
209 }
210
211 int ret = __msgctl64 (msqid, cmd, buf64);
212 if (ret < 0)
213 return ret;
214
215 switch (cmd)
216 {
217 case IPC_STAT:
218 case MSG_STAT:
219 case MSG_STAT_ANY:
220 msqid64_to_msqid (buf, buf64);
221 }
222
223 return ret;
224}
225#endif
226
227#ifndef DEFAULT_VERSION
228# ifndef __ASSUME_SYSVIPC_BROKEN_MODE_T
229# define DEFAULT_VERSION GLIBC_2_2
230# else
231# define DEFAULT_VERSION GLIBC_2_31
232# endif
233#endif
234versioned_symbol (libc, __msgctl, msgctl, DEFAULT_VERSION);
235
236#if defined __ASSUME_SYSVIPC_BROKEN_MODE_T \
237 && SHLIB_COMPAT (libc, GLIBC_2_2, GLIBC_2_31)
238int
239attribute_compat_text_section
240__msgctl_mode16 (int msqid, int cmd, struct msqid_ds *buf)
241{
242 return msgctl_syscall (msqid, cmd, (msgctl_arg_t *) buf);
243}
244compat_symbol (libc, __msgctl_mode16, msgctl, GLIBC_2_2);
245#endif
246
247#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
248struct __old_msqid_ds
249{
250 struct __old_ipc_perm msg_perm; /* structure describing operation permission */
251 struct msg *__msg_first; /* pointer to first message on queue */
252 struct msg *__msg_last; /* pointer to last message on queue */
253 __time_t msg_stime; /* time of last msgsnd command */
254 __time_t msg_rtime; /* time of last msgrcv command */
255 __time_t msg_ctime; /* time of last change */
256 struct wait_queue *__wwait; /* ??? */
257 struct wait_queue *__rwait; /* ??? */
258 unsigned short int __msg_cbytes; /* current number of bytes on queue */
259 unsigned short int msg_qnum; /* number of messages currently on queue */
260 unsigned short int msg_qbytes; /* max number of bytes allowed on queue */
261 __ipc_pid_t msg_lspid; /* pid of last msgsnd() */
262 __ipc_pid_t msg_lrpid; /* pid of last msgrcv() */
263};
264
265int
266attribute_compat_text_section
267__old_msgctl (int msqid, int cmd, struct __old_msqid_ds *buf)
268{
269#if defined __ASSUME_DIRECT_SYSVIPC_SYSCALLS \
270 && !defined __ASSUME_SYSVIPC_DEFAULT_IPC_64
271 /* For architecture that have wire-up msgctl but also have __IPC_64 to a
272 value different than default (0x0) it means the compat symbol used the
273 __NR_ipc syscall. */
274 return INLINE_SYSCALL_CALL (msgctl, msqid, cmd, buf);
275#else
276 return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd, 0, buf);
277#endif
278}
279compat_symbol (libc, __old_msgctl, msgctl, GLIBC_2_0);
280#endif
281