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
|
#include <unistd.h>
#include <sys/inotify.h>
#include <phosphor-logging/elog-errors.hpp>
#include "dump_manager.hpp"
#include "dump_internal.hpp"
#include "xyz/openbmc_project/Common/error.hpp"
#include "config.h"
namespace phosphor
{
namespace dump
{
using namespace sdbusplus::xyz::openbmc_project::Common::Error;
using namespace phosphor::logging;
namespace internal
{
void Manager::create(
Type type,
std::vector<std::string> fullPaths)
{
// TODO openbmc/openbmc#1795
// Add implementaion of internal create function.
}
} //namepsace internal
uint32_t Manager::createDump()
{
std::vector<std::string> paths;
return captureDump(Type::UserRequested, paths);
}
uint32_t Manager::captureDump(
Type type,
const std::vector<std::string>& fullPaths)
{
pid_t pid = fork();
if (pid == 0)
{
fs::path dumpPath(BMC_DUMP_PATH);
dumpPath /= std::to_string(lastEntryId + 1);
execl("/usr/bin/ffdc", "ffdc", "-d", dumpPath.c_str(), nullptr);
//ffdc script execution is failed.
auto error = errno;
log<level::ERR>("Error occurred during ffdc function execution",
entry("ERRNO=%d", error));
elog<InternalFailure>();
}
else if (pid > 0)
{
auto rc = sd_event_add_child(eventLoop.get(),
nullptr,
pid,
WEXITED | WSTOPPED,
callback,
nullptr);
if (0 > rc)
{
// Failed to add to event loop
log<level::ERR>("Error occurred during the sd_event_add_child call",
entry("rc=%d", rc));
elog<InternalFailure>();
}
}
else
{
auto error = errno;
log<level::ERR>("Error occurred during fork",
entry("ERRNO=%d", error));
elog<InternalFailure>();
}
return ++lastEntryId;
}
void Manager::createEntry(const fs::path& file)
{
// TODO openbmc/openbmc#1795
// Get Dump ID and Epoch time from Dump file name.
// Validate the Dump file name.
auto id = lastEntryId;
//Get Epoch time.
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
// Entry Object path.
auto objPath = fs::path(OBJ_ENTRY) / std::to_string(id);
auto size = fs::file_size(file);
entries.insert(std::make_pair(id,
std::make_unique<Entry>(
bus,
objPath.c_str(),
id,
ms,
size,
file,
*this)));
}
void Manager::erase(uint32_t entryId)
{
entries.erase(entryId);
}
void Manager::watchCallback(const UserMap& fileInfo)
{
for (const auto& i : fileInfo)
{
// For any new dump file create dump entry object
// and associated inotify watch.
if (IN_CLOSE_WRITE == i.second)
{
removeWatch(i.first);
createEntry(i.first);
}
// Start inotify watch on newly created directory.
else if ((IN_CREATE == i.second) && fs::is_directory(i.first))
{
auto watchObj = std::make_unique<Watch>(
eventLoop,
IN_NONBLOCK,
IN_CLOSE_WRITE,
EPOLLIN,
i.first,
std::bind(
std::mem_fn(
&phosphor::dump::Manager::watchCallback),
this, std::placeholders::_1));
childWatchMap.emplace(i.first, std::move(watchObj));
}
}
}
void Manager::removeWatch(const fs::path& path)
{
//Delete Watch entry from map.
childWatchMap.erase(path);
}
} //namespace dump
} //namespace phosphor
|
