[sanitizer][MIPS] Implement clone for MIPS

[slthakur]

Summary

Added clone implementation for MIPS.

[slthakur]

Changed comment "/* Call _exit(%rax). */" to "/* Call _exit($v0). */"

[slthakur]

Hi all,

This patch is important for LSan to work on MIPS64. Without this patch child task in LSan is not able to return control to parent task and puts LSan in infinite wait state.
Are there any comments or any changes required to this patch ?

[earthdok]

Hi, sorry for the delay.

It may be worth adding a note that we don't have proper CFI info here either (same as in x86_64 version). Clang probably supports all the necessary directives now, but it's a lot of code (at least in the mips case) for very marginal benefits, so probably not worth doing.

Note also that the glibc implementation appears to have a few differences between 32 and 64 bit mips, so please double check those to make sure they don't affect us.

Otherwise lgtm.

[slthakur]

• Added note about CFI directives as suggested by @earthdok.
• Added .cprestore directive in assembly which saves gp register across function call.

[earthdok]

lgtm

[slthakur]

Hi @earthdok,

Note also that the glibc implementation appears to have a few differences between 32 and 64 bit mips, so please double check those to make sure they don't affect us.

The only difference between 32-bit and 64-bit in glibc implementation I can see is argument passing to clone syscall. This patch was written according to n64 abi of mips. In case of n64 abi we have argument registers a0 to a5 for syscalls. Therefore this patch will work fine for LSan 64-bit on Mips.

[slthakur]

Hi all,

May I go ahead and commit this patch now?

[earthdok]

In D8318#154546, @Sagar wrote:

Hi @earthdok,

Note also that the glibc implementation appears to have a few differences between 32 and 64 bit mips, so please double check those to make sure they don't affect us.

The only difference between 32-bit and 64-bit in glibc implementation I can see is argument passing to clone syscall. This patch was written according to n64 abi of mips. In case of n64 abi we have argument registers a0 to a5 for syscalls. Therefore this patch will work fine for LSan 64-bit on Mips.

If this code is correct only on MIPS64, then please put it under an appropriate #ifdef such as __mips64.

[slthakur]

The code is correct only on MIPS64, therefore we put it under #ifdef(__mips64) as suggested by @earthdok.

[earthdok]

lgtm

[slthakur]

Added code to make internal_clone work on 32-bit also.
ASan 32-bit on mips requires internal_clone (). Therefore added in this patch only to avoid breaking ASan 32-bit on mips.

[earthdok]

Stoptheworld isn't actually used on 32-bit platforms, and that's the only thing you need clone for. But since you already have the implementation, let's land it. rslgtm

compiler-rt/trunk/lib/sanitizer_common/sanitizer_linux.cc

 #include <asm/param.h>
 #endif
 
 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
 // access stat from asm/stat.h, without conflicting with definition in
 // sys/stat.h, we use this trick.
 #if defined(__mips64)
+#include <asm/unistd.h>
 #include <sys/types.h>
 #define stat kernel_stat
 #include <asm/stat.h>
 #undef stat
 #endif
 
 #include <dlfcn.h>
 #include <errno.h>
__asm__ __volatile__(
                          "D"(flags),
                          "d"(parent_tidptr),
                          "r"(r8),
                          "r"(r10)
                        : "rsp", "memory", "r11", "rcx");
   return res;
 }
 #elif defined(__mips__)
-// TODO(sagarthakur): clone function is to be rewritten in assembly.
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
-  return clone(fn, child_stack, flags, arg, parent_tidptr,
-               newtls, child_tidptr);
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+  register void *a3 __asm__("$7") = newtls;
+  register int *a4 __asm__("$8") = child_tidptr;
+  // We don't have proper CFI directives here because it requires alot of code
+  // for very marginal benefits.
+  __asm__ __volatile__(
+                       /* $v0 = syscall($v0 = __NR_clone,
+                        * $a0 = flags,
+                        * $a1 = child_stack,
+                        * $a2 = parent_tidptr,
+                        * $a3 = new_tls,
+                        * $a4 = child_tidptr)
+                        */
+                       ".cprestore 16;\n"
+                       "move $4,%1;\n"
+                       "move $5,%2;\n"
+                       "move $6,%3;\n"
+                       "move $7,%4;\n"
+                       /* Store the fifth argument on stack
+                        * if we are using 32-bit abi.
+                        */
+#if SANITIZER_WORDSIZE == 32
+                       "lw %5,16($29);\n"
+#else
+                       "move $8,%5;\n"
+#endif
+                       "li $2,%6;\n"
+                       "syscall;\n"
+
+                       /* if ($v0 != 0)
+                        * return;
+                        */
+                       "bnez $2,1f;\n"
+
+                       /* Call "fn(arg)". */
+                       "ld $25,0($29);\n"
+                       "ld $4,8($29);\n"
+                       "jal $25;\n"
+
+                       /* Call _exit($v0). */
+                       "move $4,$2;\n"
+                       "li $2,%7;\n"
+                       "syscall;\n"
+
+                       /* Return to parent. */
+                     "1:\n"
+                       : "=r" (res)
+                       : "r"(flags),
+                         "r"(child_stack),
+                         "r"(parent_tidptr),
+                         "r"(a3),
+                         "r"(a4),
+                         "i"(__NR_clone),
+                         "i"(__NR_exit)
+                       : "memory", "$29" );
+  return res;
 }
 #endif  // defined(__x86_64__) && SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
   atomic_store(&android_log_initialized, 1, memory_order_release);