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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */
#ifndef dom_ipc_SharedStringMap_h
#define dom_ipc_SharedStringMap_h
#include "mozilla/AutoMemMap.h"
#include "mozilla/Result.h"
#include "mozilla/dom/ipc/StringTable.h"
#include "nsTHashMap.h"
namespace mozilla::dom::ipc {
class SharedStringMapBuilder;
/**
* This class provides a simple, read-only key-value string store, with all
* data packed into a single segment of memory, which can be shared between
* processes.
*
* Look-ups are performed by binary search of a static table in the mapped
* memory region, and all returned strings are literals which reference the
* mapped data. No copies are performed on instantiation or look-up.
*
* Important: The mapped memory created by this class is persistent. Once an
* instance has been initialized, the memory that it allocates can never be
* freed before process shutdown. Do not use it for short-lived mappings.
*/
class SharedStringMap {
using FileDescriptor = mozilla::ipc::FileDescriptor;
public:
/**
* The header at the beginning of the shared memory region describing its
* layout. The layout of the shared memory is as follows:
*
* - Header:
* A Header struct describing the contents of the rest of the memory region.
*
* - Optional alignment padding for Header[].
*
* - Entry[header.mEntryCount]:
* An array of Entry structs, one for each entry in the map. Entries are
* lexocographically sorted by key.
*
* - StringTable<nsCString>:
* A region of flat, null-terminated C strings. Entry key strings are
* encoded as character offsets into this region.
*
* - Optional alignment padding for char16_t[]
*
* - StringTable<nsString>:
* A region of flat, null-terminated UTF-16 strings. Entry value strings are
* encoded as character (*not* byte) offsets into this region.
*/
struct Header {
uint32_t mMagic;
// The number of entries in this map.
uint32_t mEntryCount;
// The raw byte offset of the beginning of the key string table, from the
// start of the shared memory region, and its size in bytes.
size_t mKeyStringsOffset;
size_t mKeyStringsSize;
// The raw byte offset of the beginning of the value string table, from the
// start of the shared memory region, and its size in bytes (*not*
// characters).
size_t mValueStringsOffset;
size_t mValueStringsSize;
};
/**
* Describes a value in the string map, as offsets into the key and value
* string tables.
*/
struct Entry {
// The offset and size of the entry's UTF-8 key in the key string table.
StringTableEntry mKey;
// The offset and size of the entry's UTF-16 value in the value string
// table.
StringTableEntry mValue;
};
NS_INLINE_DECL_REFCOUNTING(SharedStringMap)
// Note: These constructors are infallible on the premise that this class
// is used primarily in cases where it is critical to platform
// functionality.
explicit SharedStringMap(const FileDescriptor&, size_t);
explicit SharedStringMap(SharedStringMapBuilder&&);
/**
* Searches for the given value in the map, and returns true if it exists.
*/
bool Has(const nsCString& aKey);
/**
* Searches for the given value in the map, and, if it exists, returns true
* and places its value in aValue.
*
* The returned value is a literal string which references the mapped memory
* region.
*/
bool Get(const nsCString& aKey, nsAString& aValue);
private:
/**
* Searches for an entry for the given key. If found, returns true, and
* places its index in the entry array in aIndex.
*/
bool Find(const nsCString& aKey, size_t* aIndex);
public:
/**
* Returns the number of entries in the map.
*/
uint32_t Count() const { return EntryCount(); }
/**
* Returns the string entry at the given index. Keys are guaranteed to be
* sorted lexographically.
*
* The given index *must* be less than the value returned by Count().
*
* The returned value is a literal string which references the mapped memory
* region.
*/
nsCString GetKeyAt(uint32_t aIndex) const {
MOZ_ASSERT(aIndex < Count());
return KeyTable().Get(Entries()[aIndex].mKey);
}
/**
* Returns the string value for the entry at the given index.
*
* The given index *must* be less than the value returned by Count().
*
* The returned value is a literal string which references the mapped memory
* region.
*/
nsString GetValueAt(uint32_t aIndex) const {
MOZ_ASSERT(aIndex < Count());
return ValueTable().Get(Entries()[aIndex].mValue);
}
/**
* Returns a copy of the read-only file descriptor which backs the shared
* memory region for this map. The file descriptor may be passed between
* processes, and used to construct new instances of SharedStringMap with
* the same data as this instance.
*/
FileDescriptor CloneFileDescriptor() const;
size_t MapSize() const { return mMap.size(); }
protected:
~SharedStringMap() = default;
private:
// Type-safe getters for values in the shared memory region:
const Header& GetHeader() const { return mMap.get<Header>()[0]; }
RangedPtr<const Entry> Entries() const {
return {reinterpret_cast<const Entry*>(&GetHeader() + 1), EntryCount()};
}
uint32_t EntryCount() const { return GetHeader().mEntryCount; }
StringTable<nsCString> KeyTable() const {
auto& header = GetHeader();
return {{&mMap.get<uint8_t>()[header.mKeyStringsOffset],
header.mKeyStringsSize}};
}
StringTable<nsString> ValueTable() const {
auto& header = GetHeader();
return {{&mMap.get<uint8_t>()[header.mValueStringsOffset],
header.mValueStringsSize}};
}
loader::AutoMemMap mMap;
};
/**
* A helper class which builds the contiguous look-up table used by
* SharedStringMap. Each key-value pair in the final map is added to the
* builder, before it is finalized and transformed into a snapshot.
*/
class MOZ_RAII SharedStringMapBuilder {
public:
SharedStringMapBuilder() = default;
/**
* Adds a key-value pair to the map.
*/
void Add(const nsCString& aKey, const nsString& aValue);
/**
* Finalizes the binary representation of the map, writes it to a shared
* memory region, and then initializes the given AutoMemMap with a reference
* to the read-only copy of it.
*/
Result<Ok, nsresult> Finalize(loader::AutoMemMap& aMap);
private:
using Entry = SharedStringMap::Entry;
StringTableBuilder<nsCStringHashKey, nsCString> mKeyTable;
StringTableBuilder<nsStringHashKey, nsString> mValueTable;
nsTHashMap<nsCStringHashKey, Entry> mEntries;
};
} // namespace mozilla::dom::ipc
#endif // dom_ipc_SharedStringMap_h
|
