/*	$NetBSD: linux_mqueue.c,v 1.2 2025/05/17 19:00:56 andvar Exp $	*/

/*-
 * Copyright (c) 2024 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: linux_mqueue.c,v 1.2 2025/05/17 19:00:56 andvar Exp $");

#include <sys/param.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mqueue.h>
#include <sys/syscallargs.h>

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_sched.h>
#include <compat/linux/common/linux_fcntl.h>
#include <compat/linux/common/linux_ipc.h>
#include <compat/linux/common/linux_sem.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_sigevent.h>
#include <compat/linux/common/linux_util.h>
#include <compat/linux/common/linux_mqueue.h>

#include <compat/linux/linux_syscallargs.h>
#include <compat/linux/linux_syscall.h>

static void
linux_to_bsd_mq_attr(const struct linux_mq_attr *lmp, struct mq_attr *bmp)
{
	memset(bmp, 0, sizeof(*bmp));
	bmp->mq_flags = cvtto_bsd_mask(lmp->mq_flags, LINUX_O_NONBLOCK,
	    O_NONBLOCK);
	bmp->mq_maxmsg = lmp->mq_maxmsg;
	bmp->mq_msgsize = lmp->mq_msgsize;
	bmp->mq_curmsgs = lmp->mq_curmsgs;
}

static void
bsd_to_linux_mq_attr(const struct mq_attr *bmp, struct linux_mq_attr *lmp)
{
	memset(lmp, 0, sizeof(*lmp));
	lmp->mq_flags = cvtto_linux_mask(bmp->mq_flags, O_NONBLOCK,
	    LINUX_O_NONBLOCK);
	lmp->mq_maxmsg = bmp->mq_maxmsg;
	lmp->mq_msgsize = bmp->mq_msgsize;
	lmp->mq_curmsgs = bmp->mq_curmsgs;
}

/* Adapted from sys_mq_open */
int
linux_sys_mq_open(struct lwp *l, const struct linux_sys_mq_open_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(const char *) name;
		syscallarg(int) oflag;
		syscallarg(linux_umode_t) mode;
		syscallarg(struct linux_mq_attr *) attr;
	} */
	struct linux_mq_attr lattr;
	struct mq_attr *attr = NULL, a;
	int error, oflag;

	oflag = linux_to_bsd_ioflags(SCARG(uap, oflag));

	if ((oflag & O_CREAT) != 0 && SCARG(uap, attr) != NULL) {
		error = copyin(SCARG(uap, attr), &lattr, sizeof(lattr));
		if (error)
			return error;
		linux_to_bsd_mq_attr(&lattr, &a);
		attr = &a;
	}

	return mq_handle_open(l, SCARG(uap, name), oflag,
	    (mode_t)SCARG(uap, mode), attr, retval);
}

int
linux_sys_mq_unlink(struct lwp *l, const struct linux_sys_mq_unlink_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(const char *) name;
	} */
	struct sys_mq_unlink_args args;

	SCARG(&args, name) = SCARG(uap, name);

	return sys_mq_unlink(l, &args, retval);
}

/* Adapted from sys___mq_timedsend50 */
int
linux_sys_mq_timedsend(struct lwp *l, const struct linux_sys_mq_timedsend_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(const char *) msg_ptr;
		syscallarg(size_t) msg_len;
		syscallarg(unsigned int) msg_prio;
		syscallarg(const struct linux_timespec *) abs_timeout;
	} */
	struct linux_timespec lts;
	struct timespec ts, *tsp;
	int error;

	/* Get and convert time value */
	if (SCARG(uap, abs_timeout)) {
		error = copyin(SCARG(uap, abs_timeout), &lts, sizeof(lts));
		if (error)
			return error;
		linux_to_native_timespec(&ts, &lts);
		tsp = &ts;
	} else {
		tsp = NULL;
	}

	return mq_send1((mqd_t)SCARG(uap, mqdes), SCARG(uap, msg_ptr),
	    SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
}

