int CNIOLinux_pthread_getaffinity_np(pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset) {
#ifdef __ANDROID__
return sched_getaffinity(pthread_gettid_np(thread), cpusetsize, cpuset);
#else
return pthread_getaffinity_np(thread, cpusetsize, cpuset);
#endif
}
int CNIOLinux_pthread_getname_np(pthread_t thread, char *name, size_t len) {
#ifdef __ANDROID__
// https://android.googlesource.com/platform/bionic/+/master/libc/bionic/pthread_setname_np.cpp#51
if (thread == pthread_self()) {
return TEMP_FAILURE_RETRY(prctl(PR_GET_NAME, name)) == -1 ? -1 : 0;
}
char comm_name[64];
snprintf(comm_name, sizeof(comm_name), "/proc/self/task/%d/comm", pthread_gettid_np(thread));
int fd = TEMP_FAILURE_RETRY(open(comm_name, O_CLOEXEC | O_RDONLY));
if (fd == -1) return -1;
ssize_t n = TEMP_FAILURE_RETRY(read(fd, name, len));
close(fd);
if (n == -1) return -1;
// The kernel adds a trailing '\n' to the /proc file,
// so this is actually the normal case for short names.
if (n > 0 && name[n - 1] == '\n') {
name[n - 1] = '\0';
return 0;
}
if (n >= 0 && len <= SSIZE_MAX && n == (ssize_t)len) return 1;
name[n] = '\0';
return 0;
#else
return pthread_getname_np(thread, name, len);
#endif
}
TEST(pthread, pthread_gettid_np) {
#if defined(__BIONIC__)
ASSERT_EQ(gettid(), pthread_gettid_np(pthread_self()));
pid_t t_gettid_result;
pthread_t t;
pthread_create(&t, NULL, pthread_gettid_np_helper, &t_gettid_result);
pid_t t_pthread_gettid_np_result = pthread_gettid_np(t);
pthread_join(t, NULL);
ASSERT_EQ(t_gettid_result, t_pthread_gettid_np_result);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
// http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_create.html
int timer_create(clockid_t clock_id, sigevent* evp, timer_t* timer_id) {
PosixTimer* timer = reinterpret_cast<PosixTimer*>(malloc(sizeof(PosixTimer)));
if (timer == NULL) {
return -1;
}
timer->sigev_notify = (evp == NULL) ? SIGEV_SIGNAL : evp->sigev_notify;
// If not a SIGEV_THREAD timer, the kernel can handle it without our help.
if (timer->sigev_notify != SIGEV_THREAD) {
if (__timer_create(clock_id, evp, &timer->kernel_timer_id) == -1) {
free(timer);
return -1;
}
*timer_id = timer;
return 0;
}
// Otherwise, this must be SIGEV_THREAD timer...
timer->callback = evp->sigev_notify_function;
timer->callback_argument = evp->sigev_value;
atomic_init(&timer->deleted, false);
// Check arguments that the kernel doesn't care about but we do.
if (timer->callback == NULL) {
free(timer);
errno = EINVAL;
return -1;
}
// Create this timer's thread.
pthread_attr_t thread_attributes;
if (evp->sigev_notify_attributes == NULL) {
pthread_attr_init(&thread_attributes);
} else {
thread_attributes = *reinterpret_cast<pthread_attr_t*>(evp->sigev_notify_attributes);
}
pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED);
// We start the thread with TIMER_SIGNAL blocked by blocking the signal here and letting it
// inherit. If it tried to block the signal itself, there would be a race.
kernel_sigset_t sigset;
sigaddset(sigset.get(), TIMER_SIGNAL);
kernel_sigset_t old_sigset;
pthread_sigmask(SIG_BLOCK, sigset.get(), old_sigset.get());
int rc = pthread_create(&timer->callback_thread, &thread_attributes, __timer_thread_start, timer);
pthread_sigmask(SIG_SETMASK, old_sigset.get(), NULL);
if (rc != 0) {
free(timer);
errno = rc;
return -1;
}
sigevent se = *evp;
se.sigev_signo = TIMER_SIGNAL;
se.sigev_notify = SIGEV_THREAD_ID;
se.sigev_notify_thread_id = pthread_gettid_np(timer->callback_thread);
if (__timer_create(clock_id, &se, &timer->kernel_timer_id) == -1) {
__timer_thread_stop(timer);
return -1;
}
// Give the thread a specific meaningful name.
// It can't do this itself because the kernel timer isn't created until after it's running.
char name[16]; // 16 is the kernel-imposed limit.
snprintf(name, sizeof(name), "POSIX timer %d", to_kernel_timer_id(timer));
pthread_setname_np(timer->callback_thread, name);
*timer_id = timer;
return 0;
}
// In L we added a public pthread_gettid_np, but some apps were using the private API.
pid_t __pthread_gettid(pthread_t t) {
return pthread_gettid_np(t);
}