| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "FMQ_EventFlags" |
| |
| #include <linux/futex.h> |
| #include <string.h> |
| #include <sys/mman.h> |
| #include <sys/syscall.h> |
| #include <unistd.h> |
| |
| #include <new> |
| |
| #include <fmq/EventFlag.h> |
| #include <utils/Log.h> |
| #include <utils/SystemClock.h> |
| |
| namespace android { |
| namespace hardware { |
| |
| status_t EventFlag::createEventFlag(int fd, off_t offset, EventFlag** flag) { |
| if (flag == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| status_t status = NO_MEMORY; |
| *flag = nullptr; |
| |
| EventFlag* evFlag = new (std::nothrow) EventFlag(fd, offset, &status); |
| if (evFlag != nullptr) { |
| if (status == NO_ERROR) { |
| *flag = evFlag; |
| } else { |
| delete evFlag; |
| } |
| } |
| |
| return status; |
| } |
| |
| status_t EventFlag::createEventFlag(std::atomic<uint32_t>* fwAddr, |
| EventFlag** flag) { |
| if (flag == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| status_t status = NO_MEMORY; |
| *flag = nullptr; |
| |
| EventFlag* evFlag = new (std::nothrow) EventFlag(fwAddr, &status); |
| if (evFlag != nullptr) { |
| if (status == NO_ERROR) { |
| *flag = evFlag; |
| } else { |
| delete evFlag; |
| } |
| } |
| |
| return status; |
| } |
| |
| /* |
| * mmap memory for the futex word |
| */ |
| EventFlag::EventFlag(int fd, off_t offset, status_t* status) { |
| mEfWordPtr = static_cast<std::atomic<uint32_t>*>(mmap(NULL, |
| sizeof(std::atomic<uint32_t>), |
| PROT_READ | PROT_WRITE, |
| MAP_SHARED, fd, offset)); |
| mEfWordNeedsUnmapping = true; |
| if (mEfWordPtr != MAP_FAILED) { |
| *status = NO_ERROR; |
| } else { |
| *status = -errno; |
| ALOGE("Attempt to mmap event flag word failed: %s\n", strerror(errno)); |
| } |
| } |
| |
| /* |
| * Use this constructor if we already know where the futex word for |
| * the EventFlag group lives. |
| */ |
| EventFlag::EventFlag(std::atomic<uint32_t>* fwAddr, status_t* status) { |
| *status = NO_ERROR; |
| if (fwAddr == nullptr) { |
| *status = BAD_VALUE; |
| } else { |
| mEfWordPtr = fwAddr; |
| } |
| } |
| |
| /* |
| * Set the specified bits of the futex word here and wake up any |
| * thread waiting on any of the bits. |
| */ |
| status_t EventFlag::wake(uint32_t bitmask) { |
| /* |
| * Return early if there are no set bits in bitmask. |
| */ |
| if (bitmask == 0) { |
| return NO_ERROR; |
| } |
| |
| status_t status = NO_ERROR; |
| uint32_t old = std::atomic_fetch_or(mEfWordPtr, bitmask); |
| /* |
| * No need to call FUTEX_WAKE_BITSET if there were deferred wakes |
| * already available for all set bits from bitmask. |
| */ |
| if ((~old & bitmask) != 0) { |
| int ret = syscall(__NR_futex, mEfWordPtr, FUTEX_WAKE_BITSET, |
| INT_MAX, NULL, NULL, bitmask); |
| if (ret == -1) { |
| status = -errno; |
| ALOGE("Error in event flag wake attempt: %s\n", strerror(errno)); |
| } |
| } |
| return status; |
| } |
| |
| /* |
| * Wait for any of the bits in the bitmask to be set |
| * and return which bits caused the return. |
| */ |
| status_t EventFlag::waitHelper(uint32_t bitmask, uint32_t* efState, int64_t timeoutNanoSeconds) { |
| /* |
| * Return early if there are no set bits in bitmask. |
| */ |
| if (bitmask == 0 || efState == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| status_t status = NO_ERROR; |
| uint32_t old = std::atomic_fetch_and(mEfWordPtr, ~bitmask); |
| uint32_t setBits = old & bitmask; |
| /* |
| * If there was a deferred wake available, no need to call FUTEX_WAIT_BITSET. |
| */ |
| if (setBits != 0) { |
| *efState = setBits; |
| return status; |
| } |
| |
| uint32_t efWord = old & ~bitmask; |
| /* |
| * The syscall will put the thread to sleep only |
| * if the futex word still contains the expected |
| * value i.e. efWord. If the futex word contents have |
| * changed, it fails with the error EAGAIN; If a timeout |
| * is specified and exceeded the syscall fails with ETIMEDOUT. |
| */ |
| int ret = 0; |
| if (timeoutNanoSeconds) { |
| struct timespec waitTimeAbsolute; |
| addNanosecondsToCurrentTime(timeoutNanoSeconds, &waitTimeAbsolute); |
| |
| ret = syscall(__NR_futex, mEfWordPtr, FUTEX_WAIT_BITSET, |
| efWord, &waitTimeAbsolute, NULL, bitmask); |
| } else { |
| ret = syscall(__NR_futex, mEfWordPtr, FUTEX_WAIT_BITSET, efWord, NULL, NULL, bitmask); |
| } |
| if (ret == -1) { |
| status = -errno; |
| if (status != -EAGAIN && status != -ETIMEDOUT) { |
| ALOGE("Event flag wait was unsuccessful: %s\n", strerror(errno)); |
| } |
| *efState = 0; |
| } else { |
| old = std::atomic_fetch_and(mEfWordPtr, ~bitmask); |
| *efState = old & bitmask; |
| |
| if (*efState == 0) { |
| /* Return -EINTR for a spurious wakeup */ |
| status = -EINTR; |
| } |
| } |
| return status; |
| } |
| |
| /* |
| * Wait for any of the bits in the bitmask to be set |
| * and return which bits caused the return. If 'retry' |
| * is true, wait again on a spurious wake-up. |
| */ |
| status_t EventFlag::wait(uint32_t bitmask, |
| uint32_t* efState, |
| int64_t timeoutNanoSeconds, |
| bool retry) { |
| if (!retry) { |
| return waitHelper(bitmask, efState, timeoutNanoSeconds); |
| } |
| |
| bool shouldTimeOut = timeoutNanoSeconds != 0; |
| int64_t prevTimeNs = shouldTimeOut ? android::elapsedRealtimeNano() : 0; |
| status_t status; |
| while (true) { |
| if (shouldTimeOut) { |
| int64_t currentTimeNs = android::elapsedRealtimeNano(); |
| /* |
| * Decrement TimeOutNanos to account for the time taken to complete the last |
| * iteration of the while loop. |
| */ |
| timeoutNanoSeconds -= currentTimeNs - prevTimeNs; |
| prevTimeNs = currentTimeNs; |
| if (timeoutNanoSeconds <= 0) { |
| status = -ETIMEDOUT; |
| *efState = 0; |
| break; |
| } |
| } |
| |
| status = waitHelper(bitmask, efState, timeoutNanoSeconds); |
| if ((status != -EAGAIN) && (status != -EINTR)) { |
| break; |
| } |
| } |
| return status; |
| } |
| |
| status_t EventFlag::unmapEventFlagWord(std::atomic<uint32_t>* efWordPtr, |
| bool* efWordNeedsUnmapping) { |
| status_t status = NO_ERROR; |
| if (*efWordNeedsUnmapping) { |
| int ret = munmap(efWordPtr, sizeof(std::atomic<uint32_t>)); |
| if (ret != 0) { |
| status = -errno; |
| ALOGE("Error in deleting event flag group: %s\n", strerror(errno)); |
| } |
| *efWordNeedsUnmapping = false; |
| } |
| return status; |
| } |
| |
| status_t EventFlag::deleteEventFlag(EventFlag** evFlag) { |
| if (evFlag == nullptr || *evFlag == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| status_t status = unmapEventFlagWord((*evFlag)->mEfWordPtr, |
| &(*evFlag)->mEfWordNeedsUnmapping); |
| delete *evFlag; |
| *evFlag = nullptr; |
| |
| return status; |
| } |
| |
| void EventFlag::addNanosecondsToCurrentTime(int64_t nanoSeconds, struct timespec* waitTime) { |
| static constexpr int64_t kNanosPerSecond = 1000000000; |
| |
| clock_gettime(CLOCK_MONOTONIC, waitTime); |
| waitTime->tv_sec += nanoSeconds / kNanosPerSecond; |
| waitTime->tv_nsec += nanoSeconds % kNanosPerSecond; |
| |
| if (waitTime->tv_nsec >= kNanosPerSecond) { |
| waitTime->tv_sec++; |
| waitTime->tv_nsec -= kNanosPerSecond; |
| } |
| } |
| |
| EventFlag::~EventFlag() { |
| unmapEventFlagWord(mEfWordPtr, &mEfWordNeedsUnmapping); |
| } |
| |
| } // namespace hardware |
| } // namespace android |