/* Adapted from sys___mq_timedreceive50 */
int
linux_sys_mq_timedreceive(struct lwp *l,
    const struct linux_sys_mq_timedreceive_args *uap, register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(char *) msg_ptr;
		syscallarg(size_t) msg_len;
		syscallarg(unsigned int *) msg_prio;
		syscallarg(const struct linux_timespec *) abs_timeout;
	}; */
	struct linux_timespec lts;
	struct timespec ts, *tsp;
	ssize_t mlen;
	int error;

	/* Get and convert time value */
	if (SCARG(uap, abs_timeout)) {
		error = copyin(SCARG(uap, abs_timeout), &lts, sizeof(lts));
		if (error)
			return error;
		linux_to_native_timespec(&ts, &lts);
		tsp = &ts;
	} else {
		tsp = NULL;
	}

	error = mq_recv1((mqd_t)SCARG(uap, mqdes), SCARG(uap, msg_ptr),
	    SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp, &mlen);
	if (error == 0)
		*retval = mlen;

	return error;
}

/* Adapted from sys_mq_notify */
int
linux_sys_mq_notify(struct lwp *l, const struct linux_sys_mq_notify_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(const struct linux_sigevent *) sevp;
	} */
	struct mqueue *mq;
	struct sigevent sig;
	int error;

	if (SCARG(uap, sevp)) {
		/* Get the signal from user-space */
		error = linux_sigevent_copyin(SCARG(uap, sevp), &sig,
		    sizeof(sig));
		if (error)
			return error;
		if (sig.sigev_notify == SIGEV_SIGNAL &&
		    (sig.sigev_signo <= 0 || sig.sigev_signo >= NSIG))
			return EINVAL;
	}

	error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
	if (error)
		return error;
	if (SCARG(uap, sevp)) {
		/* Register notification: set the signal and target process */
		if (mq->mq_notify_proc == NULL) {
			memcpy(&mq->mq_sig_notify, &sig,
			    sizeof(struct sigevent));
			mq->mq_notify_proc = l->l_proc;
		} else {
			/* Fail if someone else already registered */
			error = EBUSY;
		}
	} else {
		/* Unregister the notification */
		mq->mq_notify_proc = NULL;
	}
	mutex_exit(&mq->mq_mtx);
	fd_putfile((int)SCARG(uap, mqdes));

	return error;
}

/* Adapted from sys_mq_getattr */
static int
linux_sys_mq_getattr(struct lwp *l,
    const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(const struct linux_mq_attr *) newattr;
		syscallarg(struct linux_mq_attr *) oldattr;
	} */
	struct linux_mq_attr lattr;
	struct mq_attr attr;
	struct mqueue *mq;
	int error;

	error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
	if (error)
		return error;
	memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
	bsd_to_linux_mq_attr(&attr, &lattr);
	mutex_exit(&mq->mq_mtx);
	fd_putfile((int)SCARG(uap, mqdes));

	return copyout(&lattr, SCARG(uap, oldattr), sizeof(lattr));
}

/* Adapted from sys_mq_setattr */
static int
linux_sys_mq_setattr(struct lwp *l,
    const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(const struct linux_mq_attr *) newattr;
		syscallarg(struct linux_mq_attr *) oldattr;
	} */
	struct linux_mq_attr lattr;
	struct mq_attr attr;
	struct mqueue *mq;
	int error, nonblock;

	error = copyin(SCARG(uap, newattr), &lattr, sizeof(lattr));
	if (error)
		return error;
	linux_to_bsd_mq_attr(&lattr, &attr);
	nonblock = (attr.mq_flags & O_NONBLOCK);

	error = mqueue_get((mqd_t)SCARG(uap, mqdes), 0, &mq);
	if (error)
		return error;

	/* Copy the old attributes, if needed */
	if (SCARG(uap, oldattr)) {
		memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
		bsd_to_linux_mq_attr(&attr, &lattr);
	}

	/* Ignore everything, except O_NONBLOCK */
	if (nonblock)
		mq->mq_attrib.mq_flags |= O_NONBLOCK;
	else
		mq->mq_attrib.mq_flags &= ~O_NONBLOCK;

	mutex_exit(&mq->mq_mtx);
	fd_putfile((int)SCARG(uap, mqdes));

	/* Copy the data to the user-space. */
	if (SCARG(uap, oldattr))
		return copyout(&lattr, SCARG(uap, oldattr), sizeof(lattr));

	return 0;
}

int
linux_sys_mq_getsetattr(struct lwp *l,
    const struct linux_sys_mq_getsetattr_args *uap, register_t *retval)
{
	/* {
		syscallarg(linux_mqd_t) mqdes;
		syscallarg(const struct linux_mq_attr *) newattr;
		syscallarg(struct linux_mq_attr *) oldattr;
	} */
	if (SCARG(uap, newattr) == NULL)
		return linux_sys_mq_getattr(l, uap, retval);
	return linux_sys_mq_setattr(l, uap, retval);
}