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
|
/*
* Copyright (c) 2014-2025, Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PT_MAPPED_SECTION_H
#define PT_MAPPED_SECTION_H
#include "intel-pt.h"
#include "pt_section.h"
#include <stdint.h>
/* A section mapped into memory. */
struct pt_mapped_section {
/* The section that is mapped. */
struct pt_section *section;
/* The address space into which the section is mapped. */
struct pt_asid asid;
/* The virtual address at which the section is mapped. */
uint64_t vaddr;
/* The offset into the section.
*
* This is normally zero but when @section is split, @offset is added to
* the section/file offset when accessing @section.
*/
uint64_t offset;
/* The size of the section.
*
* This is normally @section->size but when @section is split, this is
* used to determine the size of the sub-section.
*/
uint64_t size;
};
static inline void pt_msec_init(struct pt_mapped_section *msec,
struct pt_section *section,
const struct pt_asid *asid,
uint64_t vaddr, uint64_t offset, uint64_t size)
{
if (!msec)
return;
msec->section = section;
msec->vaddr = vaddr;
msec->offset = offset;
msec->size = size;
if (asid)
msec->asid = *asid;
else
pt_asid_init(&msec->asid);
}
/* Destroy a mapped section - does not free @msec->section. */
static inline void pt_msec_fini(struct pt_mapped_section *msec)
{
(void) msec;
/* Nothing to do. */
}
/* Return the virtual address of the beginning of the memory region. */
static inline uint64_t pt_msec_begin(const struct pt_mapped_section *msec)
{
if (!msec)
return 0ull;
return msec->vaddr;
}
/* Return the virtual address one byte past the end of the memory region. */
static inline uint64_t pt_msec_end(const struct pt_mapped_section *msec)
{
if (!msec)
return 0ull;
return msec->vaddr + msec->size;
}
/* Return the section/file offset. */
static inline uint64_t pt_msec_offset(const struct pt_mapped_section *msec)
{
if (!msec)
return 0ull;
return msec->offset;
}
/* Return the section size. */
static inline uint64_t pt_msec_size(const struct pt_mapped_section *msec)
{
if (!msec)
return 0ull;
return msec->size;
}
/* Return the underlying section. */
static inline struct pt_section *
pt_msec_section(const struct pt_mapped_section *msec)
{
return msec->section;
}
/* Return an identifier for the address-space the section is mapped into. */
static inline const struct pt_asid *
pt_msec_asid(const struct pt_mapped_section *msec)
{
if (!msec)
return NULL;
return &msec->asid;
}
/* Translate a section/file offset into a virtual address. */
static inline uint64_t pt_msec_map(const struct pt_mapped_section *msec,
uint64_t offset)
{
return (offset - msec->offset) + msec->vaddr;
}
/* Translate a virtual address into a section/file offset. */
static inline uint64_t pt_msec_unmap(const struct pt_mapped_section *msec,
uint64_t vaddr)
{
return (vaddr - msec->vaddr) + msec->offset;
}
/* Read memory from a mapped section.
*
* The caller must check @msec->asid.
* The caller must ensure that @msec->section is mapped.
*
* Returns the number of bytes read on success.
* Returns a negative error code otherwise.
*/
static inline int pt_msec_read(const struct pt_mapped_section *msec,
uint8_t *buffer, uint16_t size,
uint64_t vaddr)
{
struct pt_section *section;
uint64_t begin, end, mbegin, mend, offset;
if (!msec)
return -pte_internal;
begin = vaddr;
end = begin + size;
if (end < begin)
end = UINT64_MAX;
mbegin = pt_msec_begin(msec);
mend = pt_msec_end(msec);
if (begin < mbegin || mend <= begin)
return -pte_nomap;
if (mend < end)
end = mend;
size = (uint16_t) (end - begin);
section = pt_msec_section(msec);
offset = pt_msec_unmap(msec, begin);
return pt_section_read(section, buffer, size, offset);
}
#endif /* PT_MAPPED_SECTION_H */
|
