/*
|
* Copyright (C) 2014 Philippe Gerum <rpm@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 this program; 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/memory.h>
|
#include <linux/module.h>
|
#include <cobalt/kernel/compat.h>
|
#include <asm/xenomai/syscall.h>
|
#include <xenomai/posix/mqueue.h>
|
|
int sys32_get_timespec(struct timespec64 *ts,
|
const struct old_timespec32 __user *u_cts)
|
{
|
struct old_timespec32 cts;
|
|
if (u_cts == NULL || !access_rok(u_cts, sizeof(*u_cts)))
|
return -EFAULT;
|
|
if (__xn_get_user(cts.tv_sec, &u_cts->tv_sec) ||
|
__xn_get_user(cts.tv_nsec, &u_cts->tv_nsec))
|
return -EFAULT;
|
|
ts->tv_sec = cts.tv_sec;
|
ts->tv_nsec = cts.tv_nsec;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_timespec);
|
|
int sys32_put_timespec(struct old_timespec32 __user *u_cts,
|
const struct timespec64 *ts)
|
{
|
struct old_timespec32 cts;
|
|
if (u_cts == NULL || !access_wok(u_cts, sizeof(*u_cts)))
|
return -EFAULT;
|
|
cts.tv_sec = ts->tv_sec;
|
cts.tv_nsec = ts->tv_nsec;
|
|
if (__xn_put_user(cts.tv_sec, &u_cts->tv_sec) ||
|
__xn_put_user(cts.tv_nsec, &u_cts->tv_nsec))
|
return -EFAULT;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_timespec);
|
|
int sys32_get_itimerspec(struct itimerspec64 *its,
|
const struct old_itimerspec32 __user *cits)
|
{
|
int ret = sys32_get_timespec(&its->it_value, &cits->it_value);
|
|
return ret ?: sys32_get_timespec(&its->it_interval, &cits->it_interval);
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_itimerspec);
|
|
int sys32_put_itimerspec(struct old_itimerspec32 __user *cits,
|
const struct itimerspec64 *its)
|
{
|
int ret = sys32_put_timespec(&cits->it_value, &its->it_value);
|
|
return ret ?: sys32_put_timespec(&cits->it_interval, &its->it_interval);
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_itimerspec);
|
|
int sys32_get_timeval(struct __kernel_old_timeval *tv,
|
const struct old_timeval32 __user *ctv)
|
{
|
return (ctv == NULL ||
|
!access_rok(ctv, sizeof(*ctv)) ||
|
__xn_get_user(tv->tv_sec, &ctv->tv_sec) ||
|
__xn_get_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_timeval);
|
|
int sys32_put_timeval(struct old_timeval32 __user *ctv,
|
const struct __kernel_old_timeval *tv)
|
{
|
return (ctv == NULL ||
|
!access_wok(ctv, sizeof(*ctv)) ||
|
__xn_put_user(tv->tv_sec, &ctv->tv_sec) ||
|
__xn_put_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_timeval);
|
|
int sys32_get_timex(struct __kernel_timex *tx,
|
const struct old_timex32 __user *ctx)
|
{
|
struct __kernel_old_timeval time;
|
int ret;
|
|
memset(tx, 0, sizeof(*tx));
|
|
ret = sys32_get_timeval(&time, &ctx->time);
|
if (ret)
|
return ret;
|
|
tx->time.tv_sec = time.tv_sec;
|
tx->time.tv_usec = time.tv_usec;
|
|
if (!access_rok(ctx, sizeof(*ctx)) ||
|
__xn_get_user(tx->modes, &ctx->modes) ||
|
__xn_get_user(tx->offset, &ctx->offset) ||
|
__xn_get_user(tx->freq, &ctx->freq) ||
|
__xn_get_user(tx->maxerror, &ctx->maxerror) ||
|
__xn_get_user(tx->esterror, &ctx->esterror) ||
|
__xn_get_user(tx->status, &ctx->status) ||
|
__xn_get_user(tx->constant, &ctx->constant) ||
|
__xn_get_user(tx->precision, &ctx->precision) ||
|
__xn_get_user(tx->tolerance, &ctx->tolerance) ||
|
__xn_get_user(tx->tick, &ctx->tick) ||
|
__xn_get_user(tx->ppsfreq, &ctx->ppsfreq) ||
|
__xn_get_user(tx->jitter, &ctx->jitter) ||
|
__xn_get_user(tx->shift, &ctx->shift) ||
|
__xn_get_user(tx->stabil, &ctx->stabil) ||
|
__xn_get_user(tx->jitcnt, &ctx->jitcnt) ||
|
__xn_get_user(tx->calcnt, &ctx->calcnt) ||
|
__xn_get_user(tx->errcnt, &ctx->errcnt) ||
|
__xn_get_user(tx->stbcnt, &ctx->stbcnt))
|
return -EFAULT;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_timex);
|
|
int sys32_put_timex(struct old_timex32 __user *ctx,
|
const struct __kernel_timex *tx)
|
{
|
struct __kernel_old_timeval time;
|
int ret;
|
|
time.tv_sec = tx->time.tv_sec;
|
time.tv_usec = tx->time.tv_usec;
|
|
ret = sys32_put_timeval(&ctx->time, &time);
|
if (ret)
|
return ret;
|
|
if (!access_wok(ctx, sizeof(*ctx)) ||
|
__xn_put_user(tx->modes, &ctx->modes) ||
|
__xn_put_user(tx->offset, &ctx->offset) ||
|
__xn_put_user(tx->freq, &ctx->freq) ||
|
__xn_put_user(tx->maxerror, &ctx->maxerror) ||
|
__xn_put_user(tx->esterror, &ctx->esterror) ||
|
__xn_put_user(tx->status, &ctx->status) ||
|
__xn_put_user(tx->constant, &ctx->constant) ||
|
__xn_put_user(tx->precision, &ctx->precision) ||
|
__xn_put_user(tx->tolerance, &ctx->tolerance) ||
|
__xn_put_user(tx->tick, &ctx->tick) ||
|
__xn_put_user(tx->ppsfreq, &ctx->ppsfreq) ||
|
__xn_put_user(tx->jitter, &ctx->jitter) ||
|
__xn_put_user(tx->shift, &ctx->shift) ||
|
__xn_put_user(tx->stabil, &ctx->stabil) ||
|
__xn_put_user(tx->jitcnt, &ctx->jitcnt) ||
|
__xn_put_user(tx->calcnt, &ctx->calcnt) ||
|
__xn_put_user(tx->errcnt, &ctx->errcnt) ||
|
__xn_put_user(tx->stbcnt, &ctx->stbcnt))
|
return -EFAULT;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_timex);
|
|
int sys32_get_fdset(fd_set *fds, const compat_fd_set __user *cfds,
|
size_t cfdsize)
|
{
|
int rdpos, wrpos, rdlim = cfdsize / sizeof(compat_ulong_t);
|
|
if (cfds == NULL || !access_rok(cfds, cfdsize))
|
return -EFAULT;
|
|
for (rdpos = 0, wrpos = 0; rdpos < rdlim; rdpos++, wrpos++)
|
if (__xn_get_user(fds->fds_bits[wrpos], cfds->fds_bits + rdpos))
|
return -EFAULT;
|
|
return 0;
|
}
|
|
int sys32_put_fdset(compat_fd_set __user *cfds, const fd_set *fds,
|
size_t fdsize)
|
{
|
int rdpos, wrpos, wrlim = fdsize / sizeof(long);
|
|
if (cfds == NULL || !access_wok(cfds, wrlim * sizeof(compat_ulong_t)))
|
return -EFAULT;
|
|
for (rdpos = 0, wrpos = 0; wrpos < wrlim; rdpos++, wrpos++)
|
if (__xn_put_user(fds->fds_bits[rdpos], cfds->fds_bits + wrpos))
|
return -EFAULT;
|
|
return 0;
|
}
|
|
int sys32_get_param_ex(int policy,
|
struct sched_param_ex *p,
|
const struct compat_sched_param_ex __user *u_cp)
|
{
|
struct compat_sched_param_ex cpex;
|
|
if (u_cp == NULL || cobalt_copy_from_user(&cpex, u_cp, sizeof(cpex)))
|
return -EFAULT;
|
|
p->sched_priority = cpex.sched_priority;
|
|
switch (policy) {
|
case SCHED_SPORADIC:
|
p->sched_ss_low_priority = cpex.sched_ss_low_priority;
|
p->sched_ss_max_repl = cpex.sched_ss_max_repl;
|
p->sched_ss_repl_period.tv_sec = cpex.sched_ss_repl_period.tv_sec;
|
p->sched_ss_repl_period.tv_nsec = cpex.sched_ss_repl_period.tv_nsec;
|
p->sched_ss_init_budget.tv_sec = cpex.sched_ss_init_budget.tv_sec;
|
p->sched_ss_init_budget.tv_nsec = cpex.sched_ss_init_budget.tv_nsec;
|
break;
|
case SCHED_RR:
|
p->sched_rr_quantum.tv_sec = cpex.sched_rr_quantum.tv_sec;
|
p->sched_rr_quantum.tv_nsec = cpex.sched_rr_quantum.tv_nsec;
|
break;
|
case SCHED_TP:
|
p->sched_tp_partition = cpex.sched_tp_partition;
|
break;
|
case SCHED_QUOTA:
|
p->sched_quota_group = cpex.sched_quota_group;
|
break;
|
}
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_param_ex);
|
|
int sys32_put_param_ex(int policy,
|
struct compat_sched_param_ex __user *u_cp,
|
const struct sched_param_ex *p)
|
{
|
struct compat_sched_param_ex cpex;
|
|
if (u_cp == NULL)
|
return -EFAULT;
|
|
cpex.sched_priority = p->sched_priority;
|
|
switch (policy) {
|
case SCHED_SPORADIC:
|
cpex.sched_ss_low_priority = p->sched_ss_low_priority;
|
cpex.sched_ss_max_repl = p->sched_ss_max_repl;
|
cpex.sched_ss_repl_period.tv_sec = p->sched_ss_repl_period.tv_sec;
|
cpex.sched_ss_repl_period.tv_nsec = p->sched_ss_repl_period.tv_nsec;
|
cpex.sched_ss_init_budget.tv_sec = p->sched_ss_init_budget.tv_sec;
|
cpex.sched_ss_init_budget.tv_nsec = p->sched_ss_init_budget.tv_nsec;
|
break;
|
case SCHED_RR:
|
cpex.sched_rr_quantum.tv_sec = p->sched_rr_quantum.tv_sec;
|
cpex.sched_rr_quantum.tv_nsec = p->sched_rr_quantum.tv_nsec;
|
break;
|
case SCHED_TP:
|
cpex.sched_tp_partition = p->sched_tp_partition;
|
break;
|
case SCHED_QUOTA:
|
cpex.sched_quota_group = p->sched_quota_group;
|
break;
|
}
|
|
return cobalt_copy_to_user(u_cp, &cpex, sizeof(cpex));
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_param_ex);
|
|
int sys32_get_mqattr(struct mq_attr *ap,
|
const struct compat_mq_attr __user *u_cap)
|
{
|
struct compat_mq_attr cattr;
|
|
if (u_cap == NULL ||
|
cobalt_copy_from_user(&cattr, u_cap, sizeof(cattr)))
|
return -EFAULT;
|
|
ap->mq_flags = cattr.mq_flags;
|
ap->mq_maxmsg = cattr.mq_maxmsg;
|
ap->mq_msgsize = cattr.mq_msgsize;
|
ap->mq_curmsgs = cattr.mq_curmsgs;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_mqattr);
|
|
int sys32_put_mqattr(struct compat_mq_attr __user *u_cap,
|
const struct mq_attr *ap)
|
{
|
struct compat_mq_attr cattr;
|
|
cattr.mq_flags = ap->mq_flags;
|
cattr.mq_maxmsg = ap->mq_maxmsg;
|
cattr.mq_msgsize = ap->mq_msgsize;
|
cattr.mq_curmsgs = ap->mq_curmsgs;
|
|
return u_cap == NULL ? -EFAULT :
|
cobalt_copy_to_user(u_cap, &cattr, sizeof(cattr));
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_mqattr);
|
|
int sys32_get_sigevent(struct sigevent *ev,
|
const struct compat_sigevent *__user u_cev)
|
{
|
struct compat_sigevent cev;
|
compat_int_t *cp;
|
int ret, *p;
|
|
if (u_cev == NULL)
|
return -EFAULT;
|
|
ret = cobalt_copy_from_user(&cev, u_cev, sizeof(cev));
|
if (ret)
|
return ret;
|
|
memset(ev, 0, sizeof(*ev));
|
ev->sigev_value.sival_ptr = compat_ptr(cev.sigev_value.sival_ptr);
|
ev->sigev_signo = cev.sigev_signo;
|
ev->sigev_notify = cev.sigev_notify;
|
/*
|
* Extensions may define extra fields we don't know about in
|
* the padding area, so we have to load it entirely.
|
*/
|
p = ev->_sigev_un._pad;
|
cp = cev._sigev_un._pad;
|
while (p < &ev->_sigev_un._pad[ARRAY_SIZE(ev->_sigev_un._pad)] &&
|
cp < &cev._sigev_un._pad[ARRAY_SIZE(cev._sigev_un._pad)])
|
*p++ = *cp++;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_sigevent);
|
|
int sys32_get_sigset(sigset_t *set, const compat_sigset_t *u_cset)
|
{
|
#ifdef __BIG_ENDIAN
|
compat_sigset_t v;
|
|
if (cobalt_copy_from_user(&v, u_cset, sizeof(compat_sigset_t)))
|
return -EFAULT;
|
switch (_NSIG_WORDS) {
|
case 4: set->sig[3] = v.sig[6] | (((long)v.sig[7]) << 32 );
|
case 3: set->sig[2] = v.sig[4] | (((long)v.sig[5]) << 32 );
|
case 2: set->sig[1] = v.sig[2] | (((long)v.sig[3]) << 32 );
|
case 1: set->sig[0] = v.sig[0] | (((long)v.sig[1]) << 32 );
|
}
|
#else
|
if (cobalt_copy_from_user(set, u_cset, sizeof(compat_sigset_t)))
|
return -EFAULT;
|
#endif
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_sigset);
|
|
int sys32_put_sigset(compat_sigset_t *u_cset, const sigset_t *set)
|
{
|
#ifdef __BIG_ENDIAN
|
compat_sigset_t v;
|
switch (_NSIG_WORDS) {
|
case 4: v.sig[7] = (set->sig[3] >> 32); v.sig[6] = set->sig[3];
|
case 3: v.sig[5] = (set->sig[2] >> 32); v.sig[4] = set->sig[2];
|
case 2: v.sig[3] = (set->sig[1] >> 32); v.sig[2] = set->sig[1];
|
case 1: v.sig[1] = (set->sig[0] >> 32); v.sig[0] = set->sig[0];
|
}
|
return cobalt_copy_to_user(u_cset, &v, sizeof(*u_cset)) ? -EFAULT : 0;
|
#else
|
return cobalt_copy_to_user(u_cset, set, sizeof(*u_cset)) ? -EFAULT : 0;
|
#endif
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_sigset);
|
|
int sys32_get_sigval(union sigval *val, const union compat_sigval *u_cval)
|
{
|
union compat_sigval cval;
|
int ret;
|
|
if (u_cval == NULL)
|
return -EFAULT;
|
|
ret = cobalt_copy_from_user(&cval, u_cval, sizeof(cval));
|
if (ret)
|
return ret;
|
|
val->sival_ptr = compat_ptr(cval.sival_ptr);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_sigval);
|
|
int sys32_put_siginfo(void __user *u_si, const struct siginfo *si,
|
int overrun)
|
{
|
struct compat_siginfo __user *u_p = u_si;
|
int ret;
|
|
if (u_p == NULL)
|
return -EFAULT;
|
|
ret = __xn_put_user(si->si_signo, &u_p->si_signo);
|
ret |= __xn_put_user(si->si_errno, &u_p->si_errno);
|
ret |= __xn_put_user(si->si_code, &u_p->si_code);
|
|
/*
|
* Copy the generic/standard siginfo bits to userland.
|
*/
|
switch (si->si_code) {
|
case SI_TIMER:
|
ret |= __xn_put_user(si->si_tid, &u_p->si_tid);
|
ret |= __xn_put_user(ptr_to_compat(si->si_ptr), &u_p->si_ptr);
|
ret |= __xn_put_user(overrun, &u_p->si_overrun);
|
break;
|
case SI_QUEUE:
|
case SI_MESGQ:
|
ret |= __xn_put_user(ptr_to_compat(si->si_ptr), &u_p->si_ptr);
|
fallthrough;
|
case SI_USER:
|
ret |= __xn_put_user(si->si_pid, &u_p->si_pid);
|
ret |= __xn_put_user(si->si_uid, &u_p->si_uid);
|
}
|
|
return ret;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_siginfo);
|
|
int sys32_get_msghdr(struct user_msghdr *msg,
|
const struct compat_msghdr __user *u_cmsg)
|
{
|
compat_uptr_t tmp1, tmp2, tmp3;
|
|
if (u_cmsg == NULL ||
|
!access_rok(u_cmsg, sizeof(*u_cmsg)) ||
|
__xn_get_user(tmp1, &u_cmsg->msg_name) ||
|
__xn_get_user(msg->msg_namelen, &u_cmsg->msg_namelen) ||
|
__xn_get_user(tmp2, &u_cmsg->msg_iov) ||
|
__xn_get_user(msg->msg_iovlen, &u_cmsg->msg_iovlen) ||
|
__xn_get_user(tmp3, &u_cmsg->msg_control) ||
|
__xn_get_user(msg->msg_controllen, &u_cmsg->msg_controllen) ||
|
__xn_get_user(msg->msg_flags, &u_cmsg->msg_flags))
|
return -EFAULT;
|
|
if (msg->msg_namelen > sizeof(struct sockaddr_storage))
|
msg->msg_namelen = sizeof(struct sockaddr_storage);
|
|
msg->msg_name = compat_ptr(tmp1);
|
msg->msg_iov = compat_ptr(tmp2);
|
msg->msg_control = compat_ptr(tmp3);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_msghdr);
|
|
int sys32_get_mmsghdr(struct mmsghdr *mmsg,
|
const struct compat_mmsghdr __user *u_cmmsg)
|
{
|
if (u_cmmsg == NULL ||
|
!access_rok(u_cmmsg, sizeof(*u_cmmsg)) ||
|
__xn_get_user(mmsg->msg_len, &u_cmmsg->msg_len))
|
return -EFAULT;
|
|
return sys32_get_msghdr(&mmsg->msg_hdr, &u_cmmsg->msg_hdr);
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_mmsghdr);
|
|
int sys32_put_msghdr(struct compat_msghdr __user *u_cmsg,
|
const struct user_msghdr *msg)
|
{
|
if (u_cmsg == NULL ||
|
!access_wok(u_cmsg, sizeof(*u_cmsg)) ||
|
__xn_put_user(ptr_to_compat(msg->msg_name), &u_cmsg->msg_name) ||
|
__xn_put_user(msg->msg_namelen, &u_cmsg->msg_namelen) ||
|
__xn_put_user(ptr_to_compat(msg->msg_iov), &u_cmsg->msg_iov) ||
|
__xn_put_user(msg->msg_iovlen, &u_cmsg->msg_iovlen) ||
|
__xn_put_user(ptr_to_compat(msg->msg_control), &u_cmsg->msg_control) ||
|
__xn_put_user(msg->msg_controllen, &u_cmsg->msg_controllen) ||
|
__xn_put_user(msg->msg_flags, &u_cmsg->msg_flags))
|
return -EFAULT;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_msghdr);
|
|
int sys32_put_mmsghdr(struct compat_mmsghdr __user *u_cmmsg,
|
const struct mmsghdr *mmsg)
|
{
|
if (u_cmmsg == NULL ||
|
!access_wok(u_cmmsg, sizeof(*u_cmmsg)) ||
|
__xn_put_user(mmsg->msg_len, &u_cmmsg->msg_len))
|
return -EFAULT;
|
|
return sys32_put_msghdr(&u_cmmsg->msg_hdr, &mmsg->msg_hdr);
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_mmsghdr);
|
|
int sys32_get_iovec(struct iovec *iov,
|
const struct compat_iovec __user *u_ciov,
|
int ciovlen)
|
{
|
const struct compat_iovec __user *p;
|
struct compat_iovec ciov;
|
int ret, n;
|
|
for (n = 0, p = u_ciov; n < ciovlen; n++, p++) {
|
ret = cobalt_copy_from_user(&ciov, p, sizeof(ciov));
|
if (ret)
|
return ret;
|
iov[n].iov_base = compat_ptr(ciov.iov_base);
|
iov[n].iov_len = ciov.iov_len;
|
}
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_get_iovec);
|
|
int sys32_put_iovec(struct compat_iovec __user *u_ciov,
|
const struct iovec *iov,
|
int iovlen)
|
{
|
struct compat_iovec __user *p;
|
struct compat_iovec ciov;
|
int ret, n;
|
|
for (n = 0, p = u_ciov; n < iovlen; n++, p++) {
|
ciov.iov_base = ptr_to_compat(iov[n].iov_base);
|
ciov.iov_len = iov[n].iov_len;
|
ret = cobalt_copy_to_user(p, &ciov, sizeof(*p));
|
if (ret)
|
return ret;
|
}
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sys32_put_iovec);
|
