Annotation of src/sys/compat/linux/common/linux_mqueue.c, revision 1.2
1.2 ! andvar 1: /* $NetBSD$ */
1.1 christos 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>
1.2 ! andvar 30: __KERNEL_RCSID(0, "$NetBSD: linux_mqueue.c,v 1.1 2024/07/01 01:35:53 christos Exp $");
1.1 christos 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
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
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
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
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
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
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
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
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
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
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: }
CVSweb <webmaster@jp.NetBSD.org>