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

338

What about this?

1751

Why zeroes? Can you get real values?

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

72

I commented this commit here

338

I thought I did this one ...

1751

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.

311

newfstatat should return int, so no _ptr

317

same for stat

338

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?

404

same for unlinkat, it returns int, on both

1751

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

404

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

404

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

404

Good enough for me.

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

325

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–396

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

412–413

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

1751

Could you please comment about your plans here?

[devnexen]

lib/sanitizer_common/sanitizer_linux.cc

1751

All good points ... Did not know about sigcontext

[devnexen]

Adding sigcontext support

[vitalybuka]

lib/sanitizer_common/sanitizer_linux.cc

412–413

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

412–413

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>
 #endif
 #include <unistd.h>
 
 #if SANITIZER_LINUX
 #include <sys/utsname.h>
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 #include <sys/personality.h>

 }
 #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_ptr(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);
+  int res = internal_syscall_ptr(SYSCALL(stat), path, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
 # else
-  return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf);
+  return internal_syscall_ptr(SYSCALL(stat), (uptr)path, (uptr)buf);
 # endif
 #else
   struct stat64 buf64;
-  int res = internal_syscall(SYSCALL(stat64), path, &buf64);
+  int res = internal_syscall_ptr(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,
+  return internal_syscall_ptr(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);
+  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);
+  return internal_syscall_ptr(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));
 }

 #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
+#if SANITIZER_OPENBSD
+  *pc = 0;
+  *bp = 0;
+  *sp = 0;
+#elif 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;