/*
 * Copyright (C) 2005 Philippe Gerum <rpm@xenomai.org>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <getopt.h>
#include <limits.h>
#include <unistd.h>
#include <stdint.h>
#include <semaphore.h>
#include <boilerplate/setup.h>
#include <cobalt/uapi/kernel/heap.h>
#include <cobalt/ticks.h>
#include <cobalt/tunables.h>
#include <asm/xenomai/syscall.h>
#include <xenomai/init.h>
#include "umm.h"
#include "internal.h"

/**
 * @ingroup cobalt
 * @defgroup cobalt_api POSIX interface
 * @anchor cobalt_api
 *
 * The Cobalt/POSIX interface is an implementation of a subset of the
 * <a href="http://www.opengroup.org/onlinepubs/000095399/functions/">
 * Single Unix specification</a> over the Cobalt core.
 *
 * The routines from this subset are implemented as wrapper functions
 * as defined by the linker (--wrap option, see man ld(1)).  The
 * linker flags for enabling symbol wrapping can be obtained from the
 * following command: *xeno-config --posix --ldflags*.
 * The full documentation for *xeno-config* can be found at
 * https://xenomai.org/documentation/xenomai-3/html/man1/xeno-config/index.html.
 *
 * When symbol wrapping is enabled:
 *
 *   - calls to POSIX services for which Cobalt provides a (real-time)
 * implementation are redirected to the library implementing the
 * wrapper, by default libcobalt. A list of wrapped symbols libcobalt
 * overrides can be found in the source tree, in
 * lib/cobalt/cobalt.wrappers.
 *
 * With or without symbol wrapping:
 *
 *   - the wrapper function of a POSIX routine can be explicitly
 * invoked by enclosing the function call with the __RT() macro. Since
 * the wrapper symbol is weak, it may be overriden by a 3rd party
 * library, typically to implement its own version of the POSIX call,
 * instead or on top of libcobalt's. e.g. __RT(sem_init(&sem, 0, 0))
 * would initialize a real-time semaphore, usually from libcobalt
 * unless a stronger sem_init() wrapper has been provided by a 3rd
 * party library.
 *
 *   - the libcobalt implementation of a POSIX routine can be
 * explicitly invoked by enclosing the function call with the
 * __COBALT() macro.  e.g. __COBALT(sem_init(&sem, 0, 0)) would always
 * initialize a Cobalt semaphore (strong symbol).
 *
 *   - the regular *libc implementation of a POSIX routine can be
 * explicitly invoked by enclosing the function call with the __STD()
 * macro. This form basically prevents the symbol wrapping to take
 * place. e.g.  __STD(sem_init(&sem, 0, 0)) would always initialize a
 * regular *libc semaphore. This is strictly equivalent to calling the
 * __real_* form of such routine as documented for ld(1).
 *
 * Qualifying POSIX calls explicitly as described above may prove
 * useful for invoking real-time services selectively within a large
 * POSIX code base, for which globally enabling symbol wrapping would
 * be unpractical. This may also help in implementing real-time
 * service libraries for which depending on the linker's symbol
 * wrapping mechanism is not suitable.
 *
 * This said, conforming to the POSIX standard unspoiled by macro
 * tricks for developing an application may be a significant upside as
 * well. YMMV.
 */

__weak int __cobalt_control_bind = 0;

int __cobalt_main_prio = -1;

struct sigaction __cobalt_orig_sigdebug;

static const struct option cobalt_options[] = {
	{
#define main_prio_opt		0
		.name = "main-prio",
		.has_arg = required_argument,
	},
	{
#define print_bufsz_opt	1
		.name = "print-buffer-size",
		.has_arg = required_argument,
	},
	{
#define print_bufcnt_opt	2
		.name = "print-buffer-count",
		.has_arg = required_argument,
	},
	{
#define print_syncdelay_opt	3
		.name = "print-sync-delay",
		.has_arg = required_argument,
	},
	{ /* Sentinel */ }
};

static void sigill_handler(int sig)
{
	const char m[] = "no Xenomai/cobalt support in kernel?\n";
	ssize_t rc __attribute__ ((unused));
	rc = write(2, m, sizeof(m) - 1);
	exit(EXIT_FAILURE);
}

static void low_init(void)
{
	sighandler_t old_sigill_handler;
	struct cobalt_bindreq breq;
	struct cobalt_featinfo *f;
	int ret;

	old_sigill_handler = signal(SIGILL, sigill_handler);
	if (old_sigill_handler == SIG_ERR)
		early_panic("signal(SIGILL): %s", strerror(errno));

	f = &breq.feat_ret;
	breq.feat_req = XENOMAI_FEAT_DEP;
	if (__cobalt_control_bind)
		breq.feat_req |= __xn_feat_control;
	breq.abi_rev = XENOMAI_ABI_REV;
	ret = XENOMAI_SYSBIND(&breq);

	signal(SIGILL, old_sigill_handler);

	switch (ret) {
	case 0:
		break;
	case -EINVAL:
		early_panic("missing feature: %s", f->feat_mis_s);
	case -ENOEXEC:
		early_panic("ABI mismatch: required r%lu, provided r%lu",
			    XENOMAI_ABI_REV, f->feat_abirev);
	case -EAGAIN:
		early_panic("Cobalt core present but stopped "
			    "(use corectl --start)");
	case -ENOSYS:
		early_panic("Cobalt core not enabled in kernel");
	default:
		early_panic("binding failed: %s", strerror(-ret));
	}

	trace_me("connected to Cobalt");

	if (mlockall(MCL_CURRENT | MCL_FUTURE))
		early_panic("mlockall: %s", strerror(errno));

	trace_me("memory locked");
	cobalt_ticks_init(f->clock_freq);
	cobalt_features_init(f);
	cobalt_init_umm(f->vdso_offset);
	trace_me("memory heaps mapped");
	cobalt_init_current_keys();
}

