1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sync_fence.h"
17
18 #include <libsync.h>
19 #include <unistd.h>
20 #include <errno.h>
21 #include <securec.h>
22
23 #include "hilog/log.h"
24
25 namespace OHOS {
26 using namespace OHOS::HiviewDFX;
27
28 namespace {
29 constexpr HiLogLabel LABEL = { LOG_CORE, 0xD001400, "SyncFence" };
30 constexpr int32_t INVALID_FD = -1;
31 constexpr int64_t INVALID_TIMESTAMP = -1;
32
33 #define SYNC_IOC_FILE_INFO _IOWR(SYNC_IOC_MAGIC, 4, struct SyncFileInfo)
34 } // namespace
35
36 const sptr<SyncFence> SyncFence::INVALID_FENCE = sptr<SyncFence>(new SyncFence(INVALID_FD));
37
SyncFence(int32_t fenceFd)38 SyncFence::SyncFence(int32_t fenceFd) : fenceFd_(fenceFd)
39 {
40 HiLog::Debug(LABEL, "%{public}s fenceFd: %{public}d", __func__, fenceFd_.Get());
41 }
42
~SyncFence()43 SyncFence::~SyncFence()
44 {
45 }
46
Wait(uint32_t timeout)47 int32_t SyncFence::Wait(uint32_t timeout)
48 {
49 if (fenceFd_ < 0) {
50 return 0;
51 }
52
53 int32_t err = sync_wait(fenceFd_, timeout);
54 return err < 0 ? -errno : 0;
55 }
56
MergeFence(const std::string & name,const sptr<SyncFence> & fence1,const sptr<SyncFence> & fence2)57 sptr<SyncFence> SyncFence::MergeFence(const std::string &name,
58 const sptr<SyncFence>& fence1, const sptr<SyncFence>& fence2)
59 {
60 int32_t newFenceFd = INVALID_FD;
61 int32_t fenceFd1 = fence1->fenceFd_;
62 int32_t fenceFd2 = fence2->fenceFd_;
63
64 if (fenceFd1 >= 0 && fenceFd2 >= 0) {
65 newFenceFd = sync_merge(name.c_str(), fenceFd1, fenceFd2);
66 } else if (fenceFd1 >= 0) {
67 newFenceFd = sync_merge(name.c_str(), fenceFd1, fenceFd1);
68 } else if (fenceFd2 >= 0) {
69 newFenceFd = sync_merge(name.c_str(), fenceFd2, fenceFd2);
70 } else {
71 return INVALID_FENCE;
72 }
73
74 if (newFenceFd == INVALID_FD) {
75 HiLog::Error(LABEL, "sync_merge(%{public}s) failed, error: %{public}s (%{public}d)",
76 name.c_str(), strerror(errno), errno);
77 return INVALID_FENCE;
78 }
79
80 return sptr<SyncFence>(new SyncFence(newFenceFd));
81 }
82
SyncFileReadTimestamp()83 int64_t SyncFence::SyncFileReadTimestamp()
84 {
85 struct SyncFileInfo fileInfo;
86 struct SyncFenceInfo fenceInfo;
87
88 (void)memset_s(&fileInfo, sizeof(struct SyncFileInfo), 0, sizeof(struct SyncFileInfo));
89 (void)memset_s(&fenceInfo, sizeof(struct SyncFenceInfo), 0, sizeof(struct SyncFenceInfo));
90
91 fileInfo.syncFenceInfo_ = (uint64_t)(uintptr_t)&fenceInfo;
92 fileInfo.numFences_ = 1;
93
94 int32_t ret = ioctl(fenceFd_, SYNC_IOC_FILE_INFO, &fileInfo);
95 if (ret < 0) {
96 HiLog::Error(LABEL, "SyncFileReadTimestamp ioctl failed, ret: %{public}d", ret);
97 return INVALID_TIMESTAMP;
98 }
99
100 return static_cast<int64_t>(fenceInfo.timestampNs_);
101 }
102
Dup() const103 int32_t SyncFence::Dup() const
104 {
105 return ::dup(fenceFd_);
106 }
107
Get() const108 int32_t SyncFence::Get() const
109 {
110 return fenceFd_;
111 }
112
113 } // namespace OHOS
114