sched/elf: Pave the way for creating new namespace

In order to create a new partial namespace a new instance
of elf::program is needed.

This patch keep elf::s_program for all running thread while
creating a way to add a new per application elf::program when
needed.

This idea was suggested by Glauber as an alternative to the
previous series which was somewhat intrusive.

This patch also introduces an application method that allows a new program to be
created for the calling thread. The new program is created at a different slice
of the address space. This effectively imposes a lower amount of memory each
program can use. But the limit is still big enough, and should be enough for
anybody (tm).

Signed-off-by: Benoît Canet <[email protected]>
Signed-off-by: Glauber Costa <[email protected]>
Signed-off-by: Nadav Har'El <[email protected]>

Author: Benoît Canet

core/app.cc

@@ -355,6 +355,36 @@ std::string application::get_command()
     return _command;
 }
 
+// For simplicity, we will not reuse bits in the bitmap, since no destructor is
+// assigned to the program. In that case, a simple counter would do. But coding
+// this way is easy, and make this future extension simple.
+constexpr int max_namespaces = 32;
+std::bitset<max_namespaces> namespaces(1);
+
+void application::new_program()
+{
+    unsigned long i = 0;
+
+    for (i = 0; i < max_namespaces; ++i) {
+        if (!namespaces.test(i)) {
+            namespaces.set(i);
+            break;
+        }
+    }
+
+    if (i == max_namespaces) {
+        return;
+    }
+
+    void *addr = reinterpret_cast<void *>(elf::program_base) + ((i + 1) << 33);
+    _program.reset(new elf::program(addr));
+}
+
+elf::program *application::program() {
+    return _program.get();
+}
+
+
 namespace this_application {
 
 void on_termination_request(std::function<void()> callback)

core/elf.cc

@@ -6,6 +6,7 @@
  */
 
 #include <osv/elf.hh>
+#include <osv/app.hh>
 #include <osv/mmu.hh>
 #include <boost/format.hpp>
 #include <exception>
@@ -1017,14 +1018,19 @@ void object::init_static_tls()
 
 program* s_program;
 
+void create_main_program()
+{
+    assert(!s_program);
+    s_program = new elf::program();
+}
+
 program::program(void* addr)
     : _next_alloc(addr)
 {
-    assert(!s_program);
-    s_program = this;
     _core = make_shared<memory_image>(*this, (void*)ELF_IMAGE_START);
     assert(_core->module_index() == core_module_index);
     _core->load_segments();
+    set_search_path({"/", "/usr/lib"});
     // Our kernel already supplies the features of a bunch of traditional
     // shared libraries:
     static const auto supplied_modules = {
@@ -1310,6 +1316,12 @@ object *program::object_containing_addr(const void *addr)
 
 program* get_program()
 {
+    auto app = osv::application::get_current();
+
+    if (app && app->program()) {
+        return app->program();
+    }
+
     return s_program;
 }
 

include/osv/app.hh

@@ -145,7 +145,10 @@ public:
 
     std::shared_ptr<application_runtime> runtime() const { return _runtime; }
     std::shared_ptr<elf::object> lib() const { return _lib; }
+
+    elf::program *program();
 private:
+    void new_program();
     shared_app_t get_shared() {
         return shared_from_this();
     }
@@ -160,6 +163,7 @@ private:
     using main_func_t = int(int, char**);
 
     pthread_t _thread;
+    std::unique_ptr<elf::program> _program; // namespace program
     std::vector<std::string> _args;
     std::string _command;
     int _return_code;

include/osv/elf.hh

@@ -596,8 +596,10 @@ private:
     friend class object;
 };
 
+void create_main_program();
+
 /**
- * Get the single elf::program instance
+ * Get the current elf::program instance
  */
 program* get_program();
 

loader.cc

@@ -528,8 +528,8 @@ void main_cont(int ac, char** av)
 
     debug("Firmware vendor: %s\n", osv::firmware_vendor().c_str());
 
-    new elf::program();
-    elf::get_program()->set_search_path({"/", "/usr/lib"});
+    elf::create_main_program();
+
     std::vector<std::vector<std::string> > cmds;
 
     std::tie(ac, av) = parse_options(ac, av);