static int cobalt_init_2(void);

static void cobalt_fork_handler(void)
{
	cobalt_unmap_umm();
	cobalt_clear_tsd();
	cobalt_print_init_atfork();
	if (cobalt_init_2())
		exit(EXIT_FAILURE);
}

static inline void commit_stack_memory(void)
{
	char stk[PTHREAD_STACK_MIN / 2];
	cobalt_commit_memory(stk);
}

static void cobalt_init_1(void)
{
	struct sigaction sa;

	sa.sa_sigaction = cobalt_sigdebug_handler;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_SIGINFO;
	sigaction(SIGDEBUG, &sa, &__cobalt_orig_sigdebug);

	/*
	 * NOTE: a placeholder for pthread_atfork() may return an
	 * error status with uClibc, so we don't check the return
	 * value on purpose.
	 */
	pthread_atfork(NULL, NULL, cobalt_fork_handler);

	if (sizeof(struct cobalt_mutex_shadow) > sizeof(pthread_mutex_t))
		early_panic("sizeof(pthread_mutex_t): %Zd <"
			    " sizeof(cobalt_mutex_shadow): %Zd!",
			    sizeof(pthread_mutex_t),
			    sizeof(struct cobalt_mutex_shadow));

	if (sizeof(struct cobalt_cond_shadow) > sizeof(pthread_cond_t))
		early_panic("sizeof(pthread_cond_t): %Zd <"
			    " sizeof(cobalt_cond_shadow): %Zd!",
			    sizeof(pthread_cond_t),
			    sizeof(struct cobalt_cond_shadow));

	if (sizeof(struct cobalt_sem_shadow) > sizeof(sem_t))
		early_panic("sizeof(sem_t): %Zd <"
			    " sizeof(cobalt_sem_shadow): %Zd!",
			    sizeof(sem_t),
			    sizeof(struct cobalt_sem_shadow));
}

static int cobalt_init_2(void)
{
	pthread_t ptid = pthread_self();
	struct sched_param parm;
	int policy, ret;

	commit_stack_memory();	/* We only need this for the main thread */
	cobalt_default_condattr_init();

	low_init();
	cobalt_mutex_init();
	cobalt_sched_init();
	cobalt_thread_init();
	cobalt_print_init();

	if (__cobalt_control_bind)
		return 0;

	ret = __STD(pthread_getschedparam(ptid, &policy, &parm));
	if (ret) {
		early_warning("pthread_getschedparam failed");
		return -ret;
	}

	/*
	 * Turn the main thread into a Cobalt thread.
	 * __cobalt_main_prio might have been overriden by some
	 * compilation unit which has been linked in, to force the
	 * scheduling parameters. Otherwise, the current policy and
	 * priority are reused, for declaring the thread to the
	 * Cobalt scheduler.
	 *
	 * SCHED_FIFO is assumed for __cobalt_main_prio > 0.
	 */
	if (__cobalt_main_prio > 0) {
		policy = SCHED_FIFO;
		parm.sched_priority = __cobalt_main_prio;
	} else if (__cobalt_main_prio == 0) {
		policy = SCHED_OTHER;
		parm.sched_priority = 0;
	}

	ret = __RT(pthread_setschedparam(ptid, policy, &parm));
	if (ret) {
		early_warning("pthread_setschedparam failed { policy=%d, prio=%d }",
			      policy, parm.sched_priority);
		return -ret;
	}

	return 0;
}

int cobalt_init(void)
{
	cobalt_init_1();

	return cobalt_init_2();
}

static int get_int_arg(const char *name, const char *arg,
		       int *valp, int min)
{
	int value, ret;
	char *p;

	errno = 0;
	value = (int)strtol(arg, &p, 10);
	if (errno || *p || value < min) {
		ret = -errno ?: -EINVAL;
		early_warning("invalid value for %s: %s", name, arg);
		return ret;
	}

	*valp = value;

	return 0;
}

static int cobalt_parse_option(int optnum, const char *optarg)
{
	int value, ret;

	switch (optnum) {
	case main_prio_opt:
		ret = get_int_arg("--main-prio", optarg, &value, INT32_MIN);
		if (ret)
			return ret;
		__cobalt_main_prio = value;
		break;
	case print_bufsz_opt:
		ret = get_int_arg("--print-buffer-size", optarg, &value, 0);
		if (ret)
			return ret;
		__cobalt_print_bufsz = value;
		break;
	case print_bufcnt_opt:
		ret = get_int_arg("--print-buffer-count", optarg, &value, 0);
		if (ret)
			return ret;
		__cobalt_print_bufcount = value;
		break;
	case print_syncdelay_opt:
		ret = get_int_arg("--print-sync-delay", optarg, &value, 0);
		if (ret)
			return ret;
		__cobalt_print_syncdelay = value;
		break;
	default:
		/* Paranoid, can't happen. */
		return -EINVAL;
	}

	return 0;
}

static void cobalt_help(void)
{
	fprintf(stderr, "--main-prio=<prio>		main thread priority\n");
	fprintf(stderr, "--print-buffer-size=<bytes>	size of a print relay buffer (16k)\n");
	fprintf(stderr, "--print-buffer-count=<num>	number of print relay buffers (4)\n");
	fprintf(stderr, "--print-sync-delay=<ms>	max delay of output synchronization (100 ms)\n");
}

static struct setup_descriptor cobalt_interface = {
	.name = "cobalt",
	.init = cobalt_init,
	.options = cobalt_options,
	.parse_option = cobalt_parse_option,
	.help = cobalt_help,
};

core_setup_call(cobalt_interface);