You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

336 lines
9.2 KiB

/**
* Native CPU entry code
*
* Copyright (C) 2013 Ludwig Knüpfer <ludwig.knuepfer@fu-berlin.de>
* 2017 Freie Universität Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*
* @ingroup arch
* @{
* @file
* @author Ludwig Knüpfer <ludwig.knuepfer@fu-berlin.de>
* @author Martine Lenders <m.lenders@fu-berlin.de>
* @}
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#include <dlfcn.h>
#else
#include <dlfcn.h>
#endif
#include <assert.h>
#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "kernel_init.h"
#include "cpu.h"
#include "irq.h"
#include "board_internal.h"
#include "native_internal.h"
#include "tty_uart.h"
typedef enum {
_STDIOTYPE_STDIO = 0, /**< leave intact */
_STDIOTYPE_NULL, /**< redirect to "/dev/null" */
_STDIOTYPE_FILE, /**< redirect to file */
} _stdiotype_t;
int _native_null_in_pipe[2];
int _native_null_out_file;
const char *_progname;
char **_native_argv;
pid_t _native_pid;
pid_t _native_id;
unsigned _native_rng_seed = 0;
int _native_rng_mode = 0;
const char *_native_unix_socket_path = NULL;
#ifdef MODULE_NETDEV_TAP
#include "netdev_tap_params.h"
netdev_tap_params_t netdev_tap_params[NETDEV_TAP_MAX];
#endif
static const char short_opts[] = ":hi:s:deEoc:";
static const struct option long_opts[] = {
{ "help", no_argument, NULL, 'h' },
{ "id", required_argument, NULL, 'i' },
{ "seed", required_argument, NULL, 's' },
{ "daemonize", no_argument, NULL, 'd' },
{ "stderr-pipe", no_argument, NULL, 'e' },
{ "stderr-noredirect", no_argument, NULL, 'E' },
{ "stdout-pipe", no_argument, NULL, 'o' },
{ "uart-tty", required_argument, NULL, 'c' },
{ NULL, 0, NULL, '\0' },
};
/**
* @brief initialize _native_null_in_pipe to allow for reading from stdin
*
* @param[in] stdiotype _STDIOTYPE_STDIO to to just initialize pipe, any other
* value to also redirect stdin to that pipe
*/
void _native_input(_stdiotype_t stdintype)
{
if (real_pipe(_native_null_in_pipe) == -1) {
err(EXIT_FAILURE, "_native_null_in(): pipe()");
}
if (stdintype == _STDIOTYPE_STDIO) {
return;
}
if (real_dup2(_native_null_in_pipe[0], STDIN_FILENO) == -1) {
err(EXIT_FAILURE, "_native_null_in: dup2(STDIN_FILENO)");
}
}
/**
* @brief set up output redirection
*
* @param[in] stdiotype The type of redirection
* @param[in] output Output file. May be either `STDOUT_FILENO` for stdout or
* `STDERR_FILENO` for stderr
*
* @return The new file descriptor of the redirection
* @return -1 if the file descriptor did not change from the standard one
*/
int _native_log_output(_stdiotype_t stdiotype, int output)
{
int outfile;
assert((output == STDERR_FILENO) || (output == STDOUT_FILENO));
switch (stdiotype) {
case _STDIOTYPE_STDIO:
return -1;
case _STDIOTYPE_NULL:
if ((outfile = real_open("/dev/null", O_WRONLY)) == -1) {
err(EXIT_FAILURE, "_native_log_output: open");
}
break;
case _STDIOTYPE_FILE: {
/* 20 should suffice for 64-bit PIDs ;-) */
char logname[sizeof("/tmp/riot.stderr.") + 20];
snprintf(logname, sizeof(logname), "/tmp/riot.std%s.%d",
(output == STDOUT_FILENO) ? "out": "err", _native_pid);
if ((outfile = real_creat(logname, 0666)) == -1) {
err(EXIT_FAILURE, "_native_log_output: open");
}
break;
}
default:
errx(EXIT_FAILURE, "_native_log_output: unknown log type");
break;
}
if (real_dup2(outfile, output) == -1) {
err(EXIT_FAILURE, "_native_log_output: dup2(output)");
}
return outfile;
}
void daemonize(void)
{
if ((_native_pid = real_fork()) == -1) {
err(EXIT_FAILURE, "daemonize: fork");
}
if (_native_pid > 0) {
real_printf("RIOT pid: %d\n", _native_pid);
real_exit(EXIT_SUCCESS);
}
else {
_native_pid = real_getpid();
/* detach from current working directory */
if (real_chdir("/") == -1) {
err(EXIT_FAILURE, "daemonize: chdir");
}
/* detach from process group */
if (real_setsid() == -1) {
err(EXIT_FAILURE, "daemonize: setsid");
}
/* set umask */
real_umask(0);
}
}
/**
* Remove any -d options from an argument vector.
*
* @param[in][out] argv an argument vector
*/
static void filter_daemonize_argv(char **argv)
{
int idx = 0;
for (char **narg = argv; *narg != NULL; narg++, idx++) {
if (strcmp("-d", narg[0]) == 0) {
char **xarg = narg;
do {
xarg[0] = xarg[1];
} while (*xarg++ != NULL);
if (optind > 1) {
/* adapt optind if changed */
optind--;
}
narg--; /* rescan current item to filter out double args */
}
}
}
void usage_exit(int status)
{
real_printf("usage: %s", _progname);
#if defined(MODULE_NETDEV_TAP)
for (int i = 0; i < NETDEV_TAP_MAX; i++) {
real_printf(" <tap interface %d>", i + 1);
}
#endif
real_printf(" [-i <id>] [-d] [-e|-E] [-o] [-c <tty>]\n");
real_printf(" help: %s -h\n\n", _progname);
real_printf("\nOptions:\n"
" -h, --help\n"
" print this help message\n"
" -i <id>, --id=<id>\n"
" specify instance id (set by config module)\n"
" -s <seed>, --seed=<seed>\n"
" specify srandom(3) seed (/dev/random is used instead of random(3) if\n"
" the option is omitted)\n"
" -d, --daemonize\n"
" daemonize native instance\n"
" -e, --stderr-pipe\n"
" redirect stderr to file\n"
" -E, --stderr-noredirect\n"
" do not redirect stderr (i.e. leave sterr unchanged despite\n"
" daemon/socket io)\n"
" -o, --stdout-pipe\n"
" redirect stdout to file (/tmp/riot.stdout.PID) when not attached\n"
" to socket\n"
" -c <tty>, --uart-tty=<tty>\n"
" specify TTY device for UART. This argument can be used multiple\n"
" times (up to UART_NUMOF)\n");
real_exit(status);
}
__attribute__((constructor)) static void startup(int argc, char **argv)
{
_native_init_syscalls();
_native_argv = argv;
_progname = argv[0];
_native_pid = real_getpid();
/* will possibly be overridden via option below: */
_native_id = _native_pid;
int c, opt_idx = 0, uart = 0;
bool dmn = false, force_stderr = false;
_stdiotype_t stderrtype = _STDIOTYPE_STDIO;
_stdiotype_t stdouttype = _STDIOTYPE_STDIO;
_stdiotype_t stdintype = _STDIOTYPE_STDIO;
while ((c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx)) >= 0) {
switch (c) {
case 0:
case 'h':
usage_exit(EXIT_SUCCESS);
case 'i':
_native_id = atol(optarg);
break;
case 's':
_native_rng_seed = atol(optarg);
_native_rng_mode = 1;
break;
case 'd':
dmn = true;
break;
case 'e':
if (force_stderr) {
/* -e and -E are mutually exclusive */
usage_exit(EXIT_FAILURE);
}
stderrtype = _STDIOTYPE_FILE;
break;
case 'E':
if (stderrtype == _STDIOTYPE_FILE) {
/* -e and -E are mutually exclusive */
usage_exit(EXIT_FAILURE);
}
force_stderr = true;
break;
case 'o':
stdouttype = _STDIOTYPE_FILE;
break;
case 'c':
tty_uart_setup(uart++, optarg);
break;
default:
usage_exit(EXIT_FAILURE);
}
}
#ifdef MODULE_NETDEV_TAP
for (int i = 0; i < NETDEV_TAP_MAX; i++) {
if (argv[optind + i] == NULL) {
/* no tap parameter left */
usage_exit(EXIT_FAILURE);
}
}
#endif
if (dmn) {
filter_daemonize_argv(_native_argv);
if (stderrtype == _STDIOTYPE_STDIO) {
stderrtype = _STDIOTYPE_NULL;
}
if (stdouttype == _STDIOTYPE_STDIO) {
stdouttype = _STDIOTYPE_NULL;
}
if (stdintype == _STDIOTYPE_STDIO) {
stdintype = _STDIOTYPE_NULL;
}
daemonize();
}
if (force_stderr) {
stderrtype = _STDIOTYPE_STDIO;
}
_native_log_output(stderrtype, STDERR_FILENO);
_native_null_out_file = _native_log_output(stdouttype, STDOUT_FILENO);
_native_input(stdintype);
native_cpu_init();
native_interrupt_init();
#ifdef MODULE_NETDEV_TAP
for (int i = 0; i < NETDEV_TAP_MAX; i++) {
netdev_tap_params[i].tap_name = &argv[optind + i];
}
#endif
board_init();
puts("RIOT native hardware initialization complete.\n");
irq_enable();
kernel_init();
}