Implement SetThreadName in PAL for Linux.

src/pal/inc/pal.h

@@ -2410,6 +2410,14 @@ GetThreadTimes(
         OUT LPFILETIME lpKernelTime,
         OUT LPFILETIME lpUserTime);
 
+PALIMPORT
+HRESULT
+PALAPI
+SetThreadName(
+    IN HANDLE hThread,
+    IN PCWSTR lpThreadDescription
+);
+
 #define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
 
 PALIMPORT

src/pal/src/include/pal/thread.hpp

@@ -199,6 +199,14 @@ namespace CorUnix
                 int
                 );
 
+        friend
+            PAL_ERROR
+            InternalSetThreadName(
+                CPalThread *,
+                HANDLE,
+                PCWSTR
+                );
+
         friend
             PAL_ERROR
             CreateThreadData(

src/pal/src/thread/thread.cpp

@@ -1578,7 +1578,117 @@ GetThreadTimes(
     return (retval);
 }
 
+HRESULT
+PALAPI
+SetThreadName(    
+    IN HANDLE hThread,
+    IN PCWSTR lpThreadDescription)
+{
+    CPalThread *pThread;
+    PAL_ERROR palError;
+
+    PERF_ENTRY(SetThreadName);
+    ENTRY("SetThreadName(hThread=%p,lpThreadDescription=%p)\n", hThread, lpThreadDescription);
+
+    pThread = InternalGetCurrentThread();
+
+    palError = InternalSetThreadName(
+        pThread,
+        hThread,
+        lpThreadDescription
+        );
+
+    if (NO_ERROR != palError)
+    {
+        pThread->SetLastError(palError);
+    }
+
+    LOGEXIT("SetThreadNameExit");
+    PERF_EXIT(SetThreadName);
+
+    return NO_ERROR != palError ? 0x80004005 : 0; // E_FAIL
+}
+
+PAL_ERROR
+CorUnix::InternalSetThreadName(
+    CPalThread *pThread,
+    HANDLE hTargetThread,
+    PCWSTR lpThreadDescription
+)
+{
+    PAL_ERROR palError = NO_ERROR;
+    CPalThread *pTargetThread = NULL;
+    IPalObject *pobjThread = NULL;
+    int   nameSize;
+    char  *nameBuf = NULL;
+    int error;
+
+// The exact API of pthread_setname_np varies very wildly depending on OS.
+// For now, only Linux is implemented.
+#if defined(__linux__)
+
+    palError = InternalGetThreadDataFromHandle(
+        pThread,
+        hTargetThread,
+        &pTargetThread,
+        &pobjThread
+        );
 
+    if (NO_ERROR != palError)
+    {
+        goto InternalSetThreadNameExit;
+    }
+
+    pTargetThread->Lock(pThread);
+
+    /* translate the wide char lpPathName string to multibyte string */
+    if(0 == (nameSize = WideCharToMultiByte( CP_ACP, 0, lpThreadDescription, -1, NULL, 0,
+                                            NULL, NULL )))
+    {
+        palError = ERROR_INTERNAL_ERROR;
+        goto InternalSetThreadNameExit;
+    }
+
+    if (((nameBuf = (char *)PAL_malloc(nameSize)) == NULL) ||
+        (WideCharToMultiByte( CP_ACP, 0, lpThreadDescription, -1, nameBuf, nameSize, NULL,
+                              NULL) != nameSize))
+    {
+        palError = ERROR_INTERNAL_ERROR;
+        goto InternalSetThreadNameExit;
+    }
+
+    // Null terminate early.
+    // pthread_setname_np only accepts up to 16 chars.
+    nameBuf[15] = '\0';
+
+    error = pthread_setname_np(pTargetThread->GetPThreadSelf(), nameBuf);
+
+    if (error != 0) 
+    {
+        palError = ERROR_INTERNAL_ERROR;
+        goto InternalSetThreadNameExit;
+    }
+
+InternalSetThreadNameExit:
+
+    if (NULL != pTargetThread)
+    {
+        pTargetThread->Unlock(pThread);
+    }
+
+    if (NULL != pobjThread)
+    {
+        pobjThread->ReleaseReference(pThread);
+    }
+
+    if (NULL != nameBuf) {
+        PAL_free(nameBuf);
+    }
+
+#endif // defined(__linux__)
+
+    return palError;
+}
 
 void *
 CPalThread::ThreadEntry(

src/vm/comsynchronizable.cpp

@@ -1283,14 +1283,13 @@ void QCALLTYPE ThreadNative::InformThreadNameChange(QCall::ThreadHandle thread,
 
     Thread* pThread = &(*thread);
 
-#ifndef FEATURE_PAL
     // Set on Windows 10 Creators Update and later machines the unmanaged thread name as well. That will show up in ETW traces and debuggers which is very helpful
     // if more and more threads get a meaningful name
+    // Will also show up in Linux in gdb and such.
     if (len > 0 && name != NULL && pThread->GetThreadHandle() != INVALID_HANDLE_VALUE)
     {
         SetThreadName(pThread->GetThreadHandle(), name);
     }
-#endif
 
 #ifdef PROFILING_SUPPORTED
     {

src/vm/threads.cpp

@@ -2071,9 +2071,9 @@ BOOL Thread::CreateNewThread(SIZE_T stackSize, LPTHREAD_START_ROUTINE start, voi
     bRet = CreateNewOSThread(stackSize, start, args);
 #ifndef FEATURE_PAL
     UndoRevert(bReverted, token);
+#endif // !FEATURE_PAL
     if (pName != NULL)
         SetThreadName(m_ThreadHandle, pName);
-#endif // !FEATURE_PAL
 
     return bRet;
 }
@@ -2130,9 +2130,8 @@ HANDLE Thread::CreateUtilityThread(Thread::StackSizeBucket stackSizeBucket, LPTH
 
     DWORD threadId;
     HANDLE hThread = CreateThread(NULL, stackSize, start, args, flags, &threadId);
-#ifndef FEATURE_PAL
+
     SetThreadName(hThread, pName);
-#endif // !FEATURE_PAL
 
 
     if (pThreadId)

src/vm/win32threadpool.cpp

@@ -1824,9 +1824,8 @@ Thread* ThreadpoolMgr::CreateUnimpersonatedThread(LPTHREAD_START_ROUTINE lpStart
                                         lpThreadArgs,       // arguments
                                         CREATE_SUSPENDED,
                                         &threadId);
-#ifndef FEATURE_PAL
+
             SetThreadName(threadHandle, W(".NET ThreadPool Worker"));
-#endif // !FEATURE_PAL
             if (threadHandle != NULL)
                 lpThreadArgs.SuppressRelease();
         }