1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "VolatileBuffer.h"
#include "mozilla/Assertions.h"
#include "mozilla/mozalloc.h"
#include <fcntl.h>
#include <linux/ashmem.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#ifdef MOZ_MEMORY
extern "C" int posix_memalign(void** memptr, size_t alignment, size_t size);
#endif
#define MIN_VOLATILE_ALLOC_SIZE 8192
namespace mozilla {
VolatileBuffer::VolatileBuffer()
: mMutex("VolatileBuffer")
, mBuf(nullptr)
, mSize(0)
, mLockCount(0)
, mFd(-1)
{
}
bool
VolatileBuffer::Init(size_t aSize, size_t aAlignment)
{
MOZ_ASSERT(!mSize && !mBuf, "Init called twice");
MOZ_ASSERT(!(aAlignment % sizeof(void *)),
"Alignment must be multiple of pointer size");
mSize = aSize;
if (aSize < MIN_VOLATILE_ALLOC_SIZE) {
goto heap_alloc;
}
mFd = open("/" ASHMEM_NAME_DEF, O_RDWR);
if (mFd < 0) {
goto heap_alloc;
}
if (ioctl(mFd, ASHMEM_SET_SIZE, mSize) < 0) {
goto heap_alloc;
}
mBuf = mmap(nullptr, mSize, PROT_READ | PROT_WRITE, MAP_SHARED, mFd, 0);
if (mBuf != MAP_FAILED) {
return true;
}
heap_alloc:
mBuf = nullptr;
if (mFd >= 0) {
close(mFd);
mFd = -1;
}
#ifdef MOZ_MEMORY
posix_memalign(&mBuf, aAlignment, aSize);
#else
mBuf = memalign(aAlignment, aSize);
#endif
return !!mBuf;
}
VolatileBuffer::~VolatileBuffer()
{
MOZ_ASSERT(mLockCount == 0, "Being destroyed with non-zero lock count?");
if (OnHeap()) {
free(mBuf);
} else {
munmap(mBuf, mSize);
close(mFd);
}
}
bool
VolatileBuffer::Lock(void** aBuf)
{
MutexAutoLock lock(mMutex);
MOZ_ASSERT(mBuf, "Attempting to lock an uninitialized VolatileBuffer");
*aBuf = mBuf;
if (++mLockCount > 1 || OnHeap()) {
return true;
}
// Zero offset and zero length means we want to pin/unpin the entire thing.
struct ashmem_pin pin = { 0, 0 };
return ioctl(mFd, ASHMEM_PIN, &pin) == ASHMEM_NOT_PURGED;
}
void
VolatileBuffer::Unlock()
{
MutexAutoLock lock(mMutex);
MOZ_ASSERT(mLockCount > 0, "VolatileBuffer unlocked too many times!");
if (--mLockCount || OnHeap()) {
return;
}
struct ashmem_pin pin = { 0, 0 };
ioctl(mFd, ASHMEM_UNPIN, &pin);
}
bool
VolatileBuffer::OnHeap() const
{
return mFd < 0;
}
size_t
VolatileBuffer::HeapSizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
{
return OnHeap() ? aMallocSizeOf(mBuf) : 0;
}
size_t
VolatileBuffer::NonHeapSizeOfExcludingThis() const
{
if (OnHeap()) {
return 0;
}
return (mSize + (PAGE_SIZE - 1)) & PAGE_MASK;
}
} // namespace mozilla
|
