/*
|
* Copyright (C) 2016 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/types.h>
|
#include <linux/errno.h>
|
#include <linux/kconfig.h>
|
#include <linux/atomic.h>
|
#include <linux/printk.h>
|
#include <cobalt/kernel/init.h>
|
#include <cobalt/kernel/thread.h>
|
#include <xenomai/version.h>
|
#include <pipeline/tick.h>
|
#include <asm/xenomai/syscall.h>
|
#include "corectl.h"
|
|
static BLOCKING_NOTIFIER_HEAD(config_notifier_list);
|
|
static int do_conf_option(int option, void __user *u_buf, size_t u_bufsz)
|
{
|
struct cobalt_config_vector vec;
|
int ret, val = 0;
|
|
if (option <= _CC_COBALT_GET_CORE_STATUS && u_bufsz < sizeof(val))
|
return -EINVAL;
|
|
switch (option) {
|
case _CC_COBALT_GET_VERSION:
|
val = XENO_VERSION_CODE;
|
break;
|
case _CC_COBALT_GET_NR_PIPES:
|
#ifdef CONFIG_XENO_OPT_PIPE
|
val = CONFIG_XENO_OPT_PIPE_NRDEV;
|
#endif
|
break;
|
case _CC_COBALT_GET_NR_TIMERS:
|
val = CONFIG_XENO_OPT_NRTIMERS;
|
break;
|
case _CC_COBALT_GET_POLICIES:
|
val = _CC_COBALT_SCHED_FIFO|_CC_COBALT_SCHED_RR;
|
if (IS_ENABLED(CONFIG_XENO_OPT_SCHED_WEAK))
|
val |= _CC_COBALT_SCHED_WEAK;
|
if (IS_ENABLED(CONFIG_XENO_OPT_SCHED_SPORADIC))
|
val |= _CC_COBALT_SCHED_SPORADIC;
|
if (IS_ENABLED(CONFIG_XENO_OPT_SCHED_QUOTA))
|
val |= _CC_COBALT_SCHED_QUOTA;
|
if (IS_ENABLED(CONFIG_XENO_OPT_SCHED_TP))
|
val |= _CC_COBALT_SCHED_TP;
|
break;
|
case _CC_COBALT_GET_DEBUG:
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_COBALT))
|
val |= _CC_COBALT_DEBUG_ASSERT;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_CONTEXT))
|
val |= _CC_COBALT_DEBUG_CONTEXT;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_LOCKING))
|
val |= _CC_COBALT_DEBUG_LOCKING;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_USER))
|
val |= _CC_COBALT_DEBUG_USER;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_MUTEX_RELAXED))
|
val |= _CC_COBALT_DEBUG_MUTEX_RELAXED;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_MUTEX_SLEEP))
|
val |= _CC_COBALT_DEBUG_MUTEX_SLEEP;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_LEGACY))
|
val |= _CC_COBALT_DEBUG_LEGACY;
|
if (IS_ENABLED(CONFIG_XENO_OPT_DEBUG_TRACE_RELAX))
|
val |= _CC_COBALT_DEBUG_TRACE_RELAX;
|
if (IS_ENABLED(CONFIG_XENO_DRIVERS_RTNET_CHECKED))
|
val |= _CC_COBALT_DEBUG_NET;
|
break;
|
case _CC_COBALT_GET_WATCHDOG:
|
#ifdef CONFIG_XENO_OPT_WATCHDOG
|
val = CONFIG_XENO_OPT_WATCHDOG_TIMEOUT;
|
#endif
|
break;
|
case _CC_COBALT_GET_CORE_STATUS:
|
val = realtime_core_state();
|
break;
|
default:
|
if (is_primary_domain())
|
/* Switch to secondary mode first. */
|
return -ENOSYS;
|
vec.u_buf = u_buf;
|
vec.u_bufsz = u_bufsz;
|
ret = blocking_notifier_call_chain(&config_notifier_list,
|
option, &vec);
|
if (ret == NOTIFY_DONE)
|
return -EINVAL; /* Nobody cared. */
|
return notifier_to_errno(ret);
|
}
|
|
ret = cobalt_copy_to_user(u_buf, &val, sizeof(val));
|
|
return ret ? -EFAULT : 0;
|
}
|
|
static int stop_services(const void __user *u_buf, size_t u_bufsz)
|
{
|
const u32 final_grace_period = 3; /* seconds */
|
enum cobalt_run_states state;
|
__u32 grace_period;
|
int ret;
|
|
/*
|
* XXX: we don't have any syscall for unbinding a thread from
|
* the Cobalt core, so we deny real-time threads from stopping
|
* Cobalt services. i.e. _CC_COBALT_STOP_CORE must be issued
|
* from a plain regular linux thread.
|
*/
|
if (xnthread_current())
|
return -EPERM;
|
|
if (u_bufsz != sizeof(__u32))
|
return -EINVAL;
|
|
ret = cobalt_copy_from_user(&grace_period,
|
u_buf, sizeof(grace_period));
|
if (ret)
|
return ret;
|
|
state = atomic_cmpxchg(&cobalt_runstate,
|
COBALT_STATE_RUNNING,
|
COBALT_STATE_TEARDOWN);
|
switch (state) {
|
case COBALT_STATE_STOPPED:
|
break;
|
case COBALT_STATE_RUNNING:
|
/* Kill user threads. */
|
ret = xnthread_killall(grace_period, XNUSER);
|
if (ret) {
|
set_realtime_core_state(state);
|
return ret;
|
}
|
cobalt_call_state_chain(COBALT_STATE_TEARDOWN);
|
/* Kill lingering RTDM tasks. */
|
ret = xnthread_killall(final_grace_period, 0);
|
if (ret == -EAGAIN)
|
printk(XENO_WARNING "some RTDM tasks won't stop");
|
pipeline_uninstall_tick_proxy();
|
set_realtime_core_state(COBALT_STATE_STOPPED);
|
printk(XENO_INFO "services stopped\n");
|
break;
|
default:
|
ret = -EINPROGRESS;
|
}
|
|
return ret;
|
}
|
|
static int start_services(void)
|
{
|
enum cobalt_run_states state;
|
int ret = 0;
|
|
state = atomic_cmpxchg(&cobalt_runstate,
|
COBALT_STATE_STOPPED,
|
COBALT_STATE_WARMUP);
|
switch (state) {
|
case COBALT_STATE_RUNNING:
|
break;
|
case COBALT_STATE_STOPPED:
|
pipeline_install_tick_proxy();
|
cobalt_call_state_chain(COBALT_STATE_WARMUP);
|
set_realtime_core_state(COBALT_STATE_RUNNING);
|
printk(XENO_INFO "services started\n");
|
break;
|
default:
|
ret = -EINPROGRESS;
|
}
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(corectl, probing,
|
(int request, void __user *u_buf, size_t u_bufsz))
|
{
|
int ret;
|
|
switch (request) {
|
case _CC_COBALT_STOP_CORE:
|
ret = stop_services(u_buf, u_bufsz);
|
break;
|
case _CC_COBALT_START_CORE:
|
ret = start_services();
|
break;
|
default:
|
ret = do_conf_option(request, u_buf, u_bufsz);
|
}
|
|
return ret;
|
}
|
|
void cobalt_add_config_chain(struct notifier_block *nb)
|
{
|
blocking_notifier_chain_register(&config_notifier_list, nb);
|
}
|
EXPORT_SYMBOL_GPL(cobalt_add_config_chain);
|
|
void cobalt_remove_config_chain(struct notifier_block *nb)
|
{
|
blocking_notifier_chain_unregister(&config_notifier_list, nb);
|
}
|
EXPORT_SYMBOL_GPL(cobalt_remove_config_chain);
|
