Enhance getopt family of functions to work with PIEs

This patch enhances implementation of getopt() and
getopt_long() functions to work with PIEs.

Newer GCC compiler optimizes PIEs by emitting machine code
with so called copy relocations and affects how
caller (PIEs) and callee (OSv kernel) see same logical
global variables like optarg.

New implementation of getopt() and getopt_long()
detects if caller uses its (other) copies of global
variables like optind and copies its value
to the kernel copy. Likewise on return from
the getopt() function it copies values of all "output" global
variables from kernel to the equivalent caller copies of
those variables.

Fixes #689

Signed-off-by: Waldemar Kozaczuk <[email protected]>
Message-Id: <[email protected]>

Author: wkozaczuk

core/elf.cc

@@ -147,6 +147,19 @@ void* object::lookup(const char* symbol)
     return sm.relocated_addr();
 }
 
+void* object::cached_lookup(const std::string& name)
+{
+    auto cached_address_it = _cached_symbols.find(name);
+    if (cached_address_it != _cached_symbols.end()) {
+        return cached_address_it->second;
+    }
+    else {
+        void *symbol_address = lookup(name.c_str());
+        _cached_symbols[name] = symbol_address;
+        return symbol_address;
+    }
+}
+
 std::vector<Elf64_Shdr> object::sections()
 {
     size_t bytes = size_t(_ehdr.e_shentsize) * _ehdr.e_shnum;

include/osv/elf.hh

@@ -14,6 +14,7 @@
 #include <stack>
 #include <memory>
 #include <unordered_set>
+#include <unordered_map>
 #include <osv/types.h>
 #include <atomic>
 
@@ -349,6 +350,7 @@ public:
     void run_fini_funcs();
     template <typename T = void>
     T* lookup(const char* name);
+    void* cached_lookup(const std::string& name);
     dladdr_info lookup_addr(const void* addr);
     bool contains_addr(const void* addr);
     ulong module_index() const;
@@ -415,6 +417,8 @@ protected:
     bool _is_executable;
     bool is_core();
 
+    std::unordered_map<std::string,void*> _cached_symbols;
+
     // Keep list of references to other modules, to prevent them from being
     // unloaded. When this object is unloaded, the reference count of all
     // objects listed here goes down, and they too may be unloaded.

libc/misc/getopt.cc

@@ -4,6 +4,7 @@
 #include <limits.h>
 #include <stdlib.h>
 #include <libc/libc.hh>
+#include "getopt.hh"
 
 extern "C" {
 
@@ -13,7 +14,7 @@ int optind=1, opterr=1, optopt, __optpos, __optreset=0;
 #define optpos __optpos
 weak_alias(__optreset, optreset);
 
-int getopt(int argc, char * const argv[], const char *optstring)
+int __getopt(int argc, char * const argv[], const char *optstring)
 {
 	int i;
 	wchar_t c, d;
@@ -73,5 +74,11 @@ int getopt(int argc, char * const argv[], const char *optstring)
 	return c;
 }
 
+int getopt(int argc, char * const argv[], const char *optstring)
+{
+	getopt_caller_vars_copier guard;
+	return __getopt(argc, argv, optstring);
+}
+
 weak_alias(getopt, __posix_getopt);
 }

libc/misc/getopt.hh

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 Waldemar Kozaczuk
+ *
+ * This work is open source software, licensed under the terms of the
+ * BSD license as described in the LICENSE file in the top-level directory.
+ */
+
+#ifndef GETOPT_HH_
+#define GETOPT_HH_
+
+#include <osv/app.hh>
+
+// As explained in http://www.shrubbery.net/solaris9ab/SUNWdev/LLM/p22.html#CHAPTER4-84604
+// newer versions of gcc produce position independent executables with copies of
+// some global variables like those used by getopt() and getopt_long() for optimizations reason.
+// In those circumstances the caller of these functions uses different copies of
+// global variables (like optind) than the getopt() code that is part of OSv kernel.
+// For that reason in the beginning of these functions we need to copy values of the caller
+// copies of those variables to the kernel placeholders. Likewise on every return from the function
+// we need to copy the values of kernel copies of global variables to the caller ones.
+//
+// See http://man7.org/linux/man-pages/man3/getopt.3.html
+//
+// This is a simple RAII class for retrieving the caller's copy of the global opt* variables
+// on initialization, and returning them back to the caller on destruction.
+class getopt_caller_vars_copier {
+    std::shared_ptr<osv::application_runtime> _runtime;
+    int *other_optind;
+
+public:
+    getopt_caller_vars_copier() : _runtime(sched::thread::current()->app_runtime()) {
+        if (_runtime) {
+            auto obj = _runtime->app.lib();
+            other_optind = reinterpret_cast<int*>(obj->cached_lookup("optind"));
+            if (other_optind) {
+                optind = *other_optind;
+            }
+
+            auto other_opterr = reinterpret_cast<int*>(obj->cached_lookup("opterr"));
+            if (other_opterr) {
+                opterr = *other_opterr;
+            }
+        }
+    }
+
+    ~getopt_caller_vars_copier() {
+        if (_runtime) {
+            auto obj = _runtime->app.lib();
+            if (other_optind) {
+                *other_optind = optind;
+            }
+            auto other_optopt = reinterpret_cast<int*>(obj->cached_lookup("optopt"));
+            if (other_optopt) {
+                *other_optopt = optopt;
+            }
+            auto other_optarg = reinterpret_cast<char**>(obj->cached_lookup("optarg"));
+            if (other_optarg) {
+                *other_optarg = optarg;
+            }
+        }
+    }
+};
+
+extern "C" int __getopt(int argc, char * const argv[], const char *optstring);
+
+#endif

libc/misc/getopt_long.cc

@@ -1,13 +1,16 @@
 #include <stddef.h>
 #include <getopt.h>
 #include <stdio.h>
+#include "getopt.hh"
 
 extern "C" {
 
 extern int __optpos, __optreset;
 
 static int __getopt_long(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx, int longonly)
 {
+	getopt_caller_vars_copier guard;
+
 	if (!optind || __optreset) {
 		__optreset = 0;
 		__optpos = 0;
@@ -46,7 +49,7 @@ static int __getopt_long(int argc, char *const *argv, const char *optstring, con
 			return '?';
 		}
 	}
-	return getopt(argc, argv, optstring);
+	return __getopt(argc, argv, optstring);
 }
 
 int getopt_long(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx)

modules/tests/Makefile

@@ -62,6 +62,13 @@ $(out)/%.so: $(out)/%.o
 
 $(out)/tests/tst-non-fpic.o: CXXFLAGS:=$(subst -fPIC,-mcmodel=large,$(CXXFLAGS))
 
+$(out)/tests/tst-getopt-pie.o: CXXFLAGS:=$(subst -fPIC,-fpie,$(CXXFLAGS))
+$(out)/tests/tst-getopt-pie.o: $(src)/tests/tst-getopt.cc
+	$(makedir)
+	$(call quiet, $(CXX) $(CXXFLAGS) -c -o $@ $<, CXX $*.cc)
+$(out)/tests/tst-getopt-pie.so: $(out)/tests/tst-getopt-pie.o
+	$(call quiet, $(CXX) $(CXXFLAGS) -pie -o $@ $< $(LIBS), LD $*.so)
+
 # The rofs test image mounts /tmp as ramfs and 4 tests that exercise file system
 # fail due to some unresolved bugs or other shortcomings of the ramfs implementation
 # and are temporarily removed from the rofs-only-tests list. The tests tst-readdir.so
@@ -117,7 +124,7 @@ tests := tst-pthread.so misc-ramdisk.so tst-vblk.so tst-bsd-evh.so \
 	tst-ttyname.so tst-pthread-barrier.so tst-feexcept.so tst-math.so \
 	tst-sigaltstack.so tst-fread.so tst-tcp-cork.so tst-tcp-v6.so \
 	tst-calloc.so tst-crypt.so tst-non-fpic.so tst-small-malloc.so \
-	tst-mmx-fpu.so
+	tst-mmx-fpu.so tst-getopt.so tst-getopt-pie.so
 #	libstatic-thread-variable.so tst-static-thread-variable.so \
 
 tests += testrunner.so