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
|
// Copyright 2021 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#define PW_LOG_LEVEL PW_THREAD_EMBOS_CONFIG_LOG_LEVEL
#include "pw_thread_embos/snapshot.h"
#include <string_view>
#include "RTOS.h"
#include "pw_function/function.h"
#include "pw_log/log.h"
#include "pw_protobuf/encoder.h"
#include "pw_status/status.h"
#include "pw_thread/snapshot.h"
#include "pw_thread_embos/config.h"
#include "pw_thread_embos/util.h"
#include "pw_thread_protos/thread.pwpb.h"
namespace pw::thread::embos {
namespace {
// TODO(amontanez): This might make unit testing codepaths that use this more
// challenging.
inline bool ThreadIsRunning(const OS_TASK& thread) {
return OS_GetpCurrentTask() == &thread;
}
void CaptureThreadState(const OS_TASK& thread, Thread::StreamEncoder& encoder) {
if (ThreadIsRunning(thread)) {
PW_LOG_DEBUG("Thread state: RUNNING");
encoder.WriteState(ThreadState::Enum::RUNNING);
return;
}
// One byte is reserved for task status.
// - The lowest two bits are for a suspend counter.
// - The third-lowest bit is reserved for a "timeout." (ignored here)
// - The highest five bits indicate what the task is blocked on if non-zero.
//
// Note: embOS thread state is not part of the public API. This may not be
// correct for all versions. This has been tested on embOS 4.22, and was
// initially reported for embOS 5.06.
//
// Description of how `OS_TASK::Stat` is used by embOS:
// https://forum.segger.com/index.php/Thread/6548-ABANDONED-Task-state-values/?postID=23963#post23963
#if OS_VERSION_GENERIC < 42200 || OS_VERSION_GENERIC > 50600
#warning embOS thread state interpretation logic is not verfied as working on this version of embOS
#endif // OS_VERSION_GENERIC < 42200 || OS_VERSION_GENERIC > 50600
if ((thread.Stat & 0x3) != 0) {
PW_LOG_DEBUG("Thread state: SUSPENDED");
encoder.WriteState(ThreadState::Enum::SUSPENDED);
} else if ((thread.Stat & 0xf8) == 0) {
PW_LOG_DEBUG("Thread state: READY");
encoder.WriteState(ThreadState::Enum::READY);
} else {
PW_LOG_DEBUG("Thread state: BLOCKED");
encoder.WriteState(ThreadState::Enum::BLOCKED);
}
}
} // namespace
Status SnapshotThreads(void* running_thread_stack_pointer,
SnapshotThreadInfo::StreamEncoder& encoder,
ProcessThreadStackCallback& stack_dumper) {
struct {
void* running_thread_stack_pointer;
SnapshotThreadInfo::StreamEncoder* encoder;
ProcessThreadStackCallback* stack_dumper;
Status thread_capture_status;
} ctx;
ctx.running_thread_stack_pointer = running_thread_stack_pointer;
ctx.encoder = &encoder;
ctx.stack_dumper = &stack_dumper;
ThreadCallback thread_capture_cb([&ctx](const OS_TASK& thread) -> bool {
Thread::StreamEncoder thread_encoder = ctx.encoder->GetThreadsEncoder();
ctx.thread_capture_status.Update(
SnapshotThread(thread,
ctx.running_thread_stack_pointer,
thread_encoder,
*ctx.stack_dumper));
// Always iterate all threads.
return true;
});
if (Status status = ForEachThread(thread_capture_cb);
!status.ok() && !status.IsFailedPrecondition()) {
PW_LOG_ERROR("Failed to iterate threads during snapshot capture: %d",
static_cast<int>(status.code()));
}
return ctx.thread_capture_status;
}
Status SnapshotThread(const OS_TASK& thread,
void* running_thread_stack_pointer,
Thread::StreamEncoder& encoder,
ProcessThreadStackCallback& thread_stack_callback) {
#if OS_TRACKNAME
PW_LOG_DEBUG("Capturing thread info for %s", thread.Name);
encoder.WriteName(std::as_bytes(std::span(std::string_view(thread.Name))));
#else
PW_LOG_DEBUG("Capturing thread info for thread at 0x%08x", &thread);
#endif // OS_TRACKNAME
CaptureThreadState(thread, encoder);
#if OS_CHECKSTACK || OS_SUPPORT_MPU
const StackContext thread_ctx = {
.thread_name = thread.Name,
.stack_low_addr = reinterpret_cast<uintptr_t>(thread.pStackBot),
.stack_high_addr =
reinterpret_cast<uintptr_t>(thread.pStackBot) + thread.StackSize,
// If the thread is active, the stack pointer in the TCB is stale.
.stack_pointer = reinterpret_cast<uintptr_t>(
ThreadIsRunning(thread) ? running_thread_stack_pointer
: thread.pStack),
.stack_pointer_est_peak = reinterpret_cast<uintptr_t>(thread.pStackBot) +
thread.StackSize - OS_GetStackUsed(&thread),
};
return SnapshotStack(thread_ctx, encoder, thread_stack_callback);
#else
PW_LOG_DEBUG("Stack pointer: 0x%08x", running_thread_stack_pointer);
encoder.WriteStackPointer(reinterpret_cast<uintptr_t>(
ThreadIsRunning(thread) ? running_thread_stack_pointer : thread.pStack));
return encoder.status();
#endif // OS_CHECKSTACK || OS_SUPPORT_MPU
}
} // namespace pw::thread::embos
|
