1 /*
2 * Copyright (C) 2005 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
17 #define LOG_TAG "sharedbuffer"
18
19 #include "SharedBuffer.h"
20
21 #include <stdlib.h>
22 #include <string.h>
23
24 #include <log/log.h>
25
26 // ---------------------------------------------------------------------------
27
28 namespace android {
29
alloc(size_t size)30 SharedBuffer* SharedBuffer::alloc(size_t size)
31 {
32 // Don't overflow if the combined size of the buffer / header is larger than
33 // size_max.
34 LOG_ALWAYS_FATAL_IF((size >= (SIZE_MAX - sizeof(SharedBuffer))),
35 "Invalid buffer size %zu", size);
36
37 SharedBuffer* sb = static_cast<SharedBuffer *>(malloc(sizeof(SharedBuffer) + size));
38 if (sb) {
39 // Should be std::atomic_init(&sb->mRefs, 1);
40 // But that generates a warning with some compilers.
41 // The following is OK on Android-supported platforms.
42 sb->mRefs.store(1, std::memory_order_relaxed);
43 sb->mSize = size;
44 }
45 return sb;
46 }
47
48
dealloc(const SharedBuffer * released)49 void SharedBuffer::dealloc(const SharedBuffer* released)
50 {
51 free(const_cast<SharedBuffer*>(released));
52 }
53
edit() const54 SharedBuffer* SharedBuffer::edit() const
55 {
56 if (onlyOwner()) {
57 return const_cast<SharedBuffer*>(this);
58 }
59 SharedBuffer* sb = alloc(mSize);
60 if (sb) {
61 memcpy(sb->data(), data(), size());
62 release();
63 }
64 return sb;
65 }
66
editResize(size_t newSize) const67 SharedBuffer* SharedBuffer::editResize(size_t newSize) const
68 {
69 if (onlyOwner()) {
70 SharedBuffer* buf = const_cast<SharedBuffer*>(this);
71 if (buf->mSize == newSize) return buf;
72 // Don't overflow if the combined size of the new buffer / header is larger than
73 // size_max.
74 LOG_ALWAYS_FATAL_IF((newSize >= (SIZE_MAX - sizeof(SharedBuffer))),
75 "Invalid buffer size %zu", newSize);
76
77 buf = (SharedBuffer*)realloc(buf, sizeof(SharedBuffer) + newSize);
78 if (buf != nullptr) {
79 buf->mSize = newSize;
80 return buf;
81 }
82 }
83 SharedBuffer* sb = alloc(newSize);
84 if (sb) {
85 const size_t mySize = mSize;
86 memcpy(sb->data(), data(), newSize < mySize ? newSize : mySize);
87 release();
88 }
89 return sb;
90 }
91
attemptEdit() const92 SharedBuffer* SharedBuffer::attemptEdit() const
93 {
94 if (onlyOwner()) {
95 return const_cast<SharedBuffer*>(this);
96 }
97 return nullptr;
98 }
99
reset(size_t new_size) const100 SharedBuffer* SharedBuffer::reset(size_t new_size) const
101 {
102 // cheap-o-reset.
103 SharedBuffer* sb = alloc(new_size);
104 if (sb) {
105 release();
106 }
107 return sb;
108 }
109
acquire() const110 void SharedBuffer::acquire() const {
111 mRefs.fetch_add(1, std::memory_order_relaxed);
112 }
113
release(uint32_t flags) const114 int32_t SharedBuffer::release(uint32_t flags) const
115 {
116 const bool useDealloc = ((flags & eKeepStorage) == 0);
117 if (onlyOwner()) {
118 // Since we're the only owner, our reference count goes to zero.
119 mRefs.store(0, std::memory_order_relaxed);
120 if (useDealloc) {
121 dealloc(this);
122 }
123 // As the only owner, our previous reference count was 1.
124 return 1;
125 }
126 // There's multiple owners, we need to use an atomic decrement.
127 int32_t prevRefCount = mRefs.fetch_sub(1, std::memory_order_release);
128 if (prevRefCount == 1) {
129 // We're the last reference, we need the acquire fence.
130 atomic_thread_fence(std::memory_order_acquire);
131 if (useDealloc) {
132 dealloc(this);
133 }
134 }
135 return prevRefCount;
136 }
137
138
139 }; // namespace android
140