l4/pkg/l4re-core/l4re_kernel/server/src/main.cc

   1 /*
   2  * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
   3  *               Alexander Warg <warg@os.inf.tu-dresden.de>
   4  *     economic rights: Technische Universität Dresden (Germany)
   5  *
   6  * This file is part of TUD:OS and distributed under the terms of the
   7  * GNU General Public License 2.
   8  * Please see the COPYING-GPL-2 file for details.
   9  */
  10 #include <l4/re/namespace>
  11 #include <l4/re/dataspace>
  12 #include <l4/re/mem_alloc>
  13 #include <l4/re/rm>
  14 #include <l4/re/log>
  15 #include <l4/re/env>
  16 #include <l4/re/error_helper>
  17 #include <l4/re/util/env_ns>
  18
  19 #include <l4/cxx/exceptions>
  20 #include <l4/cxx/iostream>
  21 #include <l4/cxx/l4iostream>
  22 #include <l4/sys/debugger.h>
  23 #include <l4/sys/scheduler>
  24 #include <l4/sys/thread>
  25 #include <l4/sys/cxx/ipc_server_loop>
  26
  27 #include <cstdlib>
  28 #include <cstring>
  29 #include <cassert>
  30
  31 #include "region.h"
  32 #include "globals.h"
  33 #include "loader_elf.h"
  34 #include "debug.h"
  35 #include "dispatcher.h"
  36
  37 #include <l4/re/elf_aux.h>
  38
  39 extern char const __executable_start[];
  40 L4RE_ELF_AUX_ELEM_T(l4re_elf_aux_mword_t, __stack_addr,
  41                     L4RE_ELF_AUX_T_STACK_ADDR,
  42                     (l4_addr_t)__executable_start + 0x1000000);
  43
  44 using L4::Cap;
  45 using L4Re::Dataspace;
  46
  47 extern "C" int main(int argc, char const *argv[],
  48                     char const *env[]);
  49
  50 static Elf_loader loader;
  51 L4::Cap<void> rcv_cap;
  52
  53 class Loop_hooks :
  54   public L4::Ipc_svr::Ignore_errors,
  55   public L4::Ipc_svr::Default_timeout,
  56   public L4::Ipc_svr::Compound_reply
  57 {
  58 public:
  59   static void setup_wait(l4_utcb_t *utcb, bool)
  60   {
  61     l4_utcb_br_u(utcb)->br[0] = L4::Ipc::Small_buf(rcv_cap.cap(),
  62                                                    L4_RCV_ITEM_LOCAL_ID).raw();
  63     l4_utcb_br_u(utcb)->br[1] = 0;
  64     l4_utcb_br_u(utcb)->bdr = 0;
  65   }
  66 };
  67
  68 extern "C" void *__libc_alloc_initial_tls(unsigned long size);
  69
  70 void *__libc_alloc_initial_tls(unsigned long)
  71 {
  72   // __libc_alloc_initial_tls must not be called here, this is just
  73   // a safety measure
  74   assert(0);
  75 }
  76
  77 static L4::Server<Loop_hooks> server(l4_utcb());
  78
  79 static void insert_regions()
  80 {
  81   using L4Re::Rm;
  82   using L4Re::Env;
  83   int n;
  84   l4_addr_t addr = 0;
  85   Rm::Region const *rl;
  86   while ((n = L4Re::Env::env()->rm()->get_regions(addr, &rl)) > 0)
  87     {
  88       for (int i = 0; i < n; ++i)
  89         {
  90           Rm::Region const *r = &rl[i];
  91           auto pager = L4::cap_reinterpret_cast<L4Re::Dataspace>(Env::env()->rm());
  92           void *x = Global::local_rm
  93             ->attach((void*)r->start, r->end - r->start +1,
  94                      Region_handler(pager, L4_INVALID_CAP, 0, Rm::Pager), 0);
  95           if (!x)
  96             {
  97               L4::cerr << "l4re: error while initializing region mapper\n";
  98               exit(1);
  99             }
 100
 101           addr = r->end + 1;
 102         }
 103
 104     }
 105
 106   Rm::Area const *al;
 107   while ((n = L4Re::Env::env()->rm()->get_areas(addr, &al)) > 0)
 108     {
 109       for (int i = 0; i < n; ++i)
 110         {
 111           Rm::Area const *r = &al[i];
 112           l4_addr_t x
 113             = Global::local_rm->attach_area(r->start, r->end - r->start + 1);
 114           if (!x)
 115             {
 116               L4::cerr << "l4re: error while initializing region mapper\n";
 117               exit(1);
 118             }
 119
 120           addr = r->end + 1;
 121         }
 122     }
 123 }
 124
 125 static int run(int argc, char const *argv[], char const *envp[])
 126 {
 127   Dbg::set_level(Dbg::Info | Dbg::Warn);
 128
 129   Dbg boot(Dbg::Boot);
 130
 131   Global::argc = argc;
 132   Global::argv = argv;
 133
 134   if (0)
 135     {
 136       L4::cout << "ARGC=" << argc << "\n"
 137                << "ARGV=" << argv << "\n"
 138                << "ENVP=" << envp << "\n";
 139
 140       for (int i = 0; i < argc; ++i)
 141         L4::cout << "  arg: '" << argv[i] << "'\n";
 142
 143       for (char const *const *e = Global::envp; *e; ++e)
 144         L4::cout << "  env: '" << *e << "'\n";
 145     }
 146
 147   L4Re::Env *const env = const_cast<L4Re::Env*>(L4Re::Env::env());
 148
 149   if (0)
 150       L4::cout << "AUX=" << Global::l4re_aux << "\n"
 151                << "ENV=" << env << "\n"
 152                << "Binary: " << Global::l4re_aux->binary << " " << env << "\n";
 153
 154   if (!env || !Global::l4re_aux)
 155     {
 156       Err(Err::Fatal).printf("invalid AUX vectors...\n");
 157       exit(1);
 158     }
 159
 160     {
 161       char s[15];
 162       char *t = strstr(Global::l4re_aux->binary, "rom/");
 163       s[0] = '#';
 164       strncpy(s + 1, t ? t + 4 : Global::l4re_aux->binary, sizeof(s)-1);
 165       s[sizeof(s)-1] = 0;
 166       l4_debugger_set_object_name(L4_BASE_THREAD_CAP, s);
 167       l4_debugger_set_object_name(L4_BASE_TASK_CAP, s + 1);
 168     }
 169
 170   Dbg::set_level(Global::l4re_aux->dbg_lvl);
 171   rcv_cap = Global::cap_alloc->alloc<void>();
 172   boot.printf("adding regions from remote region mapper\n");
 173   insert_regions();
 174
 175   L4::Cap<Dataspace> file;
 176
 177   boot.printf("load binary '%s'\n", Global::l4re_aux->binary);
 178
 179   file = L4Re_app_model::open_file(Global::l4re_aux->binary);
 180
 181   loader.start(file, Global::local_rm, Global::l4re_aux);
 182
 183   // Raise RM prio to its MCP
 184   env->scheduler()->run_thread(env->main_thread(),
 185                                l4_sched_param(L4_SCHED_MAX_PRIO));
 186
 187   boot.printf("Start server loop\n");
 188   server.loop<L4::Runtime_error>(Dispatcher());
 189 }
 190
 191 int main(int argc, char const *argv[], char const *envp[])
 192 {
 193   try
 194     {
 195       return run(argc, argv, envp);
 196     }
 197   catch (L4::Runtime_error const &e)
 198     {
 199       Err(Err::Fatal).printf("Exception %s: '%s'\n", e.str(), e.extra_str());
 200       L4::cerr << e;
 201       return 1;
 202     }
 203   catch (L4::Base_exception const &e)
 204     {
 205       Err(Err::Fatal).printf("Exception %s\n", e.str());
 206       L4::cerr << e;
 207       return 1;
 208     }
 209
 210   return 0;
 211 }