[Sanitizers] Get link map on FreeBSD via documented API

[dim]

Summary

Instead of hand-crafting an offset into the structure returned by
dlopen(3) to get at the link map, use the documented API. This is
described in dlinfo(3): by calling it with RTLD_DI_LINKMAP, the
dynamic linker ensures the right address is returned.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

95

should be

void *__sanitizer_get_link_map_by_dlopen_handle(void* handle) {

clang-format it

[dim]

Cast return value to link_map to avoid call site errors.

[dim]

Formatting.

[krytarowski]

I will mirror it in NetBSD whatever will be decided here.

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

95

Should be

void *__sanitizer_get_link_map_by_dlopen_handle(void *handle) {

[MaskRay]

It will be nice to include in the description what systems were not supported by hard coding 560, if such information can be obtained relatively easily.

[dim]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

95

Eh, what do you mean? It's already that form?

[krytarowski]

systems were not supported by hard coding 560

In the NetBSD case this offset changes few times a year.

[emaste]

In D73990#1858086, @MaskRay wrote:

It will be nice to include in the description what systems were not supported by hard coding 560, if such information can be obtained relatively easily.

I don't quite understand this question; hard coding is definitely a hack and we should prefer the supported method for finding the information, if the system provides it.

[emaste]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

28–29

I don't think the comment is applicable now

[dim]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

28–29

Well, it is still informative in the sense that it tells you the handle parameter (which is apparently the return value from dlopen) does not directly point to the desired link map information

Would you rather delete the comment, or replace it with something else? If the latter, what? :)

[dim]

Btw, note that according to the Linux dlinfo() manpage, it also has RTLD_DI_LINKMAP as a documented way to get at the link map. Maybe we should generalize this in a follow-up review?

[krytarowski]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

96

Actually please add internal_dlinfo() alongside internal_pid() and others.

It's sufficient to redirect it for all supported OSs (Linux, FreeBSD, Solaris, NetBSD) to dlinfo() for now and stub /* unimplemented */ for others.

On NetBSD we need to use it indirectly and handle it later.

[dim]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

96

Hm, I don't see any internal_pid() anywhere, but there are quite a lot of internal_ functions in compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp. Is that the right location? It seems that these are all more like hand-rolled versions of known libc functions, not some sort of 'forwarders'.

[krytarowski]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

96

Right, I was thinking about internal_getpid(). We wrap other functions too like sysctl().

[dim]

• Rebase onto reformatted files.
• Add internal_dlinfo() for FreeBSD and NetBSD, with stubs for other platforms.
• Add GET_LINK_MAP_BY_DLOPEN_HANDLE() macro for NetBSD.

[krytarowski]

compiler-rt/lib/sanitizer_common/sanitizer_netbsd.cpp

269

So as we implemented it for NetBSD here. Please put it in the expected final form.

	​  DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
	​  return _REAL(dlinfo, handle, request, p);

[emaste]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

28–29

I would delete it - the macro name is pretty explicit about obtaining the link map from the dlopen handle :-)

[dim]

Add better NetBSD implementation of internal_dlinfo().

[dim]

Remove stray newline.

[dim]

Ping, can we get this committed then? :)

[plotfi]

This breaks in our downstream runtimes builds for armv7-none-linux-androideabi16. FYI

[dim]

In D73990#1868071, @plotfi wrote:

This breaks in our downstream runtimes builds for armv7-none-linux-androideabi16. FYI

