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
|
/* Copyright (c) 2008-2022 the MRtrix3 contributors.
*
* 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/.
*
* Covered Software is provided under this License on an "as is"
* basis, without warranty of any kind, either expressed, implied, or
* statutory, including, without limitation, warranties that the
* Covered Software is free of defects, merchantable, fit for a
* particular purpose or non-infringing.
* See the Mozilla Public License v. 2.0 for more details.
*
* For more details, see http://www.mrtrix.org/.
*/
#ifndef __file_mmap_h__
#define __file_mmap_h__
#include <iostream>
#include <cassert>
#include <cstdint>
#include "types.h"
#include "file/entry.h"
namespace MR
{
namespace File
{
class MMap : protected Entry { NOMEMALIGN
public:
//! create a new memory-mapping to file in \a entry
/*! map file in \a entry at the offset in \a entry. By default, the
* file will be mapped read-only. If \a readwrite is set to true,
* the file will be accessed with read-write permissions, but the
* mechanism used depends on whether the file is detected as residing
* on a local or a networked filesystem, and whether the filesystem is
* mounted with synchronous IO. If the filesystem is \e local and
* \e asynchronous, the file is memory-mapped as-is with read-write
* permissions. Otherwise, a write-back RAM buffer is allocated to
* store the contents of the file, and written back when the
* constructor is invoked.
*
* By default, if the file is mapped using the delayed write-back
* mechanism, its contents will be preloaded into the RAM buffer. If
* the file has just been created, \a preload should be set to \c false to
* prevent this, in which case the contents will set to zero.
*
* By default, the whole file is mapped. If \a mapped_size is
* non-zero, then only the region of size \a mapped_size starting from
* the byte offset specified in \a entry will be mapped.
*/
MMap (const Entry& entry, bool readwrite = false, bool preload = true, int64_t mapped_size = -1);
~MMap ();
std::string name () const {
return Entry::name;
}
int64_t size () const {
return msize;
}
uint8_t* address() {
return first;
}
const uint8_t* address() const {
return first;
}
bool is_read_write () const {
return readwrite;
}
bool changed () const;
friend std::ostream& operator<< (std::ostream& stream, const MMap& m) {
stream << "File::MMap { " << m.name() << " [" << m.fd << "], size: "
<< m.size() << ", mapped " << (m.readwrite ? "RW" : "RO")
<< " at " << (void*) m.address() << ", offset " << m.start << " }";
return stream;
}
protected:
int fd;
uint8_t* addr; /**< The address in memory where the file has been mapped. */
uint8_t* first; /**< The address in memory to the start of the region of interest. */
int64_t msize; /**< The size of the file. */
time_t mtime; /**< The modification time of the file at the last check. */
bool readwrite;
void map ();
private:
MMap (const MMap& mmap) : Entry (mmap), fd (0), addr (NULL), first (NULL), msize (0), mtime (0), readwrite (false) {
assert (0);
}
};
}
}
#endif
|
