369 lines
12 KiB
C++
369 lines
12 KiB
C++
|
//
|
||
|
|
// Copyright 2010 The Android Open Source Project
|
||
|
|
//
|
||
|
|
// A looper implementation based on epoll().
|
||
|
|
//
|
||
|
|
#define LOG_TAG "Looper"
|
||
|
|
|
||
|
|
//#define LOG_NDEBUG 0
|
||
|
|
|
||
|
|
// Debugs poll and wake interactions.
|
||
|
|
#define DEBUG_POLL_AND_WAKE 0
|
||
|
|
|
||
|
|
// Debugs callback registration and invocation.
|
||
|
|
#define DEBUG_CALLBACKS 0
|
||
|
|
|
||
|
|
#include <cutils/log.h>
|
||
|
|
#include <utils/Looper.h>
|
||
|
|
#include <utils/Timers.h>
|
||
|
|
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
#include <sys/epoll.h>
|
||
|
|
|
||
|
|
|
||
|
|
namespace android {
|
||
|
|
|
||
|
|
static pthread_mutex_t gTLSMutex = PTHREAD_MUTEX_INITIALIZER;
|
||
|
|
static bool gHaveTLS = false;
|
||
|
|
static pthread_key_t gTLS = 0;
|
||
|
|
|
||
|
|
// Hint for number of file descriptors to be associated with the epoll instance.
|
||
|
|
static const int EPOLL_SIZE_HINT = 8;
|
||
|
|
|
||
|
|
// Maximum number of file descriptors for which to retrieve poll events each iteration.
|
||
|
|
static const int EPOLL_MAX_EVENTS = 16;
|
||
|
|
|
||
|
|
Looper::Looper(bool allowNonCallbacks) :
|
||
|
|
mAllowNonCallbacks(allowNonCallbacks),
|
||
|
|
mResponseIndex(0) {
|
||
|
|
mEpollFd = epoll_create(EPOLL_SIZE_HINT);
|
||
|
|
LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance. errno=%d", errno);
|
||
|
|
|
||
|
|
int wakeFds[2];
|
||
|
|
int result = pipe(wakeFds);
|
||
|
|
LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno);
|
||
|
|
|
||
|
|
mWakeReadPipeFd = wakeFds[0];
|
||
|
|
mWakeWritePipeFd = wakeFds[1];
|
||
|
|
|
||
|
|
result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
|
||
|
|
LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d",
|
||
|
|
errno);
|
||
|
|
|
||
|
|
result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
|
||
|
|
LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d",
|
||
|
|
errno);
|
||
|
|
|
||
|
|
struct epoll_event eventItem;
|
||
|
|
eventItem.events = EPOLLIN;
|
||
|
|
eventItem.data.fd = mWakeReadPipeFd;
|
||
|
|
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);
|
||
|
|
LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d",
|
||
|
|
errno);
|
||
|
|
}
|
||
|
|
|
||
|
|
Looper::~Looper() {
|
||
|
|
close(mWakeReadPipeFd);
|
||
|
|
close(mWakeWritePipeFd);
|
||
|
|
close(mEpollFd);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Looper::threadDestructor(void *st) {
|
||
|
|
Looper* const self = static_cast<Looper*>(st);
|
||
|
|
if (self != NULL) {
|
||
|
|
self->decStrong((void*)threadDestructor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Looper::setForThread(const sp<Looper>& looper) {
|
||
|
|
sp<Looper> old = getForThread(); // also has side-effect of initializing TLS
|
||
|
|
|
||
|
|
if (looper != NULL) {
|
||
|
|
looper->incStrong((void*)threadDestructor);
|
||
|
|
}
|
||
|
|
|
||
|
|
pthread_setspecific(gTLS, looper.get());
|
||
|
|
|
||
|
|
if (old != NULL) {
|
||
|
|
old->decStrong((void*)threadDestructor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
sp<Looper> Looper::getForThread() {
|
||
|
|
if (!gHaveTLS) {
|
||
|
|
pthread_mutex_lock(&gTLSMutex);
|
||
|
|
if (pthread_key_create(&gTLS, threadDestructor) != 0) {
|
||
|
|
pthread_mutex_unlock(&gTLSMutex);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
gHaveTLS = true;
|
||
|
|
pthread_mutex_unlock(&gTLSMutex);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (Looper*)pthread_getspecific(gTLS);
|
||
|
|
}
|
||
|
|
|
||
|
|
sp<Looper> Looper::prepare(int opts) {
|
||
|
|
bool allowNonCallbacks = opts & ALOOPER_PREPARE_ALLOW_NON_CALLBACKS;
|
||
|
|
sp<Looper> looper = Looper::getForThread();
|
||
|
|
if (looper == NULL) {
|
||
|
|
looper = new Looper(allowNonCallbacks);
|
||
|
|
Looper::setForThread(looper);
|
||
|
|
}
|
||
|
|
if (looper->getAllowNonCallbacks() != allowNonCallbacks) {
|
||
|
|
LOGW("Looper already prepared for this thread with a different value for the "
|
||
|
|
"ALOOPER_PREPARE_ALLOW_NON_CALLBACKS option.");
|
||
|
|
}
|
||
|
|
return looper;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Looper::getAllowNonCallbacks() const {
|
||
|
|
return mAllowNonCallbacks;
|
||
|
|
}
|
||
|
|
|
||
|
|
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
|
||
|
|
int result = 0;
|
||
|
|
for (;;) {
|
||
|
|
while (mResponseIndex < mResponses.size()) {
|
||
|
|
const Response& response = mResponses.itemAt(mResponseIndex++);
|
||
|
|
if (! response.request.callback) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - returning signalled identifier %d: "
|
||
|
|
"fd=%d, events=0x%x, data=%p", this,
|
||
|
|
response.request.ident, response.request.fd,
|
||
|
|
response.events, response.request.data);
|
||
|
|
#endif
|
||
|
|
if (outFd != NULL) *outFd = response.request.fd;
|
||
|
|
if (outEvents != NULL) *outEvents = response.events;
|
||
|
|
if (outData != NULL) *outData = response.request.data;
|
||
|
|
return response.request.ident;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (result != 0) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - returning result %d", this, result);
|
||
|
|
#endif
|
||
|
|
if (outFd != NULL) *outFd = 0;
|
||
|
|
if (outEvents != NULL) *outEvents = NULL;
|
||
|
|
if (outData != NULL) *outData = NULL;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
result = pollInner(timeoutMillis);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int Looper::pollInner(int timeoutMillis) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - waiting: timeoutMillis=%d", this, timeoutMillis);
|
||
|
|
#endif
|
||
|
|
struct epoll_event eventItems[EPOLL_MAX_EVENTS];
|
||
|
|
int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
|
||
|
|
if (eventCount < 0) {
|
||
|
|
if (errno != EINTR) {
|
||
|
|
LOGW("Poll failed with an unexpected error, errno=%d", errno);
|
||
|
|
}
|
||
|
|
return ALOOPER_POLL_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventCount == 0) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - timeout", this);
|
||
|
|
#endif
|
||
|
|
return ALOOPER_POLL_TIMEOUT;
|
||
|
|
}
|
||
|
|
|
||
|
|
int result = ALOOPER_POLL_WAKE;
|
||
|
|
mResponses.clear();
|
||
|
|
mResponseIndex = 0;
|
||
|
|
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - handling events from %d fds", this, eventCount);
|
||
|
|
#endif
|
||
|
|
{ // acquire lock
|
||
|
|
AutoMutex _l(mLock);
|
||
|
|
for (int i = 0; i < eventCount; i++) {
|
||
|
|
int fd = eventItems[i].data.fd;
|
||
|
|
uint32_t epollEvents = eventItems[i].events;
|
||
|
|
if (fd == mWakeReadPipeFd) {
|
||
|
|
if (epollEvents & EPOLLIN) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ pollOnce - awoken", this);
|
||
|
|
#endif
|
||
|
|
char buffer[16];
|
||
|
|
ssize_t nRead;
|
||
|
|
do {
|
||
|
|
nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
|
||
|
|
} while (nRead == sizeof(buffer));
|
||
|
|
} else {
|
||
|
|
LOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ssize_t requestIndex = mRequests.indexOfKey(fd);
|
||
|
|
if (requestIndex >= 0) {
|
||
|
|
int events = 0;
|
||
|
|
if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;
|
||
|
|
if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;
|
||
|
|
if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;
|
||
|
|
if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;
|
||
|
|
|
||
|
|
Response response;
|
||
|
|
response.events = events;
|
||
|
|
response.request = mRequests.valueAt(requestIndex);
|
||
|
|
mResponses.push(response);
|
||
|
|
} else {
|
||
|
|
LOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "
|
||
|
|
"no longer registered.", epollEvents, fd);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (size_t i = 0; i < mResponses.size(); i++) {
|
||
|
|
const Response& response = mResponses.itemAt(i);
|
||
|
|
if (response.request.callback) {
|
||
|
|
#if DEBUG_POLL_AND_WAKE || DEBUG_CALLBACKS
|
||
|
|
LOGD("%p ~ pollOnce - invoking callback: fd=%d, events=0x%x, data=%p", this,
|
||
|
|
response.request.fd, response.events, response.request.data);
|
||
|
|
#endif
|
||
|
|
int callbackResult = response.request.callback(
|
||
|
|
response.request.fd, response.events, response.request.data);
|
||
|
|
if (callbackResult == 0) {
|
||
|
|
removeFd(response.request.fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
result = ALOOPER_POLL_CALLBACK;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
int Looper::pollAll(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
|
||
|
|
if (timeoutMillis <= 0) {
|
||
|
|
int result;
|
||
|
|
do {
|
||
|
|
result = pollOnce(timeoutMillis, outFd, outEvents, outData);
|
||
|
|
} while (result == ALOOPER_POLL_CALLBACK);
|
||
|
|
return result;
|
||
|
|
} else {
|
||
|
|
nsecs_t endTime = systemTime(SYSTEM_TIME_MONOTONIC)
|
||
|
|
+ milliseconds_to_nanoseconds(timeoutMillis);
|
||
|
|
|
||
|
|
for (;;) {
|
||
|
|
int result = pollOnce(timeoutMillis, outFd, outEvents, outData);
|
||
|
|
if (result != ALOOPER_POLL_CALLBACK) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
nsecs_t timeoutNanos = endTime - systemTime(SYSTEM_TIME_MONOTONIC);
|
||
|
|
if (timeoutNanos <= 0) {
|
||
|
|
return ALOOPER_POLL_TIMEOUT;
|
||
|
|
}
|
||
|
|
|
||
|
|
timeoutMillis = int(nanoseconds_to_milliseconds(timeoutNanos + 999999LL));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Looper::wake() {
|
||
|
|
#if DEBUG_POLL_AND_WAKE
|
||
|
|
LOGD("%p ~ wake", this);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ssize_t nWrite = write(mWakeWritePipeFd, "W", 1);
|
||
|
|
if (nWrite != 1) {
|
||
|
|
if (errno != EAGAIN) {
|
||
|
|
LOGW("Could not write wake signal, errno=%d", errno);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int Looper::addFd(int fd, int ident, int events, ALooper_callbackFunc callback, void* data) {
|
||
|
|
#if DEBUG_CALLBACKS
|
||
|
|
LOGD("%p ~ addFd - fd=%d, ident=%d, events=0x%x, callback=%p, data=%p", this, fd, ident,
|
||
|
|
events, callback, data);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
int epollEvents = 0;
|
||
|
|
if (events & ALOOPER_EVENT_INPUT) epollEvents |= EPOLLIN;
|
||
|
|
if (events & ALOOPER_EVENT_OUTPUT) epollEvents |= EPOLLOUT;
|
||
|
|
if (events & ALOOPER_EVENT_ERROR) epollEvents |= EPOLLERR;
|
||
|
|
if (events & ALOOPER_EVENT_HANGUP) epollEvents |= EPOLLHUP;
|
||
|
|
|
||
|
|
if (epollEvents == 0) {
|
||
|
|
LOGE("Invalid attempt to set a callback with no selected poll events.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (! callback) {
|
||
|
|
if (! mAllowNonCallbacks) {
|
||
|
|
LOGE("Invalid attempt to set NULL callback but not allowed for this looper.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ident < 0) {
|
||
|
|
LOGE("Invalid attempt to set NULL callback with ident <= 0.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
{ // acquire lock
|
||
|
|
AutoMutex _l(mLock);
|
||
|
|
|
||
|
|
Request request;
|
||
|
|
request.fd = fd;
|
||
|
|
request.ident = ident;
|
||
|
|
request.callback = callback;
|
||
|
|
request.data = data;
|
||
|
|
|
||
|
|
struct epoll_event eventItem;
|
||
|
|
eventItem.events = epollEvents;
|
||
|
|
eventItem.data.fd = fd;
|
||
|
|
|
||
|
|
ssize_t requestIndex = mRequests.indexOfKey(fd);
|
||
|
|
if (requestIndex < 0) {
|
||
|
|
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
|
||
|
|
if (epollResult < 0) {
|
||
|
|
LOGE("Error adding epoll events for fd %d, errno=%d", fd, errno);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
mRequests.add(fd, request);
|
||
|
|
} else {
|
||
|
|
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, & eventItem);
|
||
|
|
if (epollResult < 0) {
|
||
|
|
LOGE("Error modifying epoll events for fd %d, errno=%d", fd, errno);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
mRequests.replaceValueAt(requestIndex, request);
|
||
|
|
}
|
||
|
|
} // release lock
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
int Looper::removeFd(int fd) {
|
||
|
|
#if DEBUG_CALLBACKS
|
||
|
|
LOGD("%p ~ removeFd - fd=%d", this, fd);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
{ // acquire lock
|
||
|
|
AutoMutex _l(mLock);
|
||
|
|
ssize_t requestIndex = mRequests.indexOfKey(fd);
|
||
|
|
if (requestIndex < 0) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, NULL);
|
||
|
|
if (epollResult < 0) {
|
||
|
|
LOGE("Error removing epoll events for fd %d, errno=%d", fd, errno);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
mRequests.removeItemsAt(requestIndex);
|
||
|
|
} // request lock
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace android
|