Can you point me to some build logs? (I didn't receive any failure mails from bots yet.)

[plotfi]

In D73990#1868085, @dim wrote:

In D73990#1868071, @plotfi wrote:

This breaks in our downstream runtimes builds for armv7-none-linux-androideabi16. FYI

Can you point me to some build logs? (I didn't receive any failure mails from bots yet.)

Our bots are not public, but I have a patch that I can post shortly. If you check the android NDK you'll see that it does not implement dlinfo.

[plotfi]

In D73990#1868085, @dim wrote:

In D73990#1868071, @plotfi wrote:

This breaks in our downstream runtimes builds for armv7-none-linux-androideabi16. FYI

Can you point me to some build logs? (I didn't receive any failure mails from bots yet.)

Posted a fix at D74358

[dim]

In D73990#1868108, @plotfi wrote:

In D73990#1868085, @dim wrote:

In D73990#1868071, @plotfi wrote:

This breaks in our downstream runtimes builds for armv7-none-linux-androideabi16. FYI

Can you point me to some build logs? (I didn't receive any failure mails from bots yet.)

Posted a fix at D74358

I found this lab builder, which gave a similar error: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-android

Committed a slightly different version in rG52f2df1ecdd79cc550b694ab280f3b0396d7cf9a, thanks for the heads up!

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cpp

zx_status_t status =
       _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &info,
                           sizeof(info), NULL, NULL);
   CHECK_EQ(status, ZX_OK);
   uptr pid = static_cast<uptr>(info.koid);
   CHECK_EQ(pid, info.koid);
   return pid;
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  UNIMPLEMENTED();
+}
+
 uptr GetThreadSelf() { return reinterpret_cast<uptr>(thrd_current()); }
 
 tid_t GetTid() { return GetThreadSelf(); }
 
 void Abort() { abort(); }
 
 int Atexit(void (*function)(void)) { return atexit(function); }
 

compiler-rt/lib/sanitizer_common/sanitizer_libc.h

 
 // OS
 void NORETURN internal__exit(int exitcode);
 unsigned int internal_sleep(unsigned int seconds);
 
 uptr internal_getpid();
 uptr internal_getppid();
 
+int internal_dlinfo(void *handle, int request, void *p);
+
 // Threading
 uptr internal_sched_yield();
 
 // Error handling
 bool internal_iserror(uptr retval, int *rverrno = nullptr);
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_LIBC_H

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 uptr internal_getpid() {
   return internal_syscall(SYSCALL(getpid));
 }
 
 uptr internal_getppid() {
   return internal_syscall(SYSCALL(getppid));
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  return dlinfo(handle, request, p);
+}
+
 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
 #if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(getdirentries), fd, (uptr)dirp, count, NULL);
 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);
 #else
   return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count);
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

 unsigned int internal_sleep(unsigned int seconds) {
   return sleep(seconds);
 }
 
 uptr internal_getpid() {
   return getpid();
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  UNIMPLEMENTED();
+}
+
 int internal_sigaction(int signum, const void *act, void *oldact) {
   return sigaction(signum,
                    (const struct sigaction *)act, (struct sigaction *)oldact);
 }
 
 void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
 
 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,

compiler-rt/lib/sanitizer_common/sanitizer_netbsd.cpp

uptr internal_getpid() {
   return _REAL(getpid);
 }
 
 uptr internal_getppid() {
   DEFINE__REAL(int, getppid);
   return _REAL(getppid);
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
+  return _REAL(dlinfo, handle, request, p);
+}
+
 uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
   DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
   return _REAL(__getdents30, fd, dirp, count);
 }
 
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
   CHECK(&__lseek);
   return __lseek(fd, 0, offset, whence);

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

 #define SANITIZER_PLATFORM_LIMITS_FREEBSD_H
 
 #if SANITIZER_FREEBSD
 
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 #include "sanitizer_platform_limits_posix.h"
 
