Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Brian Anderson | 175a720 | 2016-10-10 16:52:56 -0700 | [diff] [blame] | 17 | #include <ui/Fence.h> |
| 18 | |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 19 | #define LOG_TAG "Fence" |
| 20 | #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| 21 | //#define LOG_NDEBUG 0 |
| 22 | |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 23 | // We would eliminate the non-conforming zero-length array, but we can't since |
| 24 | // this is effectively included from the Linux kernel |
| 25 | #pragma clang diagnostic push |
| 26 | #pragma clang diagnostic ignored "-Wzero-length-array" |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 27 | #include <sync/sync.h> |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 28 | #pragma clang diagnostic pop |
| 29 | |
Brian Anderson | 175a720 | 2016-10-10 16:52:56 -0700 | [diff] [blame] | 30 | #include <sys/types.h> |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 31 | #include <unistd.h> |
| 32 | #include <utils/Log.h> |
Brian Anderson | 175a720 | 2016-10-10 16:52:56 -0700 | [diff] [blame] | 33 | #include <utils/String8.h> |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 34 | #include <utils/Trace.h> |
| 35 | |
| 36 | namespace android { |
| 37 | |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 38 | const sp<Fence> Fence::NO_FENCE = sp<Fence>(new Fence); |
Jesse Hall | ef19414 | 2012-06-14 14:45:17 -0700 | [diff] [blame] | 39 | |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 40 | Fence::Fence(int fenceFd) : |
| 41 | mFenceFd(fenceFd) { |
| 42 | } |
| 43 | |
Chia-I Wu | df1badd | 2017-12-27 11:10:20 -0800 | [diff] [blame] | 44 | Fence::Fence(base::unique_fd fenceFd) : |
| 45 | mFenceFd(std::move(fenceFd)) { |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 46 | } |
| 47 | |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 48 | status_t Fence::wait(int timeout) { |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 49 | ATRACE_CALL(); |
| 50 | if (mFenceFd == -1) { |
| 51 | return NO_ERROR; |
| 52 | } |
Mathias Agopian | b5c9dcd | 2012-10-09 14:38:19 -0700 | [diff] [blame] | 53 | int err = sync_wait(mFenceFd, timeout); |
| 54 | return err < 0 ? -errno : status_t(NO_ERROR); |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 55 | } |
| 56 | |
Mathias Agopian | ea74d3b | 2013-05-16 18:03:22 -0700 | [diff] [blame] | 57 | status_t Fence::waitForever(const char* logname) { |
Jesse Hall | ba607d5 | 2012-10-01 14:05:20 -0700 | [diff] [blame] | 58 | ATRACE_CALL(); |
| 59 | if (mFenceFd == -1) { |
| 60 | return NO_ERROR; |
| 61 | } |
Dan Stoza | d318240 | 2014-11-17 12:03:59 -0800 | [diff] [blame] | 62 | int warningTimeout = 3000; |
Jesse Hall | ba607d5 | 2012-10-01 14:05:20 -0700 | [diff] [blame] | 63 | int err = sync_wait(mFenceFd, warningTimeout); |
Mathias Agopian | b5c9dcd | 2012-10-09 14:38:19 -0700 | [diff] [blame] | 64 | if (err < 0 && errno == ETIME) { |
Iris Chang | d174e38 | 2019-12-04 15:34:18 +0800 | [diff] [blame^] | 65 | ALOGE("waitForever: %s: fence %d didn't signal in %u ms", logname, mFenceFd.get(), |
| 66 | warningTimeout); |
| 67 | |
| 68 | struct sync_file_info* finfo = sync_file_info(mFenceFd); |
| 69 | if (finfo) { |
| 70 | // status: active(0) signaled(1) error(<0) |
| 71 | ALOGI("waitForever: fence(%s) status(%d)", finfo->name, finfo->status); |
| 72 | |
| 73 | struct sync_fence_info* pinfo = sync_get_fence_info(finfo); |
| 74 | for (uint32_t i = 0; i < finfo->num_fences; i++) { |
| 75 | uint64_t ts_sec = pinfo[i].timestamp_ns / 1000000000LL; |
| 76 | uint64_t ts_usec = (pinfo[i].timestamp_ns % 1000000000LL) / 1000LL; |
| 77 | |
| 78 | ALOGI("waitForever: sync point: timeline(%s) drv(%s) status(%d) timestamp(%" PRIu64 |
| 79 | ".%06" PRIu64 ")", |
| 80 | pinfo[i].obj_name, pinfo[i].driver_name, pinfo[i].status, ts_sec, ts_usec); |
| 81 | } |
| 82 | sync_file_info_free(finfo); |
| 83 | } |
| 84 | |
Jesse Hall | ba607d5 | 2012-10-01 14:05:20 -0700 | [diff] [blame] | 85 | err = sync_wait(mFenceFd, TIMEOUT_NEVER); |
| 86 | } |
Mathias Agopian | b5c9dcd | 2012-10-09 14:38:19 -0700 | [diff] [blame] | 87 | return err < 0 ? -errno : status_t(NO_ERROR); |
Jesse Hall | ba607d5 | 2012-10-01 14:05:20 -0700 | [diff] [blame] | 88 | } |
| 89 | |
Matthew Bouyack | fd4c8c3 | 2016-10-07 14:26:47 -0700 | [diff] [blame] | 90 | sp<Fence> Fence::merge(const char* name, const sp<Fence>& f1, |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 91 | const sp<Fence>& f2) { |
| 92 | ATRACE_CALL(); |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 93 | int result; |
| 94 | // Merge the two fences. In the case where one of the fences is not a |
| 95 | // valid fence (e.g. NO_FENCE) we merge the one valid fence with itself so |
| 96 | // that a new fence with the given name is created. |
| 97 | if (f1->isValid() && f2->isValid()) { |
Matthew Bouyack | fd4c8c3 | 2016-10-07 14:26:47 -0700 | [diff] [blame] | 98 | result = sync_merge(name, f1->mFenceFd, f2->mFenceFd); |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 99 | } else if (f1->isValid()) { |
Matthew Bouyack | fd4c8c3 | 2016-10-07 14:26:47 -0700 | [diff] [blame] | 100 | result = sync_merge(name, f1->mFenceFd, f1->mFenceFd); |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 101 | } else if (f2->isValid()) { |
Matthew Bouyack | fd4c8c3 | 2016-10-07 14:26:47 -0700 | [diff] [blame] | 102 | result = sync_merge(name, f2->mFenceFd, f2->mFenceFd); |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 103 | } else { |
| 104 | return NO_FENCE; |
| 105 | } |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 106 | if (result == -1) { |
Mathias Agopian | d83d67b | 2012-07-30 15:10:35 -0700 | [diff] [blame] | 107 | status_t err = -errno; |
| 108 | ALOGE("merge: sync_merge(\"%s\", %d, %d) returned an error: %s (%d)", |
Chia-I Wu | df1badd | 2017-12-27 11:10:20 -0800 | [diff] [blame] | 109 | name, f1->mFenceFd.get(), f2->mFenceFd.get(), |
Mathias Agopian | d83d67b | 2012-07-30 15:10:35 -0700 | [diff] [blame] | 110 | strerror(-err), err); |
Jesse Hall | ef19414 | 2012-06-14 14:45:17 -0700 | [diff] [blame] | 111 | return NO_FENCE; |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 112 | } |
| 113 | return sp<Fence>(new Fence(result)); |
| 114 | } |
| 115 | |
Matthew Bouyack | fd4c8c3 | 2016-10-07 14:26:47 -0700 | [diff] [blame] | 116 | sp<Fence> Fence::merge(const String8& name, const sp<Fence>& f1, |
| 117 | const sp<Fence>& f2) { |
| 118 | return merge(name.string(), f1, f2); |
| 119 | } |
| 120 | |
Jesse Hall | f9783af | 2012-06-25 13:54:23 -0700 | [diff] [blame] | 121 | int Fence::dup() const { |
| 122 | return ::dup(mFenceFd); |
| 123 | } |
| 124 | |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 125 | nsecs_t Fence::getSignalTime() const { |
| 126 | if (mFenceFd == -1) { |
Brian Anderson | 221de2a | 2016-09-21 16:53:28 -0700 | [diff] [blame] | 127 | return SIGNAL_TIME_INVALID; |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 128 | } |
| 129 | |
Jesse Hall | e158ca7 | 2018-05-18 15:58:23 -0700 | [diff] [blame] | 130 | struct sync_file_info* finfo = sync_file_info(mFenceFd); |
Yi Kong | 48d7608 | 2019-03-24 02:01:06 -0700 | [diff] [blame] | 131 | if (finfo == nullptr) { |
Jesse Hall | e158ca7 | 2018-05-18 15:58:23 -0700 | [diff] [blame] | 132 | ALOGE("sync_file_info returned NULL for fd %d", mFenceFd.get()); |
Brian Anderson | 221de2a | 2016-09-21 16:53:28 -0700 | [diff] [blame] | 133 | return SIGNAL_TIME_INVALID; |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 134 | } |
| 135 | if (finfo->status != 1) { |
Jesse Hall | e158ca7 | 2018-05-18 15:58:23 -0700 | [diff] [blame] | 136 | sync_file_info_free(finfo); |
Brian Anderson | 221de2a | 2016-09-21 16:53:28 -0700 | [diff] [blame] | 137 | return SIGNAL_TIME_PENDING; |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 138 | } |
| 139 | |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 140 | uint64_t timestamp = 0; |
Jesse Hall | e158ca7 | 2018-05-18 15:58:23 -0700 | [diff] [blame] | 141 | struct sync_fence_info* pinfo = sync_get_fence_info(finfo); |
| 142 | for (size_t i = 0; i < finfo->num_fences; i++) { |
| 143 | if (pinfo[i].timestamp_ns > timestamp) { |
| 144 | timestamp = pinfo[i].timestamp_ns; |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 145 | } |
| 146 | } |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 147 | |
Jesse Hall | e158ca7 | 2018-05-18 15:58:23 -0700 | [diff] [blame] | 148 | sync_file_info_free(finfo); |
Jamie Gennis | 82dbc74 | 2012-11-08 19:23:28 -0800 | [diff] [blame] | 149 | return nsecs_t(timestamp); |
| 150 | } |
| 151 | |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 152 | size_t Fence::getFlattenedSize() const { |
Dan Stoza | 6fbefbb | 2015-03-23 13:46:14 -0700 | [diff] [blame] | 153 | return 4; |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | size_t Fence::getFdCount() const { |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 157 | return isValid() ? 1 : 0; |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 160 | status_t Fence::flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const { |
| 161 | if (size < getFlattenedSize() || count < getFdCount()) { |
| 162 | return NO_MEMORY; |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 163 | } |
Dan Stoza | 6fbefbb | 2015-03-23 13:46:14 -0700 | [diff] [blame] | 164 | // Cast to uint32_t since the size of a size_t can vary between 32- and |
| 165 | // 64-bit processes |
| 166 | FlattenableUtils::write(buffer, size, static_cast<uint32_t>(getFdCount())); |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 167 | if (isValid()) { |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 168 | *fds++ = mFenceFd; |
| 169 | count--; |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 170 | } |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 171 | return NO_ERROR; |
| 172 | } |
| 173 | |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 174 | status_t Fence::unflatten(void const*& buffer, size_t& size, int const*& fds, size_t& count) { |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 175 | if (mFenceFd != -1) { |
| 176 | // Don't unflatten if we already have a valid fd. |
| 177 | return INVALID_OPERATION; |
| 178 | } |
| 179 | |
Chris Forbes | 9809602 | 2017-05-10 13:12:00 -0700 | [diff] [blame] | 180 | if (size < getFlattenedSize()) { |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 181 | return NO_MEMORY; |
| 182 | } |
| 183 | |
Colin Cross | 288f2ef | 2014-04-14 18:43:12 -0700 | [diff] [blame] | 184 | uint32_t numFds; |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 185 | FlattenableUtils::read(buffer, size, numFds); |
| 186 | |
| 187 | if (numFds > 1) { |
| 188 | return BAD_VALUE; |
| 189 | } |
| 190 | |
| 191 | if (count < numFds) { |
| 192 | return NO_MEMORY; |
| 193 | } |
| 194 | |
| 195 | if (numFds) { |
Chia-I Wu | df1badd | 2017-12-27 11:10:20 -0800 | [diff] [blame] | 196 | mFenceFd.reset(*fds++); |
Mathias Agopian | e142428 | 2013-07-29 21:24:40 -0700 | [diff] [blame] | 197 | count--; |
Jamie Gennis | 1df8c34 | 2012-12-20 14:05:45 -0800 | [diff] [blame] | 198 | } |
| 199 | |
Jamie Gennis | f25e183 | 2012-06-13 16:31:43 -0700 | [diff] [blame] | 200 | return NO_ERROR; |
| 201 | } |
| 202 | |
| 203 | } // namespace android |