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
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
|
#pragma once
#include <async_resp.hpp>
#include <string>
namespace redfish
{
namespace fw_util
{
/* @brief String that indicates a bios firmware instance */
constexpr const char *biosPurpose =
"xyz.openbmc_project.Software.Version.VersionPurpose.Host";
/* @brief String that indicates a BMC firmware instance */
constexpr const char *bmcPurpose =
"xyz.openbmc_project.Software.Version.VersionPurpose.BMC";
/**
* @brief Put fw version of input type into async response json structure
*
* @param[i,o] aResp Async response object
* @param[i] fwVersionPurpose Indicates what target to look for
* @param[i] jsonIdxStr Index in aResp->res.jsonValue to write fw ver
*
* @return void
*/
void getActiveFwVersion(std::shared_ptr<AsyncResp> aResp,
const std::string &fwVersionPurpose,
const std::string &jsonIdxStr)
{
// Get active FW images
crow::connections::systemBus->async_method_call(
[aResp, fwVersionPurpose,
jsonIdxStr](const boost::system::error_code ec,
const std::variant<std::vector<std::string>> &resp) {
if (ec)
{
BMCWEB_LOG_ERROR << "error_code = " << ec;
BMCWEB_LOG_ERROR << "error msg = " << ec.message();
messages::internalError(aResp->res);
return;
}
const std::vector<std::string> *functionalFw =
std::get_if<std::vector<std::string>>(&resp);
if ((functionalFw == nullptr) || (functionalFw->size() == 0))
{
BMCWEB_LOG_ERROR << "Zero functional software in system";
messages::internalError(aResp->res);
return;
}
// example functionalFw:
// v as 2 "/xyz/openbmc_project/software/ace821ef"
// "/xyz/openbmc_project/software/230fb078"
for (auto &fw : *functionalFw)
{
// if can't parse fw id then return
std::string::size_type idPos = fw.rfind("/");
if (idPos == std::string::npos)
{
messages::internalError(aResp->res);
BMCWEB_LOG_DEBUG << "Can't parse firmware ID!!";
return;
}
idPos++;
if (idPos >= fw.size())
{
messages::internalError(aResp->res);
BMCWEB_LOG_DEBUG << "Invalid firmware ID";
return;
}
std::string swId = fw.substr(idPos);
// Now find service that hosts it
crow::connections::systemBus->async_method_call(
[aResp, fw, swId, fwVersionPurpose, jsonIdxStr](
const boost::system::error_code ec,
const std::vector<std::pair<
std::string, std::vector<std::string>>> &objInfo) {
if (ec)
{
BMCWEB_LOG_DEBUG << "error_code = " << ec;
BMCWEB_LOG_DEBUG << "error msg = " << ec.message();
messages::internalError(aResp->res);
return;
}
// Example objInfo
// a{sas} 1 "org.open_power.Software.Host.Updater" 10
// "org.freedesktop.DBus.Introspectable"
// "org.freedesktop.DBus.Peer"
// "org.freedesktop.DBus.Properties"
// "org.openbmc.Associations"
// "xyz.openbmc_project.Common.FilePath"
// "xyz.openbmc_project.Object.Delete"
// "xyz.openbmc_project.Software.Activation"
// "xyz.openbmc_project.Software.ExtendedVersion"
// "xyz.openbmc_project.Software.RedundancyPriority"
// "xyz.openbmc_project.Software.Version"
// Ensure we only got one service back
if (objInfo.size() != 1)
{
BMCWEB_LOG_ERROR << "Invalid Object Size "
<< objInfo.size();
messages::internalError(aResp->res);
return;
}
// Now grab its version info
crow::connections::systemBus->async_method_call(
[aResp, swId, fwVersionPurpose, jsonIdxStr](
const boost::system::error_code ec,
const boost::container::flat_map<
std::string, VariantType> &propertiesList) {
if (ec)
{
BMCWEB_LOG_ERROR << "error_code = " << ec;
BMCWEB_LOG_ERROR << "error msg = "
<< ec.message();
messages::internalError(aResp->res);
return;
}
// example propertiesList
// a{sv} 2 "Version" s
// "IBM-witherspoon-OP9-v2.0.10-2.22" "Purpose"
// s
// "xyz.openbmc_project.Software.Version.VersionPurpose.Host"
boost::container::flat_map<
std::string, VariantType>::const_iterator
it = propertiesList.find("Purpose");
if (it == propertiesList.end())
{
BMCWEB_LOG_DEBUG
<< "Can't find property \"Purpose\"!";
messages::internalError(aResp->res);
return;
}
const std::string *swInvPurpose =
std::get_if<std::string>(&it->second);
if (swInvPurpose == nullptr)
{
BMCWEB_LOG_DEBUG << "wrong types for "
"property \"Purpose\"!";
messages::internalError(aResp->res);
return;
}
if (*swInvPurpose != fwVersionPurpose)
{
// Not purpose we're looking for
return;
}
it = propertiesList.find("Version");
if (it == propertiesList.end())
{
BMCWEB_LOG_DEBUG
<< "Can't find property \"Version\"!";
messages::internalError(aResp->res);
return;
}
const std::string *version =
std::get_if<std::string>(&it->second);
if (version == nullptr)
{
BMCWEB_LOG_DEBUG
<< "Error getting fw version";
messages::internalError(aResp->res);
return;
}
aResp->res.jsonValue[jsonIdxStr] = *version;
},
objInfo[0].first, fw,
"org.freedesktop.DBus.Properties", "GetAll",
"xyz.openbmc_project.Software.Version");
},
"xyz.openbmc_project.ObjectMapper",
"/xyz/openbmc_project/object_mapper",
"xyz.openbmc_project.ObjectMapper", "GetObject", fw,
std::array<const char *, 1>{
"xyz.openbmc_project.Software.Activation"});
}
},
"xyz.openbmc_project.ObjectMapper",
"/xyz/openbmc_project/software/functional",
"org.freedesktop.DBus.Properties", "Get",
"xyz.openbmc_project.Association", "endpoints");
return;
}
/**
* @brief Translate input fwState to Redfish state
*
* This function will return the corresponding Redfish state
*
* @param[i] fwState The OpenBMC firmware state
*
* @return The corresponding Redfish state
*/
std::string getRedfishFWState(const std::string &fwState)
{
if (fwState == "xyz.openbmc_project.Software.Activation.Activations.Active")
{
return "Enabled";
}
else if (fwState == "xyz.openbmc_project.Software.Activation."
"Activations.Activating")
{
return "Updating";
}
else if (fwState == "xyz.openbmc_project.Software.Activation."
"Activations.StandbySpare")
{
return "StandbySpare";
}
else
{
BMCWEB_LOG_DEBUG << "Default fw state " << fwState << " to Disabled";
return "Disabled";
}
}
/**
* @brief Translate input fwState to Redfish health state
*
* This function will return the corresponding Redfish health state
*
* @param[i] fwState The OpenBMC firmware state
*
* @return The corresponding Redfish health state
*/
std::string getRedfishFWHealth(const std::string &fwState)
{
if ((fwState ==
"xyz.openbmc_project.Software.Activation.Activations.Active") ||
(fwState == "xyz.openbmc_project.Software.Activation.Activations."
"Activating") ||
(fwState ==
"xyz.openbmc_project.Software.Activation.Activations.Ready"))
{
return "OK";
}
else
{
BMCWEB_LOG_DEBUG << "FW state " << fwState << " to Warning";
return "Warning";
}
}
/**
* @brief Put status of input swId into json response
*
* This function will put the appropriate Redfish state of the input
* firmware id to ["Status"]["State"] within the json response
*
* @param[i,o] aResp Async response object
* @param[i] swId The software ID to get status for
* @param[i] dbusSvc The dbus service implementing the software object
*
* @return void
*/
void getFwStatus(std::shared_ptr<AsyncResp> asyncResp,
const std::shared_ptr<std::string> swId,
const std::string &dbusSvc)
{
BMCWEB_LOG_DEBUG << "getFwStatus: swId " << *swId << " svc " << dbusSvc;
crow::connections::systemBus->async_method_call(
[asyncResp,
swId](const boost::system::error_code error_code,
const boost::container::flat_map<std::string, VariantType>
&propertiesList) {
if (error_code)
{
// not all fwtypes are updateable, this is ok
asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
return;
}
boost::container::flat_map<std::string, VariantType>::const_iterator
it = propertiesList.find("Activation");
if (it == propertiesList.end())
{
BMCWEB_LOG_DEBUG << "Can't find property \"Activation\"!";
messages::propertyMissing(asyncResp->res, "Activation");
return;
}
const std::string *swInvActivation =
std::get_if<std::string>(&it->second);
if (swInvActivation == nullptr)
{
BMCWEB_LOG_DEBUG << "wrong types for property\"Activation\"!";
messages::propertyValueTypeError(asyncResp->res, "",
"Activation");
return;
}
BMCWEB_LOG_DEBUG << "getFwStatus: Activation " << *swInvActivation;
asyncResp->res.jsonValue["Status"]["State"] =
getRedfishFWState(*swInvActivation);
asyncResp->res.jsonValue["Status"]["Health"] =
getRedfishFWHealth(*swInvActivation);
},
dbusSvc, "/xyz/openbmc_project/software/" + *swId,
"org.freedesktop.DBus.Properties", "GetAll",
"xyz.openbmc_project.Software.Activation");
}
/**
* @brief Updates programmable status of input swId into json response
*
* This function checks whether firmware inventory component
* can be programable or not and fill's the "Updateable"
* Property.
*
* @param[i,o] asyncResp Async response object
* @param[i] fwId The firmware ID
*/
void getFwUpdateableStatus(std::shared_ptr<AsyncResp> asyncResp,
const std::shared_ptr<std::string> fwId)
{
crow::connections::systemBus->async_method_call(
[asyncResp, fwId](const boost::system::error_code ec,
const std::variant<std::vector<std::string>> &resp) {
if (ec)
{
BMCWEB_LOG_DEBUG << __FUNCTION__ << " error_code = " << ec
<< " error msg = " << ec.message();
// System can exist with no updateable firmware,
// so don't throw error here.
return;
}
const std::vector<std::string> *objPaths =
std::get_if<std::vector<std::string>>(&resp);
if (objPaths)
{
std::string reqFwObjPath =
"/xyz/openbmc_project/software/" + *fwId;
if (std::find((*objPaths).begin(), (*objPaths).end(),
reqFwObjPath) != (*objPaths).end())
{
asyncResp->res.jsonValue["Updateable"] = true;
return;
}
}
return;
},
"xyz.openbmc_project.ObjectMapper",
"/xyz/openbmc_project/software/updateable",
"org.freedesktop.DBus.Properties", "Get",
"xyz.openbmc_project.Association", "endpoints");
return;
}
} // namespace fw_util
} // namespace redfish
|
