/*
|
* Copyright (C) 2005 Jan Kiszka <jan.kiszka@web.de>.
|
* Copyright (C) 2005 Joerg Langenberg <joerg.langenberg@gmx.net>.
|
* Copyright (C) 2008 Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
|
*
|
* Xenomai is free software; you can redistribute it and/or modify it
|
* under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* Xenomai is distributed in the hope that it will be useful, but
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with Xenomai; if not, write to the Free Software Foundation,
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
#include <linux/err.h>
|
#include <linux/fs.h>
|
#include <cobalt/kernel/compat.h>
|
#include <cobalt/kernel/ppd.h>
|
#include <cobalt/kernel/time.h>
|
#include <xenomai/rtdm/internal.h>
|
#include "process.h"
|
#include "internal.h"
|
#include "clock.h"
|
#include "io.h"
|
|
COBALT_SYSCALL(open, lostage,
|
(const char __user *u_path, int oflag))
|
{
|
struct filename *filename;
|
int ufd;
|
|
filename = getname(u_path);
|
if (IS_ERR(filename))
|
return PTR_ERR(filename);
|
|
ufd = __rtdm_dev_open(filename->name, oflag);
|
putname(filename);
|
|
return ufd;
|
}
|
|
COBALT_SYSCALL(socket, lostage,
|
(int protocol_family, int socket_type, int protocol))
|
{
|
return __rtdm_dev_socket(protocol_family, socket_type, protocol);
|
}
|
|
COBALT_SYSCALL(close, lostage, (int fd))
|
{
|
return rtdm_fd_close(fd, 0);
|
}
|
|
COBALT_SYSCALL(fcntl, current, (int fd, int cmd, long arg))
|
{
|
return rtdm_fd_fcntl(fd, cmd, arg);
|
}
|
|
COBALT_SYSCALL(ioctl, handover,
|
(int fd, unsigned int request, void __user *arg))
|
{
|
return rtdm_fd_ioctl(fd, request, arg);
|
}
|
|
COBALT_SYSCALL(read, handover,
|
(int fd, void __user *buf, size_t size))
|
{
|
return rtdm_fd_read(fd, buf, size);
|
}
|
|
COBALT_SYSCALL(write, handover,
|
(int fd, const void __user *buf, size_t size))
|
{
|
return rtdm_fd_write(fd, buf, size);
|
}
|
|
COBALT_SYSCALL(recvmsg, handover,
|
(int fd, struct user_msghdr __user *umsg, int flags))
|
{
|
struct user_msghdr m;
|
ssize_t ret;
|
|
ret = cobalt_copy_from_user(&m, umsg, sizeof(m));
|
if (ret)
|
return ret;
|
|
ret = rtdm_fd_recvmsg(fd, &m, flags);
|
if (ret < 0)
|
return ret;
|
|
return cobalt_copy_to_user(umsg, &m, sizeof(*umsg)) ?: ret;
|
}
|
|
static int get_timespec(struct timespec64 *ts,
|
const void __user *u_ts)
|
{
|
return cobalt_get_u_timespec(ts, u_ts);
|
}
|
|
static int get_mmsg(struct mmsghdr *mmsg, void __user *u_mmsg)
|
{
|
return cobalt_copy_from_user(mmsg, u_mmsg, sizeof(*mmsg));
|
}
|
|
static int put_mmsg(void __user **u_mmsg_p, const struct mmsghdr *mmsg)
|
{
|
struct mmsghdr __user **p = (struct mmsghdr **)u_mmsg_p,
|
*q __user = (*p)++;
|
|
return cobalt_copy_to_user(q, mmsg, sizeof(*q));
|
}
|
|
COBALT_SYSCALL(recvmmsg, primary,
|
(int fd, struct mmsghdr __user *u_msgvec, unsigned int vlen,
|
unsigned int flags, struct __user_old_timespec __user *u_timeout))
|
{
|
return __rtdm_fd_recvmmsg(fd, u_msgvec, vlen, flags, u_timeout,
|
get_mmsg, put_mmsg, get_timespec);
|
}
|
|
COBALT_SYSCALL(recvmmsg64, primary,
|
(int fd, struct mmsghdr __user *u_msgvec, unsigned int vlen,
|
unsigned int flags, struct __kernel_timespec __user *u_timeout))
|
{
|
return __rtdm_fd_recvmmsg64(fd, u_msgvec, vlen, flags, u_timeout,
|
get_mmsg, put_mmsg);
|
}
|
|
COBALT_SYSCALL(sendmsg, handover,
|
(int fd, struct user_msghdr __user *umsg, int flags))
|
{
|
struct user_msghdr m;
|
int ret;
|
|
ret = cobalt_copy_from_user(&m, umsg, sizeof(m));
|
|
return ret ?: rtdm_fd_sendmsg(fd, &m, flags);
|
}
|
|
static int put_mmsglen(void __user **u_mmsg_p, const struct mmsghdr *mmsg)
|
{
|
struct mmsghdr __user **p = (struct mmsghdr **)u_mmsg_p,
|
*q __user = (*p)++;
|
|
return __xn_put_user(mmsg->msg_len, &q->msg_len);
|
}
|
|
COBALT_SYSCALL(sendmmsg, primary,
|
(int fd, struct mmsghdr __user *u_msgvec,
|
unsigned int vlen, unsigned int flags))
|
{
|
return __rtdm_fd_sendmmsg(fd, u_msgvec, vlen, flags,
|
get_mmsg, put_mmsglen);
|
}
|
|
COBALT_SYSCALL(mmap, lostage,
|
(int fd, struct _rtdm_mmap_request __user *u_rma,
|
void __user **u_addrp))
|
{
|
struct _rtdm_mmap_request rma;
|
void *u_addr = NULL;
|
int ret;
|
|
ret = cobalt_copy_from_user(&rma, u_rma, sizeof(rma));
|
if (ret)
|
return ret;
|
|
ret = rtdm_fd_mmap(fd, &rma, &u_addr);
|
if (ret)
|
return ret;
|
|
return cobalt_copy_to_user(u_addrp, &u_addr, sizeof(u_addr));
|
}
|
|
static int __cobalt_first_fd_valid_p(fd_set *fds[XNSELECT_MAX_TYPES], int nfds)
|
{
|
int i, fd;
|
|
for (i = 0; i < XNSELECT_MAX_TYPES; i++)
|
if (fds[i]
|
&& (fd = find_first_bit(fds[i]->fds_bits, nfds)) < nfds)
|
return rtdm_fd_valid_p(fd);
|
|
/* All empty is correct, used as a "sleep" mechanism by strange
|
applications. */
|
return 1;
|
}
|
|
static int __cobalt_select_bind_all(struct xnselector *selector,
|
fd_set *fds[XNSELECT_MAX_TYPES], int nfds)
|
{
|
bool first_fd = true;
|
unsigned fd, type;
|
int err;
|
|
for (type = 0; type < XNSELECT_MAX_TYPES; type++) {
|
fd_set *set = fds[type];
|
if (set)
|
for (fd = find_first_bit(set->fds_bits, nfds);
|
fd < nfds;
|
fd = find_next_bit(set->fds_bits, nfds, fd + 1)) {
|
err = rtdm_fd_select(fd, selector, type);
|
if (err) {
|
/*
|
* Do not needlessly signal "retry
|
* under Linux" for mixed fd sets.
|
*/
|
if (err == -EADV && !first_fd)
|
return -EBADF;
|
return err;
|
}
|
first_fd = false;
|
}
|
}
|
|
return 0;
|
}
|
|
int __cobalt_select(int nfds, void __user *u_rfds, void __user *u_wfds,
|
void __user *u_xfds, void __user *u_tv, bool compat)
|
{
|
void __user *ufd_sets[XNSELECT_MAX_TYPES] = {
|
[XNSELECT_READ] = u_rfds,
|
[XNSELECT_WRITE] = u_wfds,
|
[XNSELECT_EXCEPT] = u_xfds
|
};
|
fd_set *in_fds[XNSELECT_MAX_TYPES] = {NULL, NULL, NULL};
|
fd_set *out_fds[XNSELECT_MAX_TYPES] = {NULL, NULL, NULL};
|
fd_set in_fds_storage[XNSELECT_MAX_TYPES],
|
out_fds_storage[XNSELECT_MAX_TYPES];
|
xnticks_t timeout = XN_INFINITE;
|
struct restart_block *restart;
|
xntmode_t mode = XN_RELATIVE;
|
struct xnselector *selector;
|
struct xnthread *curr;
|
struct __kernel_old_timeval tv;
|
size_t fds_size;
|
int i, err;
|
|
curr = xnthread_current();
|
|
if (u_tv) {
|
if (xnthread_test_localinfo(curr, XNSYSRST)) {
|
xnthread_clear_localinfo(curr, XNSYSRST);
|
|
restart = cobalt_get_restart_block(current);
|
timeout = restart->nanosleep.expires;
|
|
if (restart->fn != cobalt_restart_syscall_placeholder) {
|
err = -EINTR;
|
goto out;
|
}
|
} else {
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (compat) {
|
if (sys32_get_timeval(&tv, u_tv))
|
return -EFAULT;
|
} else
|
#endif
|
{
|
if (!access_wok(u_tv, sizeof(tv))
|
|| cobalt_copy_from_user(&tv, u_tv,
|
sizeof(tv)))
|
return -EFAULT;
|
}
|
|
if (tv.tv_usec >= 1000000)
|
return -EINVAL;
|
|
timeout = clock_get_ticks(CLOCK_MONOTONIC) + tv2ns(&tv);
|
}
|
|
mode = XN_ABSOLUTE;
|
}
|
|
fds_size = __FDELT__(nfds + __NFDBITS__ - 1) * sizeof(long);
|
|
for (i = 0; i < XNSELECT_MAX_TYPES; i++)
|
if (ufd_sets[i]) {
|
in_fds[i] = &in_fds_storage[i];
|
out_fds[i] = &out_fds_storage[i];
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (compat) {
|
if (sys32_get_fdset(in_fds[i], ufd_sets[i],
|
fds_size))
|
return -EFAULT;
|
} else
|
#endif
|
{
|
if (!access_wok((void __user *) ufd_sets[i],
|
sizeof(fd_set))
|
|| cobalt_copy_from_user(in_fds[i],
|
(void __user *)ufd_sets[i],
|
fds_size))
|
return -EFAULT;
|
}
|
}
|
|
selector = curr->selector;
|
if (!selector) {
|
/* This function may be called from pure Linux fd_sets, we want
|
to avoid the xnselector allocation in this case, so, we do a
|
simple test: test if the first file descriptor we find in the
|
fd_set is an RTDM descriptor or a message queue descriptor. */
|
if (!__cobalt_first_fd_valid_p(in_fds, nfds))
|
return -EADV;
|
|
selector = xnmalloc(sizeof(*curr->selector));
|
if (selector == NULL)
|
return -ENOMEM;
|
xnselector_init(selector);
|
curr->selector = selector;
|
|
/* Bind directly the file descriptors, we do not need to go
|
through xnselect returning -ECHRNG */
|
err = __cobalt_select_bind_all(selector, in_fds, nfds);
|
if (err)
|
return err;
|
}
|
|
do {
|
err = xnselect(selector, out_fds, in_fds, nfds, timeout, mode);
|
if (err == -ECHRNG) {
|
int bind_err = __cobalt_select_bind_all(selector,
|
out_fds, nfds);
|
if (bind_err)
|
return bind_err;
|
}
|
} while (err == -ECHRNG);
|
|
if (err == -EINTR && signal_pending(current)) {
|
xnthread_set_localinfo(curr, XNSYSRST);
|
|
restart = cobalt_get_restart_block(current);
|
restart->fn = cobalt_restart_syscall_placeholder;
|
restart->nanosleep.expires = timeout;
|
|
return -ERESTARTSYS;
|
}
|
|
out:
|
if (u_tv && (err > 0 || err == -EINTR)) {
|
xnsticks_t diff = timeout - clock_get_ticks(CLOCK_MONOTONIC);
|
if (diff > 0)
|
ticks2tv(&tv, diff);
|
else
|
tv.tv_sec = tv.tv_usec = 0;
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (compat) {
|
if (sys32_put_timeval(u_tv, &tv))
|
return -EFAULT;
|
} else
|
#endif
|
{
|
if (cobalt_copy_to_user(u_tv, &tv, sizeof(tv)))
|
return -EFAULT;
|
}
|
}
|
|
if (err >= 0)
|
for (i = 0; i < XNSELECT_MAX_TYPES; i++) {
|
if (!ufd_sets[i])
|
continue;
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (compat) {
|
if (sys32_put_fdset(ufd_sets[i], out_fds[i],
|
sizeof(fd_set)))
|
return -EFAULT;
|
} else
|
#endif
|
{
|
if (cobalt_copy_to_user((void __user *)ufd_sets[i],
|
out_fds[i], sizeof(fd_set)))
|
return -EFAULT;
|
}
|
}
|
return err;
|
}
|
|
/* int select(int, fd_set *, fd_set *, fd_set *, struct __kernel_old_timeval *) */
|
COBALT_SYSCALL(select, primary,
|
(int nfds,
|
fd_set __user *u_rfds,
|
fd_set __user *u_wfds,
|
fd_set __user *u_xfds,
|
struct __kernel_old_timeval __user *u_tv))
|
{
|
return __cobalt_select(nfds, u_rfds, u_wfds, u_xfds, u_tv, false);
|
}
|
