LLDB  mainline
LinuxProcMaps.cpp
Go to the documentation of this file.
1 //===-- LinuxProcMaps.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "LinuxProcMaps.h"
11 #include "lldb/Utility/Status.h"
13 #include "llvm/ADT/StringRef.h"
14 
15 using namespace lldb_private;
16 
17 enum class MapsKind { Maps, SMaps };
18 
19 static llvm::Expected<MemoryRegionInfo> ProcMapError(const char *msg,
20  MapsKind kind) {
21  return llvm::createStringError(llvm::inconvertibleErrorCode(), msg,
22  kind == MapsKind::Maps ? "maps" : "smaps");
23 }
24 
25 static llvm::Expected<MemoryRegionInfo>
26 ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
27  MapsKind maps_kind) {
28  MemoryRegionInfo region;
29  StringExtractor line_extractor(maps_line);
30 
31  // Format: {address_start_hex}-{address_end_hex} perms offset dev inode
32  // pathname perms: rwxp (letter is present if set, '-' if not, final
33  // character is p=private, s=shared).
34 
35  // Parse out the starting address
36  lldb::addr_t start_address = line_extractor.GetHexMaxU64(false, 0);
37 
38  // Parse out hyphen separating start and end address from range.
39  if (!line_extractor.GetBytesLeft() || (line_extractor.GetChar() != '-'))
40  return ProcMapError(
41  "malformed /proc/{pid}/%s entry, missing dash between address range",
42  maps_kind);
43 
44  // Parse out the ending address
45  lldb::addr_t end_address = line_extractor.GetHexMaxU64(false, start_address);
46 
47  // Parse out the space after the address.
48  if (!line_extractor.GetBytesLeft() || (line_extractor.GetChar() != ' '))
49  return ProcMapError(
50  "malformed /proc/{pid}/%s entry, missing space after range", maps_kind);
51 
52  // Save the range.
53  region.GetRange().SetRangeBase(start_address);
54  region.GetRange().SetRangeEnd(end_address);
55 
56  // Any memory region in /proc/{pid}/(maps|smaps) is by definition mapped
57  // into the process.
58  region.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
59 
60  // Parse out each permission entry.
61  if (line_extractor.GetBytesLeft() < 4)
62  return ProcMapError(
63  "malformed /proc/{pid}/%s entry, missing some portion of "
64  "permissions",
65  maps_kind);
66 
67  // Handle read permission.
68  const char read_perm_char = line_extractor.GetChar();
69  if (read_perm_char == 'r')
70  region.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
71  else if (read_perm_char == '-')
72  region.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
73  else
74  return ProcMapError("unexpected /proc/{pid}/%s read permission char",
75  maps_kind);
76 
77  // Handle write permission.
78  const char write_perm_char = line_extractor.GetChar();
79  if (write_perm_char == 'w')
80  region.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
81  else if (write_perm_char == '-')
82  region.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
83  else
84  return ProcMapError("unexpected /proc/{pid}/%s write permission char",
85  maps_kind);
86 
87  // Handle execute permission.
88  const char exec_perm_char = line_extractor.GetChar();
89  if (exec_perm_char == 'x')
90  region.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
91  else if (exec_perm_char == '-')
92  region.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
93  else
94  return ProcMapError("unexpected /proc/{pid}/%s exec permission char",
95  maps_kind);
96 
97  line_extractor.GetChar(); // Read the private bit
98  line_extractor.SkipSpaces(); // Skip the separator
99  line_extractor.GetHexMaxU64(false, 0); // Read the offset
100  line_extractor.GetHexMaxU64(false, 0); // Read the major device number
101  line_extractor.GetChar(); // Read the device id separator
102  line_extractor.GetHexMaxU64(false, 0); // Read the major device number
103  line_extractor.SkipSpaces(); // Skip the separator
104  line_extractor.GetU64(0, 10); // Read the inode number
105 
106  line_extractor.SkipSpaces();
107  const char *name = line_extractor.Peek();
108  if (name)
109  region.SetName(name);
110 
111  return region;
112 }
113 
114 void lldb_private::ParseLinuxMapRegions(llvm::StringRef linux_map,
115  LinuxMapCallback const &callback) {
116  llvm::StringRef lines(linux_map);
117  llvm::StringRef line;
118  while (!lines.empty()) {
119  std::tie(line, lines) = lines.split('\n');
121  break;
122  }
123 }
124 
125 void lldb_private::ParseLinuxSMapRegions(llvm::StringRef linux_smap,
126  LinuxMapCallback const &callback) {
127  // Entries in /smaps look like:
128  // 00400000-0048a000 r-xp 00000000 fd:03 960637
129  // Size: 552 kB
130  // Rss: 460 kB
131  // <...>
132  // VmFlags: rd ex mr mw me dw
133  // 00500000-0058a000 rwxp 00000000 fd:03 960637
134  // <...>
135  //
136  // Where the first line is identical to the /maps format
137  // and VmFlags is only printed for kernels >= 3.8.
138 
139  llvm::StringRef lines(linux_smap);
140  llvm::StringRef line;
141  llvm::Optional<MemoryRegionInfo> region;
142 
143  while (lines.size()) {
144  std::tie(line, lines) = lines.split('\n');
145 
146  // A property line looks like:
147  // <word>: <value>
148  // (no spaces on the left hand side)
149  // A header will have a ':' but the LHS will contain spaces
150  llvm::StringRef name;
151  llvm::StringRef value;
152  std::tie(name, value) = line.split(':');
153 
154  // If this line is a property line
155  if (!name.contains(' ')) {
156  if (region) {
157  if (name == "VmFlags") {
158  if (value.contains("mt"))
159  region->SetMemoryTagged(MemoryRegionInfo::eYes);
160  else
161  region->SetMemoryTagged(MemoryRegionInfo::eNo);
162  }
163  // Ignore anything else
164  } else {
165  // Orphaned settings line
166  callback(ProcMapError(
167  "Found a property line without a corresponding mapping "
168  "in /proc/{pid}/%s",
169  MapsKind::SMaps));
170  return;
171  }
172  } else {
173  // Must be a new region header
174  if (region) {
175  // Save current region
176  callback(*region);
177  region.reset();
178  }
179 
180  // Try to start a new region
181  llvm::Expected<MemoryRegionInfo> new_region =
183  if (new_region) {
184  region = *new_region;
185  } else {
186  // Stop at first invalid region header
187  callback(new_region.takeError());
188  return;
189  }
190  }
191  }
192 
193  // Catch last region
194  if (region)
195  callback(*region);
196 }
ProcMapError
static llvm::Expected< MemoryRegionInfo > ProcMapError(const char *msg, MapsKind kind)
Definition: LinuxProcMaps.cpp:19
MapsKind::Maps
@ Maps
StringExtractor::GetBytesLeft
size_t GetBytesLeft()
Definition: StringExtractor.h:52
lldb_private::MemoryRegionInfo::SetName
void SetName(const char *name)
Definition: MemoryRegionInfo.h:62
StringExtractor::SkipSpaces
void SkipSpaces()
Definition: StringExtractor.cpp:367
lldb_private::ParseLinuxMapRegions
void ParseLinuxMapRegions(llvm::StringRef linux_map, LinuxMapCallback const &callback)
Definition: LinuxProcMaps.cpp:114
MapsKind
MapsKind
Definition: LinuxProcMaps.cpp:17
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::MemoryRegionInfo::SetReadable
void SetReadable(OptionalBool val)
Definition: MemoryRegionInfo.h:54
StringExtractor
Definition: StringExtractor.h:19
lldb_private::LinuxMapCallback
std::function< bool(llvm::Expected< MemoryRegionInfo >)> LinuxMapCallback
Definition: LinuxProcMaps.h:18
lldb_private::ParseLinuxSMapRegions
void ParseLinuxSMapRegions(llvm::StringRef linux_smap, LinuxMapCallback const &callback)
Definition: LinuxProcMaps.cpp:125
lldb_private::Range::SetRangeEnd
void SetRangeEnd(BaseType end)
Definition: RangeMap.h:64
StringExtractor::Peek
const char * Peek()
Definition: StringExtractor.h:100
MemoryRegionInfo.h
lldb_private::MemoryRegionInfo::SetExecutable
void SetExecutable(OptionalBool val)
Definition: MemoryRegionInfo.h:58
lldb_private::MemoryRegionInfo::eYes
@ eYes
Definition: MemoryRegionInfo.h:25
StringExtractor::GetChar
char GetChar(char fail_value='\0')
Definition: StringExtractor.cpp:45
lldb_private::MemoryRegionInfo::eNo
@ eNo
Definition: MemoryRegionInfo.h:25
lldb_private::MemoryRegionInfo::SetWritable
void SetWritable(OptionalBool val)
Definition: MemoryRegionInfo.h:56
StringExtractor::GetU64
uint64_t GetU64(uint64_t fail_value, int base=0)
Definition: StringExtractor.cpp:125
StringExtractor::GetHexMaxU64
uint64_t GetHexMaxU64(bool little_endian, uint64_t fail_value)
Definition: StringExtractor.cpp:206
StringExtractor.h
lldb_private::MemoryRegionInfo::SetMapped
void SetMapped(OptionalBool val)
Definition: MemoryRegionInfo.h:60
lldb_private::Range::SetRangeBase
void SetRangeBase(BaseType b)
Definition: RangeMap.h:48
ParseMemoryRegionInfoFromProcMapsLine
static llvm::Expected< MemoryRegionInfo > ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line, MapsKind maps_kind)
Definition: LinuxProcMaps.cpp:26
lldb_private::MemoryRegionInfo::GetRange
RangeType & GetRange()
Definition: MemoryRegionInfo.h:36
Status.h
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
LinuxProcMaps.h
MapsKind::SMaps
@ SMaps