/**
|
* This file is part of the Xenomai project.
|
*
|
* @note Copyright (C) 2009 Philippe Gerum <rpm@xenomai.org>
|
*
|
* This program 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.
|
*
|
* This program 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 this program; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
#include <linux/module.h>
|
#include <linux/init.h>
|
#include <linux/slab.h>
|
#include <linux/poll.h>
|
#include <linux/time.h>
|
#include <rtdm/ipc.h>
|
#include <rtdm/compat.h>
|
#include "internal.h"
|
|
MODULE_DESCRIPTION("Real-time IPC interface");
|
MODULE_AUTHOR("Philippe Gerum <rpm@xenomai.org>");
|
MODULE_LICENSE("GPL");
|
|
static struct rtipc_protocol *protocols[IPCPROTO_MAX] = {
|
#ifdef CONFIG_XENO_DRIVERS_RTIPC_XDDP
|
[IPCPROTO_XDDP - 1] = &xddp_proto_driver,
|
#endif
|
#ifdef CONFIG_XENO_DRIVERS_RTIPC_IDDP
|
[IPCPROTO_IDDP - 1] = &iddp_proto_driver,
|
#endif
|
#ifdef CONFIG_XENO_DRIVERS_RTIPC_BUFP
|
[IPCPROTO_BUFP - 1] = &bufp_proto_driver,
|
#endif
|
};
|
|
DEFINE_XNPTREE(rtipc_ptree, "rtipc");
|
|
int rtipc_get_arg(struct rtdm_fd *fd, void *dst, const void *src, size_t len)
|
{
|
if (!rtdm_fd_is_user(fd)) {
|
memcpy(dst, src, len);
|
return 0;
|
}
|
|
return rtdm_copy_from_user(fd, dst, src, len);
|
}
|
|
int rtipc_put_arg(struct rtdm_fd *fd, void *dst, const void *src, size_t len)
|
{
|
if (!rtdm_fd_is_user(fd)) {
|
memcpy(dst, src, len);
|
return 0;
|
}
|
|
return rtdm_copy_to_user(fd, dst, src, len);
|
}
|
|
int rtipc_get_sockaddr(struct rtdm_fd *fd, struct sockaddr_ipc **saddrp,
|
const void *arg)
|
{
|
const struct _rtdm_setsockaddr_args *p;
|
struct _rtdm_setsockaddr_args sreq;
|
int ret;
|
|
if (!rtdm_fd_is_user(fd)) {
|
p = arg;
|
if (p->addrlen > 0) {
|
if (p->addrlen != sizeof(**saddrp))
|
return -EINVAL;
|
memcpy(*saddrp, p->addr, sizeof(**saddrp));
|
} else {
|
if (p->addr)
|
return -EINVAL;
|
*saddrp = NULL;
|
}
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
struct compat_rtdm_setsockaddr_args csreq;
|
ret = rtdm_safe_copy_from_user(fd, &csreq, arg, sizeof(csreq));
|
if (ret)
|
return ret;
|
if (csreq.addrlen > 0) {
|
if (csreq.addrlen != sizeof(**saddrp))
|
return -EINVAL;
|
return rtdm_safe_copy_from_user(fd, *saddrp,
|
compat_ptr(csreq.addr),
|
sizeof(**saddrp));
|
}
|
if (csreq.addr)
|
return -EINVAL;
|
|
*saddrp = NULL;
|
|
return 0;
|
}
|
#endif
|
|
ret = rtdm_safe_copy_from_user(fd, &sreq, arg, sizeof(sreq));
|
if (ret)
|
return ret;
|
if (sreq.addrlen > 0) {
|
if (sreq.addrlen != sizeof(**saddrp))
|
return -EINVAL;
|
return rtdm_safe_copy_from_user(fd, *saddrp,
|
sreq.addr, sizeof(**saddrp));
|
}
|
if (sreq.addr)
|
return -EINVAL;
|
|
*saddrp = NULL;
|
|
return 0;
|
}
|
|
int rtipc_put_sockaddr(struct rtdm_fd *fd, void *arg,
|
const struct sockaddr_ipc *saddr)
|
{
|
const struct _rtdm_getsockaddr_args *p;
|
struct _rtdm_getsockaddr_args sreq;
|
socklen_t len;
|
int ret;
|
|
if (!rtdm_fd_is_user(fd)) {
|
p = arg;
|
if (*p->addrlen < sizeof(*saddr))
|
return -EINVAL;
|
memcpy(p->addr, saddr, sizeof(*saddr));
|
*p->addrlen = sizeof(*saddr);
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
struct compat_rtdm_getsockaddr_args csreq;
|
ret = rtdm_safe_copy_from_user(fd, &csreq, arg, sizeof(csreq));
|
if (ret)
|
return ret;
|
|
ret = rtdm_safe_copy_from_user(fd, &len,
|
compat_ptr(csreq.addrlen),
|
sizeof(len));
|
if (ret)
|
return ret;
|
|
if (len < sizeof(*saddr))
|
return -EINVAL;
|
|
ret = rtdm_safe_copy_to_user(fd, compat_ptr(csreq.addr),
|
saddr, sizeof(*saddr));
|
if (ret)
|
return ret;
|
|
len = sizeof(*saddr);
|
return rtdm_safe_copy_to_user(fd, compat_ptr(csreq.addrlen),
|
&len, sizeof(len));
|
}
|
#endif
|
|
sreq.addr = NULL;
|
sreq.addrlen = NULL;
|
ret = rtdm_safe_copy_from_user(fd, &sreq, arg, sizeof(sreq));
|
if (ret)
|
return ret;
|
|
ret = rtdm_safe_copy_from_user(fd, &len, sreq.addrlen, sizeof(len));
|
if (ret)
|
return ret;
|
|
if (len < sizeof(*saddr))
|
return -EINVAL;
|
|
ret = rtdm_safe_copy_to_user(fd, sreq.addr, saddr, sizeof(*saddr));
|
if (ret)
|
return ret;
|
|
len = sizeof(*saddr);
|
|
return rtdm_safe_copy_to_user(fd, sreq.addrlen, &len, sizeof(len));
|
}
|
|
int rtipc_get_sockoptout(struct rtdm_fd *fd, struct _rtdm_getsockopt_args *sopt,
|
const void *arg)
|
{
|
if (!rtdm_fd_is_user(fd)) {
|
*sopt = *(struct _rtdm_getsockopt_args *)arg;
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
struct compat_rtdm_getsockopt_args csopt;
|
int ret;
|
ret = rtdm_safe_copy_from_user(fd, &csopt, arg, sizeof(csopt));
|
if (ret)
|
return ret;
|
sopt->level = csopt.level;
|
sopt->optname = csopt.optname;
|
sopt->optval = compat_ptr(csopt.optval);
|
sopt->optlen = compat_ptr(csopt.optlen);
|
return 0;
|
}
|
#endif
|
|
return rtdm_safe_copy_from_user(fd, sopt, arg, sizeof(*sopt));
|
}
|
|
int rtipc_put_sockoptout(struct rtdm_fd *fd, void *arg,
|
const struct _rtdm_getsockopt_args *sopt)
|
{
|
if (!rtdm_fd_is_user(fd)) {
|
*(struct _rtdm_getsockopt_args *)arg = *sopt;
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
struct compat_rtdm_getsockopt_args csopt;
|
int ret;
|
csopt.level = sopt->level;
|
csopt.optname = sopt->optname;
|
csopt.optval = ptr_to_compat(sopt->optval);
|
csopt.optlen = ptr_to_compat(sopt->optlen);
|
ret = rtdm_safe_copy_to_user(fd, arg, &csopt, sizeof(csopt));
|
if (ret)
|
return ret;
|
return 0;
|
}
|
#endif
|
|
return rtdm_safe_copy_to_user(fd, arg, sopt, sizeof(*sopt));
|
}
|
|
int rtipc_get_sockoptin(struct rtdm_fd *fd, struct _rtdm_setsockopt_args *sopt,
|
const void *arg)
|
{
|
if (!rtdm_fd_is_user(fd)) {
|
*sopt = *(struct _rtdm_setsockopt_args *)arg;
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
struct compat_rtdm_setsockopt_args csopt;
|
int ret;
|
ret = rtdm_safe_copy_from_user(fd, &csopt, arg, sizeof(csopt));
|
if (ret)
|
return ret;
|
sopt->level = csopt.level;
|
sopt->optname = csopt.optname;
|
sopt->optval = compat_ptr(csopt.optval);
|
sopt->optlen = csopt.optlen;
|
return 0;
|
}
|
#endif
|
|
return rtdm_safe_copy_from_user(fd, sopt, arg, sizeof(*sopt));
|
}
|
|
int rtipc_get_timeval(struct rtdm_fd *fd, struct __kernel_old_timeval *tv,
|
const void *arg, size_t arglen)
|
{
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
if (arglen != sizeof(struct old_timeval32))
|
return -EINVAL;
|
return sys32_get_timeval(tv, arg);
|
}
|
#endif
|
|
if (arglen != sizeof(*tv))
|
return -EINVAL;
|
|
if (!rtdm_fd_is_user(fd)) {
|
*tv = *(struct __kernel_old_timeval *)arg;
|
return 0;
|
}
|
|
return rtdm_safe_copy_from_user(fd, tv, arg, sizeof(*tv));
|
}
|
|
int rtipc_put_timeval(struct rtdm_fd *fd, void *arg,
|
const struct __kernel_old_timeval *tv, size_t arglen)
|
{
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
if (arglen != sizeof(struct old_timeval32))
|
return -EINVAL;
|
return sys32_put_timeval(arg, tv);
|
}
|
#endif
|
|
if (arglen != sizeof(*tv))
|
return -EINVAL;
|
|
if (!rtdm_fd_is_user(fd)) {
|
*(struct __kernel_old_timeval *)arg = *tv;
|
return 0;
|
}
|
|
return rtdm_safe_copy_to_user(fd, arg, tv, sizeof(*tv));
|
}
|
|
int rtipc_get_length(struct rtdm_fd *fd, size_t *lenp,
|
const void *arg, size_t arglen)
|
{
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (rtdm_fd_is_compat(fd)) {
|
const compat_size_t *csz;
|
if (arglen != sizeof(*csz))
|
return -EINVAL;
|
csz = arg;
|
return csz == NULL ||
|
!access_rok(csz, sizeof(*csz)) ||
|
__xn_get_user(*lenp, csz) ? -EFAULT : 0;
|
}
|
#endif
|
|
if (arglen != sizeof(size_t))
|
return -EINVAL;
|
|
if (!rtdm_fd_is_user(fd)) {
|
*lenp = *(size_t *)arg;
|
return 0;
|
}
|
|
return rtdm_safe_copy_from_user(fd, lenp, arg, sizeof(*lenp));
|
}
|
|
static int rtipc_socket(struct rtdm_fd *fd, int protocol)
|
{
|
struct rtipc_protocol *proto;
|
struct rtipc_private *priv;
|
int ret;
|
|
if (protocol < 0 || protocol >= IPCPROTO_MAX)
|
return -EPROTONOSUPPORT;
|
|
if (protocol == IPCPROTO_IPC)
|
/* Default protocol is IDDP */
|
protocol = IPCPROTO_IDDP;
|
|
proto = protocols[protocol - 1];
|
if (proto == NULL) /* Not compiled in? */
|
return -ENOPROTOOPT;
|
|
priv = rtdm_fd_to_private(fd);
|
priv->proto = proto;
|
priv->state = kmalloc(proto->proto_statesz, GFP_KERNEL);
|
if (priv->state == NULL)
|
return -ENOMEM;
|
|
xnselect_init(&priv->send_block);
|
xnselect_init(&priv->recv_block);
|
|
ret = proto->proto_ops.socket(fd);
|
if (ret)
|
kfree(priv->state);
|
|
return ret;
|
}
|
|
static void rtipc_close(struct rtdm_fd *fd)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
/*
|
* CAUTION: priv->state shall be released by the
|
* proto_ops.close() handler when appropriate (which may be
|
* done asynchronously later, see XDDP).
|
*/
|
priv->proto->proto_ops.close(fd);
|
xnselect_destroy(&priv->recv_block);
|
xnselect_destroy(&priv->send_block);
|
}
|
|
static ssize_t rtipc_recvmsg(struct rtdm_fd *fd,
|
struct user_msghdr *msg, int flags)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
return priv->proto->proto_ops.recvmsg(fd, msg, flags);
|
}
|
|
static ssize_t rtipc_sendmsg(struct rtdm_fd *fd,
|
const struct user_msghdr *msg, int flags)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
return priv->proto->proto_ops.sendmsg(fd, msg, flags);
|
}
|
|
static ssize_t rtipc_read(struct rtdm_fd *fd,
|
void *buf, size_t len)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
return priv->proto->proto_ops.read(fd, buf, len);
|
}
|
|
static ssize_t rtipc_write(struct rtdm_fd *fd,
|
const void *buf, size_t len)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
return priv->proto->proto_ops.write(fd, buf, len);
|
}
|
|
static int rtipc_ioctl(struct rtdm_fd *fd,
|
unsigned int request, void *arg)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
return priv->proto->proto_ops.ioctl(fd, request, arg);
|
}
|
|
static int rtipc_select(struct rtdm_fd *fd, struct xnselector *selector,
|
unsigned int type, unsigned int index)
|
{
|
struct rtipc_private *priv = rtdm_fd_to_private(fd);
|
struct xnselect_binding *binding;
|
unsigned int pollstate, mask;
|
struct xnselect *block;
|
spl_t s;
|
int ret;
|
|
if (type != XNSELECT_READ && type != XNSELECT_WRITE)
|
return -EINVAL;
|
|
binding = xnmalloc(sizeof(*binding));
|
if (binding == NULL)
|
return -ENOMEM;
|
|
cobalt_atomic_enter(s);
|
|
pollstate = priv->proto->proto_ops.pollstate(fd);
|
|
if (type == XNSELECT_READ) {
|
mask = pollstate & POLLIN;
|
block = &priv->recv_block;
|
} else {
|
mask = pollstate & POLLOUT;
|
block = &priv->send_block;
|
}
|
|
ret = xnselect_bind(block, binding, selector, type, index, mask);
|
|
cobalt_atomic_leave(s);
|
|
if (ret)
|
xnfree(binding);
|
|
return ret;
|
}
|
|
static struct rtdm_driver rtipc_driver = {
|
.profile_info = RTDM_PROFILE_INFO(rtipc,
|
RTDM_CLASS_RTIPC,
|
RTDM_SUBCLASS_GENERIC,
|
1),
|
.device_flags = RTDM_PROTOCOL_DEVICE,
|
.device_count = 1,
|
.context_size = sizeof(struct rtipc_private),
|
.protocol_family = PF_RTIPC,
|
.socket_type = SOCK_DGRAM,
|
.ops = {
|
.socket = rtipc_socket,
|
.close = rtipc_close,
|
.recvmsg_rt = rtipc_recvmsg,
|
.recvmsg_nrt = NULL,
|
.sendmsg_rt = rtipc_sendmsg,
|
.sendmsg_nrt = NULL,
|
.ioctl_rt = rtipc_ioctl,
|
.ioctl_nrt = rtipc_ioctl,
|
.read_rt = rtipc_read,
|
.read_nrt = NULL,
|
.write_rt = rtipc_write,
|
.write_nrt = NULL,
|
.select = rtipc_select,
|
},
|
};
|
|
static struct rtdm_device device = {
|
.driver = &rtipc_driver,
|
.label = "rtipc",
|
};
|
|
int __init __rtipc_init(void)
|
{
|
int ret, n;
|
|
if (!rtdm_available())
|
return -ENOSYS;
|
|
for (n = 0; n < IPCPROTO_MAX; n++) {
|
if (protocols[n] && protocols[n]->proto_init) {
|
ret = protocols[n]->proto_init();
|
if (ret)
|
return ret;
|
}
|
}
|
|
return rtdm_dev_register(&device);
|
}
|
|
void __exit __rtipc_exit(void)
|
{
|
int n;
|
|
rtdm_dev_unregister(&device);
|
|
for (n = 0; n < IPCPROTO_MAX; n++) {
|
if (protocols[n] && protocols[n]->proto_exit)
|
protocols[n]->proto_exit();
|
}
|
}
|
|
module_init(__rtipc_init);
|
module_exit(__rtipc_exit);
|
