1 /* $NetBSD: linux_mqueue.c,v 1.2 2025/05/17 19:00:56 andvar Exp $ */ 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.2 2025/05/17 19:00:56 andvar 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 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 } 316
Indexes created Sat Sep 20 22:09:52 GMT 2025