Annotation of src/sys/compat/linux/common/linux_mqueue.c, revision 1.1
1.1 ! christos 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$");
! 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>