[9085df]: mozglue / linker / Mappable.h Maximize Restore History

Download this file

Mappable.h    275 lines (227 with data), 7.9 kB

  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
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
/* 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 Mappable_h
#define Mappable_h
#include <sys/types.h>
#include <pthread.h>
#include "Zip.h"
#include "SeekableZStream.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Scoped.h"
#include "zlib.h"
/**
* Abstract class to handle mmap()ing from various kind of entities, such as
* plain files or Zip entries. The virtual members are meant to act as the
* equivalent system functions, with a few differences:
* - mapped memory is always MAP_PRIVATE, even though a given implementation
* may use something different internally.
* - memory after length and up to the end of the corresponding page is nulled
* out.
*/
class Mappable
{
public:
virtual ~Mappable() { }
virtual void *mmap(const void *addr, size_t length, int prot, int flags,
off_t offset) = 0;
enum Kind {
MAPPABLE_FILE,
MAPPABLE_EXTRACT_FILE,
MAPPABLE_DEFLATE,
MAPPABLE_SEEKABLE_ZSTREAM
};
virtual Kind GetKind() const = 0;
private:
virtual void munmap(void *addr, size_t length) {
::munmap(addr, length);
}
/* Limit use of Mappable::munmap to classes that keep track of the address
* and size of the mapping. This allows to ignore ::munmap return value. */
friend class Mappable1stPagePtr;
friend class LibHandle;
public:
/**
* Ensures the availability of the memory pages for the page(s) containing
* the given address. Returns whether the pages were successfully made
* available.
*/
virtual bool ensure(const void *addr) { return true; }
/**
* Indicate to a Mappable instance that no further mmap is going to happen.
*/
virtual void finalize() = 0;
/**
* Shows some stats about the Mappable instance.
* Meant for MappableSeekableZStream only.
* As Mappables don't keep track of what they are instanciated for, the name
* argument is used to make the stats logging useful to the reader. The when
* argument is to be used by the caller to give an identifier of the when
* the stats call is made.
*/
virtual void stats(const char *when, const char *name) const { }
/**
* Returns the maximum length that can be mapped from this Mappable for
* offset = 0.
*/
virtual size_t GetLength() const = 0;
};
/**
* Mappable implementation for plain files
*/
class MappableFile: public Mappable
{
public:
~MappableFile() { }
/**
* Create a MappableFile instance for the given file path.
*/
static Mappable *Create(const char *path);
/* Inherited from Mappable */
virtual void *mmap(const void *addr, size_t length, int prot, int flags, off_t offset);
virtual void finalize();
virtual size_t GetLength() const;
virtual Kind GetKind() const { return MAPPABLE_FILE; };
protected:
MappableFile(int fd): fd(fd) { }
private:
/* File descriptor */
AutoCloseFD fd;
};
/**
* Mappable implementation for deflated stream in a Zip archive
* Inflates the complete stream into a cache file.
*/
class MappableExtractFile: public MappableFile
{
public:
~MappableExtractFile();
/**
* Create a MappableExtractFile instance for the given Zip stream. The name
* argument is used to create the cache file in the cache directory.
*/
static Mappable *Create(const char *name, Zip *zip, Zip::Stream *stream);
virtual Kind GetKind() const { return MAPPABLE_EXTRACT_FILE; };
private:
MappableExtractFile(int fd, char *path)
: MappableFile(fd), path(path), pid(getpid()) { }
/**
* AutoUnlinkFile keeps track or a file name and removes (unlinks) the file
* when the instance is destroyed.
*/
struct AutoUnlinkFileTraits: public mozilla::ScopedDeleteArrayTraits<char>
{
static void release(char *value)
{
if (!value)
return;
unlink(value);
mozilla::ScopedDeleteArrayTraits<char>::release(value);
}
};
typedef mozilla::Scoped<AutoUnlinkFileTraits> AutoUnlinkFile;
/* Extracted file */
AutoUnlinkFile path;
/* Id of the process that initialized the instance */
pid_t pid;
};
class _MappableBuffer;
/**
* Mappable implementation for deflated stream in a Zip archive.
* Inflates the mapped bits in a temporary buffer.
*/
class MappableDeflate: public Mappable
{
public:
~MappableDeflate();
/**
* Create a MappableDeflate instance for the given Zip stream. The name
* argument is used for an appropriately named temporary file, and the Zip
* instance is given for the MappableDeflate to keep a reference of it.
*/
static Mappable *Create(const char *name, Zip *zip, Zip::Stream *stream);
/* Inherited from Mappable */
virtual void *mmap(const void *addr, size_t length, int prot, int flags, off_t offset);
virtual void finalize();
virtual size_t GetLength() const;
virtual Kind GetKind() const { return MAPPABLE_DEFLATE; };
private:
MappableDeflate(_MappableBuffer *buf, Zip *zip, Zip::Stream *stream);
/* Zip reference */
mozilla::RefPtr<Zip> zip;
/* Decompression buffer */
mozilla::ScopedDeletePtr<_MappableBuffer> buffer;
/* Zlib data */
z_stream zStream;
};
/**
* Mappable implementation for seekable zStreams.
* Inflates the mapped bits in a temporary buffer, on demand.
*/
class MappableSeekableZStream: public Mappable
{
public:
~MappableSeekableZStream();
/**
* Create a MappableSeekableZStream instance for the given Zip stream. The
* name argument is used for an appropriately named temporary file, and the
* Zip instance is given for the MappableSeekableZStream to keep a reference
* of it.
*/
static Mappable *Create(const char *name, Zip *zip,
Zip::Stream *stream);
/* Inherited from Mappable */
virtual void *mmap(const void *addr, size_t length, int prot, int flags, off_t offset);
virtual void munmap(void *addr, size_t length);
virtual void finalize();
virtual bool ensure(const void *addr);
virtual void stats(const char *when, const char *name) const;
virtual size_t GetLength() const;
virtual Kind GetKind() const { return MAPPABLE_SEEKABLE_ZSTREAM; };
private:
MappableSeekableZStream(Zip *zip);
/* Zip reference */
mozilla::RefPtr<Zip> zip;
/* Decompression buffer */
mozilla::ScopedDeletePtr<_MappableBuffer> buffer;
/* Seekable ZStream */
SeekableZStream zStream;
/* Keep track of mappings performed with MappableSeekableZStream::mmap so
* that they can be realized by MappableSeekableZStream::ensure.
* Values stored in the struct are those passed to mmap */
struct LazyMap
{
const void *addr;
size_t length;
int prot;
off_t offset;
/* Returns addr + length, as a pointer */
const void *end() const {
return reinterpret_cast<const void *>
(reinterpret_cast<const unsigned char *>(addr) + length);
}
/* Returns offset + length */
const off_t endOffset() const {
return offset + length;
}
/* Returns the offset corresponding to the given address */
const off_t offsetOf(const void *ptr) const {
return reinterpret_cast<uintptr_t>(ptr)
- reinterpret_cast<uintptr_t>(addr) + offset;
}
/* Returns whether the given address is in the LazyMap range */
const bool Contains(const void *ptr) const {
return (ptr >= addr) && (ptr < end());
}
};
/* List of all mappings */
std::vector<LazyMap> lazyMaps;
/* Array keeping track of which chunks have already been decompressed.
* Each value is the number of pages decompressed for the given chunk. */
mozilla::ScopedDeleteArray<unsigned char> chunkAvail;
/* Number of chunks that have already been decompressed. */
mozilla::Atomic<size_t> chunkAvailNum;
/* Mutex protecting decompression */
pthread_mutex_t mutex;
};
#endif /* Mappable_h */