-// FreeBSD's dlopen() returns a pointer to an Obj_Entry structure that
-// incorporates the map structure.
-#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
-  ((link_map *)((handle) == nullptr ? nullptr : ((char *)(handle) + 560)))
 // Get sys/_types.h, because that tells us whether 64-bit inodes are
 // used in struct dirent below.
 #include <sys/_types.h>
 
 namespace __sanitizer {
+void *__sanitizer_get_link_map_by_dlopen_handle(void *handle);
+#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+  (link_map *)__sanitizer_get_link_map_by_dlopen_handle(handle)
+
 extern unsigned struct_utsname_sz;
 extern unsigned struct_stat_sz;
 #if defined(__powerpc64__)
 const unsigned struct___old_kernel_stat_sz = 0;
 #else
 const unsigned struct___old_kernel_stat_sz = 32;
 #endif
 extern unsigned struct_rusage_sz;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

 #include <net/if.h>
 #include <net/ppp_defs.h>
 #include <net/route.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/ip_mroute.h>
 //
 #include <dirent.h>
+#include <dlfcn.h>
 #include <fstab.h>
 #include <fts.h>
 #include <glob.h>
 #include <grp.h>
 #include <ifaddrs.h>
 #include <limits.h>
 #include <poll.h>
 #include <pthread.h>

 #undef _KERNEL
 
 #undef INLINE  // to avoid clashes with sanitizers' definitions
 
 #undef IOC_DIRMASK
 
 // Include these after system headers to avoid name clashes and ambiguities.
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
 #include "sanitizer_platform_limits_freebsd.h"
 
 namespace __sanitizer {
+void *__sanitizer_get_link_map_by_dlopen_handle(void *handle) {
+  void *p = nullptr;
+  return internal_dlinfo(handle, RTLD_DI_LINKMAP, &p) == 0 ? p : nullptr;
+}
+
 unsigned struct_cap_rights_sz = sizeof(cap_rights_t);
 unsigned struct_utsname_sz = sizeof(struct utsname);
 unsigned struct_stat_sz = sizeof(struct stat);
 unsigned struct_rusage_sz = sizeof(struct rusage);
 unsigned struct_tm_sz = sizeof(struct tm);
 unsigned struct_passwd_sz = sizeof(struct passwd);
 unsigned struct_group_sz = sizeof(struct group);
 unsigned siginfo_t_sz = sizeof(siginfo_t);

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

 #ifndef SANITIZER_PLATFORM_LIMITS_NETBSD_H
 #define SANITIZER_PLATFORM_LIMITS_NETBSD_H
 
 #if SANITIZER_NETBSD
 
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 
-#define _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, shift) \
-  ((link_map *)((handle) == nullptr ? nullptr : ((char *)(handle) + (shift))))
-
-#if defined(__x86_64__)
-#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
-  _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 264)
-#elif defined(__i386__)
-#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
-  _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 136)
-#endif
+namespace __sanitizer {
+void *__sanitizer_get_link_map_by_dlopen_handle(void *handle);
+# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+    (link_map *)__sanitizer_get_link_map_by_dlopen_handle(handle)
 
-namespace __sanitizer {
 extern unsigned struct_utsname_sz;
 extern unsigned struct_stat_sz;
 extern unsigned struct_rusage_sz;
 extern unsigned siginfo_t_sz;
 extern unsigned struct_itimerval_sz;
 extern unsigned pthread_t_sz;
 extern unsigned pthread_mutex_t_sz;
 extern unsigned pthread_cond_t_sz;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.cpp

 #include <dev/usb/usb.h>
 #include <dev/usb/utoppy.h>
 #include <dev/vme/xio.h>
 #include <dev/vndvar.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wscons/wsdisplay_usl_io.h>
 #include <fs/autofs/autofs_ioctl.h>
 #include <dirent.h>
+#include <dlfcn.h>
 #include <glob.h>
 #include <grp.h>
 #include <ifaddrs.h>
 #include <limits.h>
 #include <link_elf.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <netdb.h>

 
 #if defined(__x86_64__)
 #include <nvmm.h>
 #endif
 // clang-format on
 
 // Include these after system headers to avoid name clashes and ambiguities.
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
 #include "sanitizer_platform_limits_netbsd.h"
 
 namespace __sanitizer {
+void *__sanitizer_get_link_map_by_dlopen_handle(void* handle) {
+  void *p = nullptr;
+  return internal_dlinfo(handle, RTLD_DI_LINKMAP, &p) == 0 ? p : nullptr;
+}
+
 unsigned struct_utsname_sz = sizeof(struct utsname);
 unsigned struct_stat_sz = sizeof(struct stat);
 unsigned struct_rusage_sz = sizeof(struct rusage);
 unsigned struct_tm_sz = sizeof(struct tm);
 unsigned struct_passwd_sz = sizeof(struct passwd);
 unsigned struct_group_sz = sizeof(struct group);
 unsigned siginfo_t_sz = sizeof(siginfo_t);
 unsigned struct_sigaction_sz = sizeof(struct sigaction);

compiler-rt/lib/sanitizer_common/sanitizer_rtems.cpp

 uptr internal_sched_yield() {
   return sched_yield();
 }
 
 uptr internal_getpid() {
   return getpid();
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  UNIMPLEMENTED();
+}
+
 bool FileExists(const char *filename) {
   struct stat st;
   if (stat(filename, &st))
     return false;
   // Sanity check: filename is a regular file.
   return S_ISREG(st.st_mode);
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

 bool FileExists(const char *filename) {
   return ::GetFileAttributesA(filename) != INVALID_FILE_ATTRIBUTES;
 }
 
 uptr internal_getpid() {
   return GetProcessId(GetCurrentProcess());
 }
 
+int internal_dlinfo(void *handle, int request, void *p) {
+  UNIMPLEMENTED();
+}
+
 // In contrast to POSIX, on Windows GetCurrentThreadId()
 // returns a system-unique identifier.
 tid_t GetTid() {
   return GetCurrentThreadId();
 }
 
 uptr GetThreadSelf() {
   return GetTid();