1 /* $NetBSD */
2
3 /*-
4 * Copyright (c) 2024 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: linux_mqueue.c,v 1.1 2024/07/01 01:35:53 christos Exp $");
31
32 #include <sys/param.h>
33 #include <sys/filedesc.h>
34 #include <sys/fcntl.h>
35 #include <sys/mqueue.h>
36 #include <sys/syscallargs.h>
37
38 #include <compat/linux/common/linux_types.h>
39 #include <compat/linux/common/linux_sched.h>
40 #include <compat/linux/common/linux_fcntl.h>
41 #include <compat/linux/common/linux_ipc.h>
42 #include <compat/linux/common/linux_sem.h>
43 #include <compat/linux/common/linux_signal.h>
44 #include <compat/linux/common/linux_sigevent.h>
45 #include <compat/linux/common/linux_util.h>
46 #include <compat/linux/common/linux_mqueue.h>
47
48 #include <compat/linux/linux_syscallargs.h>
49 #include <compat/linux/linux_syscall.h>
50
51 static void
linux_to_bsd_mq_attr(const struct linux_mq_attr * lmp,struct mq_attr * bmp)52 linux_to_bsd_mq_attr(const struct linux_mq_attr *lmp, struct mq_attr *bmp)
53 {
54 memset(bmp, 0, sizeof(*bmp));
55 bmp->mq_flags = cvtto_bsd_mask(lmp->mq_flags, LINUX_O_NONBLOCK,
56 O_NONBLOCK);
57 bmp->mq_maxmsg = lmp->mq_maxmsg;
58 bmp->mq_msgsize = lmp->mq_msgsize;
59 bmp->mq_curmsgs = lmp->mq_curmsgs;
60 }
61
62 static void
bsd_to_linux_mq_attr(const struct mq_attr * bmp,struct linux_mq_attr * lmp)63 bsd_to_linux_mq_attr(const struct mq_attr *bmp, struct linux_mq_attr *lmp)
64 {
65 memset(lmp, 0, sizeof(*lmp));
66 lmp->mq_flags = cvtto_linux_mask(bmp->mq_flags, O_NONBLOCK,
67 LINUX_O_NONBLOCK);
68 lmp->mq_maxmsg = bmp->mq_maxmsg;
69 lmp->mq_msgsize = bmp->mq_msgsize;
70 lmp->mq_curmsgs = bmp->mq_curmsgs;
71 }
72
73 /* Adapted from sys_mq_open */
74 int
linux_sys_mq_open(struct lwp * l,const struct linux_sys_mq_open_args * uap,register_t * retval)75 linux_sys_mq_open(struct lwp *l, const struct linux_sys_mq_open_args *uap,
76 register_t *retval)
77 {
78 /* {
79 syscallarg(const char *) name;
80 syscallarg(int) oflag;
81 syscallarg(linux_umode_t) mode;
82 syscallarg(struct linux_mq_attr *) attr;
83 } */
84 struct linux_mq_attr lattr;
85 struct mq_attr *attr = NULL, a;
86 int error, oflag;
87
88 oflag = linux_to_bsd_ioflags(SCARG(uap, oflag));
89
90 if ((oflag & O_CREAT) != 0 && SCARG(uap, attr) != NULL) {
91 error = copyin(SCARG(uap, attr), &lattr, sizeof(lattr));
92 if (error)
93 return error;
94 linux_to_bsd_mq_attr(&lattr, &a);
95 attr = &a;
96 }
97
98 return mq_handle_open(l, SCARG(uap, name), oflag,
99 (mode_t)SCARG(uap, mode), attr, retval);
100 }
101
102 int
linux_sys_mq_unlink(struct lwp * l,const struct linux_sys_mq_unlink_args * uap,register_t * retval)103 linux_sys_mq_unlink(struct lwp *l, const struct linux_sys_mq_unlink_args *uap,
104 register_t *retval)
105 {
106 /* {
107 syscallarg(const char *) name;
108 } */
109 struct sys_mq_unlink_args args;
110
111 SCARG(&args, name) = SCARG(uap, name);
112
113 return sys_mq_unlink(l, &args, retval);
114 }
115
116 /* Adapted from sys___mq_timedsend50 */
117 int
linux_sys_mq_timedsend(struct lwp * l,const struct linux_sys_mq_timedsend_args * uap,register_t * retval)118 linux_sys_mq_timedsend(struct lwp *l, const struct linux_sys_mq_timedsend_args *uap,
119 register_t *retval)
120 {
121 /* {
122 syscallarg(linux_mqd_t) mqdes;
123 syscallarg(const char *) msg_ptr;
124 syscallarg(size_t) msg_len;
125 syscallarg(unsigned int) msg_prio;
126 syscallarg(const struct linux_timespec *) abs_timeout;
127 } */
128 struct linux_timespec lts;
129 struct timespec ts, *tsp;
130 int error;
131
132 /* Get and convert time value */
133 if (SCARG(uap, abs_timeout)) {
134 error = copyin(SCARG(uap, abs_timeout), <s, sizeof(lts));
135 if (error)
136 return error;
137 linux_to_native_timespec(&ts, <s);
138 tsp = &ts;
139 } else {
140 tsp = NULL;
141 }
142
143 return mq_send1((mqd_t)SCARG(uap, mqdes), SCARG(uap, msg_ptr),
144 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
145 }
146
147 /* Adapted from sys___mq_timedreceive50 */
148 int
linux_sys_mq_timedreceive(struct lwp * l,const struct linux_sys_mq_timedreceive_args * uap,register_t * retval)149 linux_sys_mq_timedreceive(struct lwp *l,
150 const struct linux_sys_mq_timedreceive_args *uap, register_t *retval)
151 {
152 /* {
153 syscallarg(linux_mqd_t) mqdes;
154 syscallarg(char *) msg_ptr;
155 syscallarg(size_t) msg_len;
156 syscallarg(unsigned int *) msg_prio;
157 syscallarg(const struct linux_timespec *) abs_timeout;
158 }; */
159 struct linux_timespec lts;
160 struct timespec ts, *tsp;
161 ssize_t mlen;
162 int error;
163
164 /* Get and convert time value */
165 if (SCARG(uap, abs_timeout)) {
166 error = copyin(SCARG(uap, abs_timeout), <s, sizeof(lts));
167 if (error)
168 return error;
169 linux_to_native_timespec(&ts, <s);
170 tsp = &ts;
171 } else {
172 tsp = NULL;
173 }
174
175 error = mq_recv1((mqd_t)SCARG(uap, mqdes), SCARG(uap, msg_ptr),
176 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp, &mlen);
177 if (error == 0)
178 *retval = mlen;
179
180 return error;
181 }
182
183 /* Adapted from sys_mq_notify */
184 int
linux_sys_mq_notify(struct lwp * l,const struct linux_sys_mq_notify_args * uap,register_t * retval)185 linux_sys_mq_notify(struct lwp *l, const struct linux_sys_mq_notify_args *uap,
186 register_t *retval)
187 {
188 /* {
189 syscallarg(linux_mqd_t) mqdes;
190 syscallarg(const struct linux_sigevent *) sevp;
191 } */
192 struct mqueue *mq;
193 struct sigevent sig;
194 int error;
195
196 if (SCARG(uap, sevp)) {
197 /* Get the signal from user-space */
198 error = linux_sigevent_copyin(SCARG(uap, sevp), &sig,
199 sizeof(sig));
200 if (error)
201 return error;
202 if (sig.sigev_notify == SIGEV_SIGNAL &&
203 (sig.sigev_signo <= 0 || sig.sigev_signo >= NSIG))
204 return EINVAL;
205 }
206
207 error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
208 if (error)
209 return error;
210 if (SCARG(uap, sevp)) {
211 /* Register notification: set the signal and target process */
212 if (mq->mq_notify_proc == NULL) {
213 memcpy(&mq->mq_sig_notify, &sig,
214 sizeof(struct sigevent));
215 mq->mq_notify_proc = l->l_proc;
216 } else {
217 /* Fail if someone else already registered */
218 error = EBUSY;
219 }
220 } else {
221 /* Unregister the notification */
222 mq->mq_notify_proc = NULL;
223 }
224 mutex_exit(&mq->mq_mtx);
225 fd_putfile((int)SCARG(uap, mqdes));
226
227 return error;
228 }
229
230 /* Adapted from sys_mq_getattr */
231 static int
linux_sys_mq_getattr(struct lwp * l,const struct linux_sys_mq_getsetattr_args * uap,register_t * retval)232 linux_sys_mq_getattr(struct lwp *l,
233 const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
234 {
235 /* {
236 syscallarg(linux_mqd_t) mqdes;
237 syscallarg(const struct linux_mq_attr *) newattr;
238 syscallarg(struct linux_mq_attr *) oldattr;
239 } */
240 struct linux_mq_attr lattr;
241 struct mq_attr attr;
242 struct mqueue *mq;
243 int error;
244
245 error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
246 if (error)
247 return error;
248 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
249 bsd_to_linux_mq_attr(&attr, &lattr);
250 mutex_exit(&mq->mq_mtx);
251 fd_putfile((int)SCARG(uap, mqdes));
252
253 return copyout(&lattr, SCARG(uap, oldattr), sizeof(lattr));
254 }
255
256 /* Adapted from sys_mq_setattr */
257 static int
linux_sys_mq_setattr(struct lwp * l,const struct linux_sys_mq_getsetattr_args * uap,register_t * retval)258 linux_sys_mq_setattr(struct lwp *l,
259 const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
260 {
261 /* {
262 syscallarg(linux_mqd_t) mqdes;
263 syscallarg(const struct linux_mq_attr *) newattr;
264 syscallarg(struct linux_mq_attr *) oldattr;
265 } */
266 struct linux_mq_attr lattr;
267 struct mq_attr attr;
268 struct mqueue *mq;
269 int error, nonblock;
270
271 error = copyin(SCARG(uap, newattr), &lattr, sizeof(lattr));
272 if (error)
273 return error;
274 linux_to_bsd_mq_attr(&lattr, &attr);
275 nonblock = (attr.mq_flags & O_NONBLOCK);
276
277 error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
278 if (error)
279 return error;
280
281 /* Copy the old attributes, if needed */
282 if (SCARG(uap, oldattr)) {
283 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
284 bsd_to_linux_mq_attr(&attr, &lattr);
285 }
286
287 /* Ignore everything, except O_NONBLOCK */
288 if (nonblock)
289 mq->mq_attrib.mq_flags |= O_NONBLOCK;
290 else
291 mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
292
293 mutex_exit(&mq->mq_mtx);
294 fd_putfile((int)SCARG(uap, mqdes));
295
296 /* Copy the data to the user-space. */
297 if (SCARG(uap, oldattr))
298 return copyout(&lattr, SCARG(uap, oldattr), sizeof(lattr));
299
300 return 0;
301 }
302
303 int
linux_sys_mq_getsetattr(struct lwp * l,const struct linux_sys_mq_getsetattr_args * uap,register_t * retval)304 linux_sys_mq_getsetattr(struct lwp *l,
305 const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
306 {
307 /* {
308 syscallarg(linux_mqd_t) mqdes;
309 syscallarg(const struct linux_mq_attr *) newattr;
310 syscallarg(struct linux_mq_attr *) oldattr;
311 } */
312 if (SCARG(uap, newattr) == NULL)
313 return linux_sys_mq_getattr(l, uap, retval);
314 return linux_sys_mq_setattr(l, uap, retval);
315 }
316