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
|
#include <fstream>
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <sdbusplus/vtable.hpp>
#include <systemd/sd-bus.h>
#include <systemd/sd-journal.h>
#include "elog-lookup.cpp"
#include "config.h"
#include "elog_entry.hpp"
#include "log.hpp"
#include "log_manager.hpp"
namespace phosphor
{
namespace logging
{
void Manager::commit(uint64_t transactionId, std::string errMsg)
{
// TODO Change /tmp path to a permanent location on flash
constexpr const auto path = "/tmp/elog";
constexpr const auto transactionIdVar = "TRANSACTION_ID";
std::string filename{};
filename.append(path);
// TODO Create error logs in their own separate dir once permanent location
// on flash is determined. Ex: ../transactionId/1
std::ofstream efile;
efile.open(filename);
efile << "{" << std::endl;
sd_journal *j = nullptr;
int rc = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY);
if (rc < 0)
{
logging::log<logging::level::ERR>("Failed to open journal",
logging::entry("DESCRIPTION=%s", strerror(-rc)));
return;
}
std::string transactionIdStr = std::to_string(transactionId);
std::vector<std::string> metalist = g_errMetaMap[errMsg];
std::vector<std::string> additionalData;
// Read the journal from the end to get the most recent entry first.
// The result from the sd_journal_get_data() is of the form VARIABLE=value.
SD_JOURNAL_FOREACH_BACKWARDS(j)
{
const char *data = nullptr;
size_t length = 0;
// Look for the transaction id metadata variable
rc = sd_journal_get_data(j, transactionIdVar, (const void **)&data,
&length);
if (rc < 0)
{
// This journal entry does not have the transaction id,
// continue to next entry
continue;
}
std::string result(data);
if (result.find(transactionIdStr) == std::string::npos)
{
// Requested transaction id not found,
// continue to next journal entry.
continue;
}
// Match found, write to file
// TODO This is a draft format based on the redfish event logs written
// in json, the final openbmc format is to be determined
efile << "\t{" << std::endl;
efile << "\t\"@" << data << "\"," << std::endl;
// Include the journal message
rc = sd_journal_get_data(j, "MESSAGE", (const void **)&data, &length);
if (rc < 0)
{
continue;
}
efile << "\t\"@" << data << "\"," << std::endl;
// Search for the metadata variables in the current journal entry
for (auto metaVarStr : metalist)
{
rc = sd_journal_get_data(j, metaVarStr.c_str(),
(const void **)&data, &length);
if (rc < 0)
{
// Not found, continue to next metadata variable
logging::log<logging::level::INFO>("Failed to find metadata",
logging::entry("META_FIELD=%s", metaVarStr.c_str()));
continue;
}
// Metatdata variable found, write to file
additionalData.push_back(std::string(data));
efile << "\t\"@" << data << "\"," << std::endl;
}
efile << "\t}" << std::endl;
// TODO Break only once all metadata fields have been found. Implement
// once this function reads the metadata fields from the header file.
break;
}
sd_journal_close(j);
// Create error Entry dbus object
entryId++;
auto objPath = std::string(OBJ_ENTRY) + '/' +
std::to_string(entryId);
entries.insert(std::make_pair(entryId, std::make_unique<Entry>(
busLog,
objPath,
entryId,
(Entry::Level)g_errLevelMap[errMsg],
std::move(errMsg),
std::move(additionalData))));
efile << "}" << std::endl;
efile.close();
return;
}
} // namespace logging
} // namepsace phosphor
|
