xref: /openbmc/phosphor-logging/extensions/openpower-pels/pldm_interface.cpp (revision 1b41886d1ba223437ed35f4e04f3cad2e77c94ef)
1 /**
2  * Copyright © 2019 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "pldm_interface.hpp"
17 
18 #include <libpldm/base.h>
19 #include <libpldm/file_io.h>
20 #include <systemd/sd-bus.h>
21 #include <unistd.h>
22 
23 #include <phosphor-logging/lg2.hpp>
24 
25 #include <fstream>
26 
27 namespace openpower::pels
28 {
29 
30 namespace service
31 {
32 constexpr auto pldm = "xyz.openbmc_project.PLDM";
33 }
34 
35 namespace object_path
36 {
37 constexpr auto pldm = "/xyz/openbmc_project/pldm";
38 }
39 
40 namespace interface
41 {
42 constexpr auto pldm_requester = "xyz.openbmc_project.PLDM.Requester";
43 }
44 
45 using namespace sdeventplus;
46 using namespace sdeventplus::source;
47 
48 constexpr auto eidPath = "/usr/share/pldm/host_eid";
49 constexpr mctp_eid_t defaultEIDValue = 9;
50 
51 constexpr uint16_t pelFileType = 0;
52 
53 PLDMInterface::~PLDMInterface()
54 {
55     sd_bus_unref(_bus);
56     closeFD();
57 }
58 
59 void PLDMInterface::closeFD()
60 {
61     if (_fd >= 0)
62     {
63         close(_fd);
64         _fd = -1;
65     }
66 }
67 
68 void PLDMInterface::readEID()
69 {
70     _eid = defaultEIDValue;
71 
72     std::ifstream eidFile{eidPath};
73     if (!eidFile.good())
74     {
75         lg2::error("Could not open host EID file");
76     }
77     else
78     {
79         std::string eid;
80         eidFile >> eid;
81         if (!eid.empty())
82         {
83             _eid = atoi(eid.c_str());
84         }
85         else
86         {
87             lg2::error("EID file was empty");
88         }
89     }
90 }
91 
92 void PLDMInterface::open()
93 {
94     _fd = pldm_open();
95     if (_fd < 0)
96     {
97         auto e = errno;
98         lg2::error("pldm_open failed.  errno = {ERRNO}, rc = {RC}", "ERRNO", e,
99                    "RC", _fd);
100         throw std::exception{};
101     }
102 }
103 
104 void PLDMInterface::instanceIDCallback(sd_bus_message* msg)
105 {
106     if (!_inProgress)
107     {
108         lg2::info("A command was canceled while waiting for the instance ID");
109         return;
110     }
111 
112     bool failed = false;
113 
114     auto rc = sd_bus_message_get_errno(msg);
115     if (rc)
116     {
117         lg2::error("GetInstanceId D-Bus method failed, rc = {RC}", "RC", rc);
118         failed = true;
119     }
120     else
121     {
122         uint8_t id;
123         rc = sd_bus_message_read_basic(msg, 'y', &id);
124         if (rc < 0)
125         {
126             lg2::error("Could not read instance ID out of message, rc = {RC}",
127                        "RC", rc);
128             failed = true;
129         }
130         else
131         {
132             _instanceID = id;
133         }
134     }
135 
136     if (failed)
137     {
138         _inProgress = false;
139         callResponseFunc(ResponseStatus::failure);
140     }
141     else
142     {
143         startCommand();
144     }
145 }
146 
147 int iidCallback(sd_bus_message* msg, void* data, sd_bus_error* /*err*/)
148 {
149     auto* interface = static_cast<PLDMInterface*>(data);
150     interface->instanceIDCallback(msg);
151     return 0;
152 }
153 
154 void PLDMInterface::startCommand()
155 {
156     try
157     {
158         closeFD();
159 
160         open();
161 
162         registerReceiveCallback();
163 
164         doSend();
165 
166         _receiveTimer.restartOnce(_receiveTimeout);
167     }
168     catch (const std::exception& e)
169     {
170         cleanupCmd();
171 
172         callResponseFunc(ResponseStatus::failure);
173     }
174 }
175 
176 void PLDMInterface::startReadInstanceID()
177 {
178     auto rc = sd_bus_call_method_async(
179         _bus, NULL, service::pldm, object_path::pldm, interface::pldm_requester,
180         "GetInstanceId", iidCallback, this, "y", _eid);
181 
182     if (rc < 0)
183     {
184         lg2::error(
185             "Error calling sd_bus_call_method_async, rc = {RC}, msg = {MSG}",
186             "RC", rc, "MSG", strerror(-rc));
187     }
188 }
189 
190 CmdStatus PLDMInterface::sendNewLogCmd(uint32_t id, uint32_t size)
191 {
192     _pelID = id;
193     _pelSize = size;
194     _inProgress = true;
195 
196     try
197     {
198         // Kick off the async call to get the instance ID if
199         // necessary, otherwise start the command itself.
200         if (!_instanceID)
201         {
202             startReadInstanceID();
203         }
204         else
205         {
206             startCommand();
207         }
208     }
209     catch (const std::exception& e)
210     {
211         _inProgress = false;
212         return CmdStatus::failure;
213     }
214 
215     return CmdStatus::success;
216 }
217 
218 void PLDMInterface::registerReceiveCallback()
219 {
220     _source = std::make_unique<IO>(
221         _event, _fd, EPOLLIN,
222         std::bind(std::mem_fn(&PLDMInterface::receive), this,
223                   std::placeholders::_1, std::placeholders::_2,
224                   std::placeholders::_3));
225 }
226 
227 void PLDMInterface::doSend()
228 {
229     std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(pelFileType) +
230                             sizeof(_pelID) + sizeof(uint64_t)>
231         requestMsg;
232 
233     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
234 
235     auto rc = encode_new_file_req(*_instanceID, pelFileType, _pelID, _pelSize,
236                                   request);
237     if (rc != PLDM_SUCCESS)
238     {
239         lg2::error("encode_new_file_req failed, rc = {RC}", "RC", rc);
240         throw std::exception{};
241     }
242 
243     rc = pldm_send(_eid, _fd, requestMsg.data(), requestMsg.size());
244     if (rc < 0)
245     {
246         auto e = errno;
247         lg2::error("pldm_send failed, rc = {RC}, errno = {ERRNO}", "RC", rc,
248                    "ERRNO", e);
249 
250         throw std::exception{};
251     }
252 }
253 
254 void PLDMInterface::receive(IO& /*io*/, int fd, uint32_t revents)
255 {
256     if (!(revents & EPOLLIN))
257     {
258         return;
259     }
260 
261     uint8_t* responseMsg = nullptr;
262     size_t responseSize = 0;
263     ResponseStatus status = ResponseStatus::success;
264 
265     auto rc = pldm_recv(_eid, fd, *_instanceID, &responseMsg, &responseSize);
266     if (rc < 0)
267     {
268         if (rc == PLDM_REQUESTER_INSTANCE_ID_MISMATCH)
269         {
270             // We got a response to someone else's message. Ignore it.
271             return;
272         }
273         else if (rc == PLDM_REQUESTER_NOT_RESP_MSG)
274         {
275             // Due to the MCTP loopback, we may get notified of the message
276             // we just sent.
277             return;
278         }
279 
280         auto e = errno;
281         lg2::error("pldm_recv failed, rc = {RC}, errno = {ERRNO}", "RC",
282                    static_cast<std::underlying_type_t<pldm_requester_rc_t>>(rc),
283                    "ERRNO", e);
284         status = ResponseStatus::failure;
285 
286         responseMsg = nullptr;
287     }
288 
289     cleanupCmd();
290 
291     // Can't use this instance ID anymore.
292     _instanceID = std::nullopt;
293 
294     if (status == ResponseStatus::success)
295     {
296         uint8_t completionCode = 0;
297         auto response = reinterpret_cast<pldm_msg*>(responseMsg);
298 
299         auto decodeRC = decode_new_file_resp(response, PLDM_NEW_FILE_RESP_BYTES,
300                                              &completionCode);
301         if (decodeRC < 0)
302         {
303             lg2::error("decode_new_file_resp failed, rc = {RC}", "RC",
304                        decodeRC);
305             status = ResponseStatus::failure;
306         }
307         else
308         {
309             if (completionCode != PLDM_SUCCESS)
310             {
311                 lg2::error("Bad PLDM completion code {CODE}", "CODE",
312                            completionCode);
313                 status = ResponseStatus::failure;
314             }
315         }
316     }
317 
318     callResponseFunc(status);
319 
320     if (responseMsg)
321     {
322         free(responseMsg);
323     }
324 }
325 
326 void PLDMInterface::receiveTimerExpired()
327 {
328     lg2::error("Timed out waiting for PLDM response");
329 
330     // Cleanup, but keep the instance ID because the host didn't
331     // respond so we can still use it.
332     cleanupCmd();
333 
334     callResponseFunc(ResponseStatus::failure);
335 }
336 
337 void PLDMInterface::cancelCmd()
338 {
339     _instanceID = std::nullopt;
340     cleanupCmd();
341 }
342 
343 void PLDMInterface::cleanupCmd()
344 {
345     _inProgress = false;
346     _source.reset();
347 
348     if (_receiveTimer.isEnabled())
349     {
350         _receiveTimer.setEnabled(false);
351     }
352 
353     closeFD();
354 }
355 
356 } // namespace openpower::pels
357