More OpenBSD fixes

[devnexen]

Summary

• Use internal_syscall_ptr in internal_readlink
• use sigcontext on OpenBSD

Patch by David CARLIER

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

72

this should not be needed after r328077

339

What about this?

1757

Why zeroes? Can you get real values?

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

72

I commented this commit here

339

I thought I did this one ...

1757

ucontext not supported here.

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

72

Nice works better under FreeBSD should do the job under OpenBSD.

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

72

Sorry, that was a typo.

312–313

newfstatat should return int, so no _ptr

318

same for stat

339

Sorry, but I only asked, because I am not sure why you are making this change.
According sanitizer_common/sanitizer_syscall_generic.inc

internal_syscall_ptr for pointer and (s)size_t

Looking on documentation all of them return int and internal_syscall supposed to be used. What am I missing?

408

same for unlinkat, it returns int, on both

1757

https://man.openbsd.org/sigaction.2

On OpenBSD, ucontext_t is an alias for the sigcontext structure defined in <signal.h>.

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

408

Seems under Linux it s the same in fact https://github.com/llvm-mirror/compiler-rt/blob/b4e600115ad4c50192095c225aaed3ae9ca99ec1/lib/sanitizer_common/sanitizer_syscall_generic.inc#L53 but I personally do not mind reverting them I think it was kamel who asked me to update in the first place.

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

408

it's the same, but if we introduced internal_syscall_ptr and we specified that it's for pointers and size, we should follow that convention.

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

408

Good enough for me.

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

326

I think it should be internal_syscall() as it's int everywhere, why do you need ptr?
And this is not OpenBSD branch at all

395–400

On linux readlinkat is int, on OpenBSD it's size. So it should be two different branches

416–417

it's int on OpenBSD as well https://github.com/openbsd/src/blob/master/sys/sys/syscall.h

1757

Could you please comment about your plans here?

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

1757

All good points ... Did not know about sigcontext

[devnexen]

Adding sigcontext support

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

416–417

it's int on OpenBSD as well
https://github.com/openbsd/src/blob/master/sys/sys/syscall.h

What do you think about this one?

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

416–417

Sorry I missed this one good point.

lib/sanitizer_common/sanitizer_linux.cc

 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #if !SANITIZER_OPENBSD
 #include <ucontext.h>
 #endif
 #if SANITIZER_OPENBSD
 #include <sys/futex.h>
+#include <signal.h>
 #endif
 #include <unistd.h>
 
 #if SANITIZER_LINUX
 #include <sys/utsname.h>
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID

 }
 #endif
 
 uptr internal_stat(const char *path, void *buf) {
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD
   return internal_syscall_ptr(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                               0);
 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
-  return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf,
-                          0);
+  return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
+                              (uptr)buf, 0);
 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 # if defined(__mips64)
   // For mips64, stat syscall fills buffer in the format of kernel_stat
   struct kernel_stat kbuf;
   int res = internal_syscall(SYSCALL(stat), path, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
 # else
   return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf);
 # endif
 #else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(stat64), path, &buf64);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
 #endif
 }
 
 uptr internal_lstat(const char *path, void *buf) {
 #if SANITIZER_NETBSD
   return internal_syscall_ptr(SYSCALL(lstat), path, buf);
 #elif SANITIZER_FREEBSD || SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                           AT_SYMLINK_NOFOLLOW);
 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                           AT_SYMLINK_NOFOLLOW);
 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 # if SANITIZER_MIPS64
   // For mips64, lstat syscall fills buffer in the format of kernel_stat
   struct kernel_stat kbuf;
   int res = internal_syscall(SYSCALL(lstat), path, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;

 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
 #else
   return internal_syscall(SYSCALL(dup2), oldfd, newfd);
 #endif
 }
 
 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
