static int Sys_SetThreadName( pthread_t handle, const char* name ) { int ret = 0; #ifdef __linux__ // NOTE: linux only supports threadnames up to 16chars *including* terminating NULL // http://man7.org/linux/man-pages/man3/pthread_setname_np.3.html // on my machine a longer name (eg "JobListProcessor_0") caused an ENOENT error (instead of ERANGE) assert( strlen( name ) < 16 ); ret = pthread_setname_np( handle, name ); if( ret != 0 ) idLib::common->Printf( "Setting threadname \"%s\" failed, reason: %s (%i)\n", name, strerror( errno ), errno ); #elif defined(__FreeBSD__) // according to http://www.freebsd.org/cgi/man.cgi?query=pthread_set_name_np&sektion=3 // the interface is void pthread_set_name_np(pthread_t tid, const char *name); pthread_set_name_np( handle, name ); // doesn't return anything #endif /* TODO: OSX: // according to http://stackoverflow.com/a/7989973 // this needs to be called in the thread to be named! ret = pthread_setname_np(name); // so we'd have to wrap the xthread_t function in Sys_CreateThread and set the name in the wrapping function... */ return ret; }
Error ThreadPosix::set_name_func_posix(const String& p_name) { pthread_t running_thread = pthread_self(); #ifdef PTHREAD_NO_RENAME return ERR_UNAVAILABLE; #else #ifdef PTHREAD_RENAME_SELF // check if thread is the same as caller int err = pthread_setname_np(p_name.utf8().get_data()); #else #ifdef PTHREAD_BSD_SET_NAME pthread_set_name_np(running_thread, p_name.utf8().get_data()); int err = 0; // Open/FreeBSD ignore errors in this function #else int err = pthread_setname_np(running_thread, p_name.utf8().get_data()); #endif // PTHREAD_BSD_SET_NAME #endif // PTHREAD_RENAME_SELF return err == 0 ? OK : ERR_INVALID_PARAMETER; #endif // PTHREAD_NO_RENAME };
void js::ThisThread::SetName(const char* name) { MOZ_RELEASE_ASSERT(name); #if (defined(__APPLE__) && defined(__MACH__)) || defined(__linux__) // On linux and OS X the name may not be longer than 16 bytes, including // the null terminator. Truncate the name to 15 characters. char nameBuf[16]; strncpy(nameBuf, name, sizeof nameBuf - 1); nameBuf[sizeof nameBuf - 1] = '\0'; name = nameBuf; #endif int rv; #ifdef XP_DARWIN rv = pthread_setname_np(name); #elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__) pthread_set_name_np(pthread_self(), name); rv = 0; #elif defined(__NetBSD__) rv = pthread_setname_np(pthread_self(), "%s", (void*)name); #else rv = pthread_setname_np(pthread_self(), name); #endif MOZ_RELEASE_ASSERT(!rv); }
/* Thread: main */ int library_init(void) { int i; int ret; scan_exit = false; scanning = false; CHECK_NULL(L_LIB, evbase_lib = event_base_new()); CHECK_NULL(L_LIB, updateev = evtimer_new(evbase_lib, update_trigger_cb, NULL)); for (i = 0; sources[i]; i++) { if (!sources[i]->init) continue; ret = sources[i]->init(); if (ret < 0) sources[i]->disabled = 1; } CHECK_NULL(L_LIB, cmdbase = commands_base_new(evbase_lib, NULL)); CHECK_ERR(L_LIB, pthread_create(&tid_library, NULL, library, NULL)); #if defined(HAVE_PTHREAD_SETNAME_NP) pthread_setname_np(tid_library, "library"); #elif defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(tid_library, "library"); #endif return 0; }
void SDL_SYS_SetupThread(const char *name) { int i; sigset_t mask; if (name != NULL) { #if ( (__MACOSX__ && (MAC_OS_X_VERSION_MAX_ALLOWED >= 1060)) || \ (__IPHONEOS__ && (__IPHONE_OS_VERSION_MAX_ALLOWED >= 30200)) ) if (pthread_setname_np != NULL) { pthread_setname_np(name); } #elif HAVE_PTHREAD_SETNAME_NP pthread_setname_np(pthread_self(), name); #elif HAVE_PTHREAD_SET_NAME_NP pthread_set_name_np(pthread_self(), name); #endif } /* Mask asynchronous signals for this thread */ sigemptyset(&mask); for (i = 0; sig_list[i]; ++i) { sigaddset(&mask, sig_list[i]); } pthread_sigmask(SIG_BLOCK, &mask, 0); #ifdef PTHREAD_CANCEL_ASYNCHRONOUS /* Allow ourselves to be asynchronously cancelled */ { int oldstate; pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate); } #endif }
static void * thread_wrapper ( void *p ) { struct thread_state *ts = p; sigset_t set; #if defined(PLATFORM_LINUX) /* Set name */ prctl(PR_SET_NAME, ts->name); #elif defined(PLATFORM_FREEBSD) /* Set name of thread */ pthread_set_name_np(pthread_self(), ts->name); #elif defined(PLATFORM_DARWIN) pthread_setname_np(ts->name); #endif sigemptyset(&set); sigaddset(&set, SIGTERM); pthread_sigmask(SIG_UNBLOCK, &set, NULL); signal(SIGTERM, doexit); /* Run */ tvhtrace("thread", "created thread %ld [%s / %p(%p)]", (long)pthread_self(), ts->name, ts->run, ts->arg); void *r = ts->run(ts->arg); free(ts); return r; }
void * Thread::entryPoint(void * param) { Thread & thread = *((Thread *)param); // Set the thread name. #if ARX_HAVE_PTHREAD_SETNAME_NP && ARX_PLATFORM != ARX_PLATFORM_MACOSX // Linux pthread_setname_np(thread.thread, thread.threadName.c_str()); #elif ARX_HAVE_PTHREAD_SETNAME_NP && ARX_PLATFORM == ARX_PLATFORM_MACOSX // Mac OS X pthread_setname_np(thread.threadName.c_str()); #elif ARX_HAVE_PTHREAD_SET_NAME_NP // FreeBSD & OpenBSD pthread_set_name_np(thread.thread, thread.threadName.c_str()); #elif ARX_HAVE_PRCTL && defined(PR_SET_NAME) // Linux prctl(PR_SET_NAME, reinterpret_cast<unsigned long>(thread.threadName.c_str()), 0, 0, 0); #else // This is non-fatal, but let's print a warning so future ports will be // reminded to implement it. #pragma message ( "No function available to set thread names!" ) #endif CrashHandler::registerThreadCrashHandlers(); profiler::registerThread(thread.threadName); thread.run(); profiler::unregisterThread(); CrashHandler::unregisterThreadCrashHandlers(); return NULL; }
void zmq::thread_t::setThreadName(const char *name_) { /* The thread name is a cosmetic string, added to ease debugging of * multi-threaded applications. It is not a big issue if this value * can not be set for any reason (such as Permission denied in some * cases where the application changes its EUID, etc.) The value of * "int rc" is retained where available, to help debuggers stepping * through code to see its value - but otherwise it is ignored. */ if (!name_) return; #if defined(ZMQ_HAVE_PTHREAD_SETNAME_1) int rc = pthread_setname_np(name_); if(rc) return; #elif defined(ZMQ_HAVE_PTHREAD_SETNAME_2) int rc = pthread_setname_np(descriptor, name_); if(rc) return; #elif defined(ZMQ_HAVE_PTHREAD_SETNAME_3) int rc = pthread_setname_np(descriptor, name_, NULL); if(rc) return; #elif defined(ZMQ_HAVE_PTHREAD_SET_NAME) pthread_set_name_np(descriptor, name_); #endif }
R_API bool r_th_setname(RThread *th, const char *name) { #if defined(HAVE_PTHREAD_NP) && HAVE_PTHREAD_NP #if __linux__ if (pthread_setname_np (th->tid, name) != 0) { eprintf ("Failed to set thread name\n"); return false; } return true; #elif __FreeBSD__ || __OpenBSD__ || __DragonFly__ pthread_set_name_np (th->tid, name); return true; #elif __NetBSD__ if (pthread_setname_np (th->tid, "%s", (void *)name) != 0) { eprintf ("Failed to set thread name\n"); return false; } return true; #else #pragma message("warning r_th_setname not implemented") #endif #else return true; #endif }
void SetThisProcessName(const char *aName) { #if defined(OS_NETBSD) pthread_setname_np(pthread_self(), "%s", (void *)aName); #else pthread_set_name_np(pthread_self(), aName); #endif }
void THR_SetName(const char *name) { AZ(pthread_setspecific(name_key, name)); #ifdef HAVE_PTHREAD_SET_NAME_NP pthread_set_name_np(pthread_self(), name); #endif }
void CThread::SetThreadInfo() { #ifdef TARGET_FREEBSD #if __FreeBSD_version < 900031 long lwpid; thr_self(&lwpid); m_ThreadOpaque.LwpId = lwpid; #else m_ThreadOpaque.LwpId = pthread_getthreadid_np(); #endif #elif defined(TARGET_ANDROID) m_ThreadOpaque.LwpId = gettid(); #else m_ThreadOpaque.LwpId = syscall(SYS_gettid); #endif #if defined(HAVE_PTHREAD_SETNAME_NP) #ifdef TARGET_DARWIN #if(__MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 30200) pthread_setname_np(m_ThreadName.c_str()); #endif #else pthread_setname_np(m_ThreadId, m_ThreadName.c_str()); #endif #elif defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(m_ThreadId, m_ThreadName.c_str()); #endif #ifdef RLIMIT_NICE // get user max prio struct rlimit limit; int userMaxPrio; if (getrlimit(RLIMIT_NICE, &limit) == 0) { userMaxPrio = limit.rlim_cur - 20; if (userMaxPrio < 0) userMaxPrio = 0; } else userMaxPrio = 0; if (geteuid() == 0) userMaxPrio = GetMaxPriority(); // if the user does not have an entry in limits.conf the following // call will fail if (userMaxPrio > 0) { // start thread with nice level of appication int appNice = getpriority(PRIO_PROCESS, getpid()); if (setpriority(PRIO_PROCESS, m_ThreadOpaque.LwpId, appNice) != 0) if (logger) logger->Log(LOGERROR, "%s: error %s", __FUNCTION__, strerror(errno)); } #endif }
void SDL_SYS_SetupThread(const char *name) { #if !defined(__ANDROID__) && !defined(__NACL__) int i; sigset_t mask; #endif /* !__ANDROID__ && !__NACL__ */ if (name != NULL) { #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__) SDL_assert(checked_setname); if (ppthread_setname_np != NULL) { #if defined(__MACOSX__) || defined(__IPHONEOS__) ppthread_setname_np(name); #elif defined(__LINUX__) ppthread_setname_np(pthread_self(), name); #endif } #elif HAVE_PTHREAD_SETNAME_NP #if defined(__NETBSD__) pthread_setname_np(pthread_self(), "%s", name); #else pthread_setname_np(pthread_self(), name); #endif #elif HAVE_PTHREAD_SET_NAME_NP pthread_set_name_np(pthread_self(), name); #elif defined(__HAIKU__) /* The docs say the thread name can't be longer than B_OS_NAME_LENGTH. */ char namebuf[B_OS_NAME_LENGTH]; SDL_snprintf(namebuf, sizeof (namebuf), "%s", name); namebuf[sizeof (namebuf) - 1] = '\0'; rename_thread(find_thread(NULL), namebuf); #endif } /* NativeClient does not yet support signals.*/ #if !defined(__ANDROID__) && !defined(__NACL__) /* Mask asynchronous signals for this thread */ sigemptyset(&mask); for (i = 0; sig_list[i]; ++i) { sigaddset(&mask, sig_list[i]); } pthread_sigmask(SIG_BLOCK, &mask, 0); #endif /* !__ANDROID__ && !__NACL__ */ #ifdef PTHREAD_CANCEL_ASYNCHRONOUS /* Allow ourselves to be asynchronously cancelled */ { int oldstate; pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate); } #endif }
void setCurrentThreadName(const std::string &name) { #if defined (__linux__) && !defined(ANDROID) prctl(PR_SET_NAME, name.c_str(), 0, 0, 0); #elif defined (__APPLE__) pthread_setname_np(name.c_str()); #elif defined (ANDROID) //no implementation under Android #else //BSD, whatever... pthread_set_name_np(pthread_self(), name.c_str()); #endif }
void sctp_userspace_set_threadname(const char *name) { #if defined(__Userspace_os_Darwin) pthread_setname_np(name); #endif #if defined(__Userspace_os_Linux) prctl(PR_SET_NAME, name); #endif #if defined(__Userspace_os_FreeBSD) pthread_set_name_np(pthread_self(), name); #endif }
//! Set the thread's name at the process level. Does not affect the //! internal name. static void SetThreadName(const char* name) { #if defined(PR_SET_NAME) // Only the first 15 characters are used (16 - NUL terminator) ::prctl(PR_SET_NAME, name, 0, 0, 0); #elif (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)) pthread_set_name_np(pthread_self(), name); #elif defined(MAC_OSX) pthread_setname_np(name); #else // Prevent warnings for unused parameters... (void)name; #endif }
/* Sets 'subprogram_name' as the name of the currently running thread or * process. (This appears in log messages and may also be visible in system * process listings and debuggers.) */ void set_subprogram_name(const char *subprogram_name) { char *pname = xstrdup(subprogram_name ? subprogram_name : program_name); free(subprogram_name_set(pname)); #if HAVE_GLIBC_PTHREAD_SETNAME_NP pthread_setname_np(pthread_self(), pname); #elif HAVE_NETBSD_PTHREAD_SETNAME_NP pthread_setname_np(pthread_self(), "%s", pname); #elif HAVE_PTHREAD_SET_NAME_NP pthread_set_name_np(pthread_self(), pname); #endif }
int fm_fft_thread_start(struct fm_fft_thread *ft) { int r; r = pthread_create(&ft->ft_thr, NULL, fm_fft_thread_thr, ft); if (r != 0) { warn("%s: pthread_create", __func__); return (-1); } pthread_set_name_np(ft->ft_thr, "fft_thread"); return (0); }
/** * First pthread child -- pull stuff apart and re-exec user's first function * * Also, disable cancellation, disable signals, install tracking list cleanup * handler, make detached, start user processing * * THREADS: MT-SAFE * * @param opaque Data from pthread which is hopefully my tcomm * @return stuff from user function which is then ignored */ static void *bk_thread_continue(void *opaque) { struct bk_threadcomm *tcomm = opaque; bk_s B; void *subopaque; void *(*start)(bk_s, void *); sigset_t mask; if (!tcomm) { return(NULL); // <TRICKY>Work around gcc bug</TRICKY> subopaque = &subopaque; } // Block all signals except SIGCONT (to allow interrupting select calls) sigfillset(&mask); sigdelset(&mask, SIGCONT); pthread_sigmask(SIG_BLOCK, &mask, NULL); // Defer cancel until cancel point (per POSIX, this is default - be paranoid) pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); // Turn on cacellability pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); B = tcomm->btc_B; subopaque = tcomm->btc_opaque; start = tcomm->btc_start; setitimer(ITIMER_PROF, &tcomm->btc_itimer, NULL); pthread_getcpuclockid(pthread_self(), &(BK_BT_CPU_CLOCK(B))); free(opaque); #ifdef HAVE_PTHREAD_SET_NAME_NP // what the hell, might as well... pthread_set_name_np(pthread_self(), (char *)BK_BT_THREADNAME(B)); #endif pthread_cleanup_push(bk_thread_cleanup, B); subopaque = (*start)(B, subopaque); bk_thread_cancel(B, pthread_self(), 0); pthread_cleanup_pop(1); return subopaque; }
/* Thread: main */ int filescanner_init(void) { int ret; scan_exit = 0; scanning = 0; evbase_scan = event_base_new(); if (!evbase_scan) { DPRINTF(E_FATAL, L_SCAN, "Could not create an event base\n"); return -1; } ret = inofd_event_set(); if (ret < 0) { goto ino_fail; } cmdbase = commands_base_new(evbase_scan, NULL); ret = pthread_create(&tid_scan, NULL, filescanner, NULL); if (ret != 0) { DPRINTF(E_FATAL, L_SCAN, "Could not spawn filescanner thread: %s\n", strerror(errno)); goto thread_fail; } #if defined(HAVE_PTHREAD_SETNAME_NP) pthread_setname_np(tid_scan, "filescanner"); #elif defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(tid_scan, "filescanner"); #endif return 0; thread_fail: commands_base_free(cmdbase); close(inofd); ino_fail: event_base_free(evbase_scan); return -1; }
void dylan_set_current_thread_name(const char *name) { #ifdef OPEN_DYLAN_PLATFORM_LINUX /* gdb shows this, so set it too */ prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0); extern int pthread_setname_np(pthread_t, const char*) __attribute__((weak)); if (pthread_setname_np) { pthread_setname_np(pthread_self(), name); } #endif #ifdef OPEN_DYLAN_PLATFORM_FREEBSD pthread_set_name_np(pthread_self(), name); #endif #ifdef OPEN_DYLAN_PLATFORM_DARWIN pthread_setname_np(name); #endif }
void althrd_setname(althrd_t thr, const char *name) { #if defined(HAVE_PTHREAD_SETNAME_NP) #if defined(__GNUC__) pthread_setname_np(thr, name); #elif defined(__APPLE__) if(althrd_equal(thr, althrd_current()) pthread_setname_np(name); #endif #elif defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(thr, name); #else (void)thr; (void)name; #endif }
void Thread::setName(const std::string &name) { #if defined(linux) || defined(__linux) // It would be cleaner to do this with pthread_setname_np, // which was added to glibc in version 2.12, but some major // distributions are still runing 2.11 and previous versions. prctl(PR_SET_NAME, name.c_str()); #elif defined(__FreeBSD__) || defined(__OpenBSD__) pthread_set_name_np(pthread_self(), name.c_str()); #elif defined(__NetBSD__) pthread_setname_np(pthread_self(), name.c_str()); #elif defined(__APPLE__) pthread_setname_np(name.c_str()); #elif defined(_MSC_VER) // Windows itself doesn't support thread names, // but the MSVC debugger does... THREADNAME_INFO info; info.dwType = 0x1000; info.szName = name.c_str(); info.dwThreadID = -1; info.dwFlags = 0; __try { RaiseException(0x406D1388, 0, sizeof(info) / sizeof(DWORD), (ULONG_PTR *)&info); } __except (EXCEPTION_CONTINUE_EXECUTION) { } #elif defined(_WIN32) || defined(__GNU__) // These platforms are known to not support thread names. // Silently ignore the request. #else #warning "Unrecognized platform, thread names will not be available." #endif }
void THR_SetName(const char *name) { AZ(pthread_setspecific(name_key, name)); #if defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(pthread_self(), name); #elif defined(HAVE_PTHREAD_SETNAME_NP) #if defined(__APPLE__) pthread_setname_np(name); #elif defined(__NetBSD__) pthread_setname_np(pthread_self(), "%s", (char *)(uintptr_t)name); #else pthread_setname_np(pthread_self(), name); #endif #endif }
PRStatus PR_SetCurrentThreadName(const char* name) { int result; #ifdef XP_MACOSX result = pthread_setname_np(name); #elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__) pthread_set_name_np(pthread_self(), name); result = 0; #elif defined(__NetBSD__) result = pthread_setname_np(pthread_self(), "%s", (void*)name); #else result = pthread_setname_np(pthread_self(), name); #endif if (result) return PR_FAILURE; return PR_SUCCESS; }
void althrd_setname(althrd_t thr, const char *name) { #if defined(HAVE_PTHREAD_SETNAME_NP) #if defined(PTHREAD_SETNAME_NP_ONE_PARAM) if(althrd_equal(thr, althrd_current())) pthread_setname_np(name); #elif defined(PTHREAD_SETNAME_NP_THREE_PARAMS) pthread_setname_np(thr, "%s", (void*)name); #else pthread_setname_np(thr, name); #endif #elif defined(HAVE_PTHREAD_SET_NAME_NP) pthread_set_name_np(thr, name); #else (void)thr; (void)name; #endif }
static void * fbsdrun_start_thread(void *param) { char tname[MAXCOMLEN + 1]; struct mt_vmm_info *mtp; int vcpu; mtp = param; vcpu = mtp->mt_vcpu; snprintf(tname, sizeof(tname), "vcpu %d", vcpu); pthread_set_name_np(mtp->mt_thr, tname); vm_loop(mtp->mt_ctx, vcpu, vmexit[vcpu].rip); /* not reached */ exit(1); return (NULL); }
static void __create_thread(pthread_t *tid, const char *name, int seq) { struct sched_param param; pthread_attr_t attr; int ret; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&attr, SCHED_FIFO); pthread_attr_setschedparam(&attr, ¶m); pthread_attr_setstacksize(&attr, 64*1024); ret = pthread_create(tid, &attr, thread_body, (void *)(long)seq); if (ret) error(1, ret, "pthread_create"); pthread_attr_destroy(&attr); pthread_set_name_np(*tid, name); }
/* Start a new thread. */ ILIAS_NET2_LOCAL struct net2_thread* net2_thread_new(void *(*fn)(void*), void *arg, const char *name) { struct net2_thread *t; if ((t = net2_malloc(sizeof(*t))) == NULL) return NULL; t->fn = fn; t->arg = arg; if (pthread_create(&t->n2t_impl, NULL, &thread_wrapper, t)) { warn("pthread_create"); net2_free(t); return NULL; } #ifdef HAS_PTHREAD_SET_NAME_NP if (name != NULL) pthread_set_name_np(t->n2t_impl, name); #endif /* HAS_PTHREAD_SET_NAME_NP */ return t; }
static void * thread_wrapper ( void *p ) { struct thread_state *ts = p; #if defined(PLATFORM_LINUX) /* Set name */ prctl(PR_SET_NAME, ts->name); #elif defined(PLATFORM_FREEBSD) /* Set name of thread */ pthread_set_name_np(pthread_self(), ts->name); #endif /* Run */ tvhdebug("thread", "created thread %ld [%s / %p(%p)]", (long)pthread_self(), ts->name, ts->run, ts->arg); void *r = ts->run(ts->arg); free(ts); return r; }