-  return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path, (uptr)buf,
-                          bufsize);
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path,
+                              (uptr)buf, bufsize);
+#elif SANITIZER_OPENBSD
+  return internal_syscall_ptr(SYSCALL(readlinkat), AT_FDCWD, (uptr)path,
+                              (uptr)buf, bufsize);
 #else
   return internal_syscall_ptr(SYSCALL(readlink), path, buf, bufsize);
 #endif
 }
 
 uptr internal_unlink(const char *path) {
 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 #else
   return internal_syscall_ptr(SYSCALL(unlink), (uptr)path);
 #endif
 }
 
 uptr internal_rename(const char *oldpath, const char *newpath) {
 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
-  return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
-                          (uptr)newpath);
+  return internal_syscall_ptr(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath,
+                              AT_FDCWD, (uptr)newpath);
 #else
   return internal_syscall_ptr(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 #endif
 }
 
 uptr internal_sched_yield() {
   return internal_syscall(SYSCALL(sched_yield));
 }
static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
   }
   return false;
 }
 #endif
 
 SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
 #if !SANITIZER_OPENBSD
   ucontext_t *ucontext = (ucontext_t *)context;
+#else
+  sigcontext *ucontext = (sigcontext *)context;
 #if defined(__x86_64__) || defined(__i386__)
   static const uptr PF_WRITE = 1U << 1;
 #if SANITIZER_FREEBSD
   uptr err = ucontext->uc_mcontext.mc_err;
 #elif SANITIZER_NETBSD
   uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];
+#elif SANITIZER_OPENBSD
+  uptr err = ucontext->sc_err;
 #elif SANITIZER_SOLARIS && defined(__i386__)
 # define ERR 13
   uptr err = ucontext->uc_mcontext.gregs[ERR];
 #else
   uptr err = ucontext->uc_mcontext.gregs[REG_ERR];
 #endif
   return err & PF_WRITE ? WRITE : READ;
 #elif defined(__arm__)
#elif SANITIZER_SOLARIS && defined(__sparc__)
   // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype).
   uptr pc = ucontext->uc_mcontext.gregs[REG_PC];
   u32 instr = *(u32 *)pc;
   return (instr >> 21) & 1 ? WRITE: READ;
 #else
   (void)ucontext;
   return UNKNOWN;  // FIXME: Implement.
 #endif
-#else  // !SANITIZER_OPENBSD
-  return UNKNOWN;
 #endif // !SANITIZER_OPENBSD
 }
 
 void SignalContext::DumpAllRegisters(void *context) {
   // FIXME: Implement this.
 }
 
 static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
 #if SANITIZER_NETBSD
   // This covers all NetBSD architectures
   ucontext_t *ucontext = (ucontext_t *)context;
   *pc = _UC_MACHINE_PC(ucontext);
   *bp = _UC_MACHINE_FP(ucontext);
   *sp = _UC_MACHINE_SP(ucontext);
 #elif defined(__arm__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.arm_pc;
   *bp = ucontext->uc_mcontext.arm_fp;
#elif defined(__hppa__)
   *bp = ucontext->uc_mcontext.sc_gr[3];
   *sp = ucontext->uc_mcontext.sc_gr[30];
 #elif defined(__x86_64__)
 # if SANITIZER_FREEBSD
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.mc_rip;
   *bp = ucontext->uc_mcontext.mc_rbp;
   *sp = ucontext->uc_mcontext.mc_rsp;
+#elif SANITIZER_OPENBSD
+  sigcontext *ucontext = (sigcontext *)context;
+  *pc = ucontext->sc_rip;
+  *bp = ucontext->sc_rbp;
+  *sp = ucontext->sc_rsp;
 # else
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.gregs[REG_RIP];
   *bp = ucontext->uc_mcontext.gregs[REG_RBP];
   *sp = ucontext->uc_mcontext.gregs[REG_RSP];
 # endif
 #elif defined(__i386__)
 # if SANITIZER_FREEBSD
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.mc_eip;
   *bp = ucontext->uc_mcontext.mc_ebp;
   *sp = ucontext->uc_mcontext.mc_esp;
+#elif SANITIZER_OPENBSD
+  sigcontext *ucontext = (sigcontext *)context;
+  *pc = ucontext->sc_eip;
+  *bp = ucontext->sc_ebp;
+  *sp = ucontext->sc_esp;
 # else
   ucontext_t *ucontext = (ucontext_t*)context;
 # if SANITIZER_SOLARIS
   /* Use the numeric values: the symbolic ones are undefined by llvm
      include/llvm/Support/Solaris.h.  */
 # ifndef REG_EIP
 #  define REG_EIP 14 // REG_PC
 # endif