1 #pragma once
2 
3 #include "common/utils.hpp"
4 #include "oem/ibm/requester/dbus_to_file_handler.hpp"
5 #include "oem_ibm_handler.hpp"
6 #include "pldmd/handler.hpp"
7 #include "requester/handler.hpp"
8 
9 #include <fcntl.h>
10 #include <libpldm/base.h>
11 #include <libpldm/oem/ibm/file_io.h>
12 #include <libpldm/oem/ibm/host.h>
13 #include <stdint.h>
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include <unistd.h>
17 
18 #include <phosphor-logging/lg2.hpp>
19 
20 #include <filesystem>
21 #include <iostream>
22 #include <vector>
23 
24 PHOSPHOR_LOG2_USING;
25 
26 namespace pldm
27 {
28 namespace responder
29 {
30 namespace dma
31 {
32 // The minimum data size of dma transfer in bytes
33 constexpr uint32_t minSize = 16;
34 
35 constexpr size_t maxSize = DMA_MAXSIZE;
36 
37 namespace fs = std::filesystem;
38 
39 /**
40  * @class DMA
41  *
42  * Expose API to initiate transfer of data by DMA
43  *
44  * This class only exposes the public API transferDataHost to transfer data
45  * between BMC and host using DMA. This allows for mocking the transferDataHost
46  * for unit testing purposes.
47  */
48 class DMA
49 {
50   public:
51     /** @brief API to transfer data between BMC and host using DMA
52      *
53      * @param[in] path     - pathname of the file to transfer data from or to
54      * @param[in] offset   - offset in the file
55      * @param[in] length   - length of the data to transfer
56      * @param[in] address  - DMA address on the host
57      * @param[in] upstream - indicates direction of the transfer; true indicates
58      *                       transfer to the host
59      *
60      * @return returns 0 on success, negative errno on failure
61      */
62     int transferDataHost(int fd, uint32_t offset, uint32_t length,
63                          uint64_t address, bool upstream);
64 
65     /** @brief API to transfer data on to unix socket from host using DMA
66      *
67      * @param[in] path     - pathname of the file to transfer data from or to
68      * @param[in] length   - length of the data to transfer
69      * @param[in] address  - DMA address on the host
70      *
71      * @return returns 0 on success, negative errno on failure
72      */
73     int transferHostDataToSocket(int fd, uint32_t length, uint64_t address);
74 };
75 
76 /** @brief Transfer the data between BMC and host using DMA.
77  *
78  *  There is a max size for each DMA operation, transferAll API abstracts this
79  *  and the requested length is broken down into multiple DMA operations if the
80  *  length exceed max size.
81  *
82  * @tparam[in] T - DMA interface type
83  * @param[in] intf - interface passed to invoke DMA transfer
84  * @param[in] command  - PLDM command
85  * @param[in] path     - pathname of the file to transfer data from or to
86  * @param[in] offset   - offset in the file
87  * @param[in] length   - length of the data to transfer
88  * @param[in] address  - DMA address on the host
89  * @param[in] upstream - indicates direction of the transfer; true indicates
90  *                       transfer to the host
91  * @param[in] instanceId - Message's instance id
92  * @return PLDM response message
93  */
94 
95 template <class DMAInterface>
96 Response transferAll(DMAInterface* intf, uint8_t command, fs::path& path,
97                      uint32_t offset, uint32_t length, uint64_t address,
98                      bool upstream, uint8_t instanceId)
99 {
100     uint32_t origLength = length;
101     Response response(sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES, 0);
102     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
103 
104     int flags{};
105     if (upstream)
106     {
107         flags = O_RDONLY;
108     }
109     else if (fs::exists(path))
110     {
111         flags = O_RDWR;
112     }
113     else
114     {
115         flags = O_WRONLY;
116     }
117     int file = open(path.string().c_str(), flags);
118     if (file == -1)
119     {
120         error("File does not exist, path = {FILE_PATH}", "FILE_PATH",
121               path.string());
122         encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
123                                    responsePtr);
124         return response;
125     }
126     pldm::utils::CustomFD fd(file);
127 
128     while (length > dma::maxSize)
129     {
130         auto rc = intf->transferDataHost(fd(), offset, dma::maxSize, address,
131                                          upstream);
132         if (rc < 0)
133         {
134             encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
135                                        responsePtr);
136             return response;
137         }
138 
139         offset += dma::maxSize;
140         length -= dma::maxSize;
141         address += dma::maxSize;
142     }
143 
144     auto rc = intf->transferDataHost(fd(), offset, length, address, upstream);
145     if (rc < 0)
146     {
147         encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
148                                    responsePtr);
149         return response;
150     }
151 
152     encode_rw_file_memory_resp(instanceId, command, PLDM_SUCCESS, origLength,
153                                responsePtr);
154     return response;
155 }
156 
157 } // namespace dma
158 
159 namespace oem_ibm
160 {
161 static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump/resource/entry/";
162 static constexpr auto resDumpEntry = "com.ibm.Dump.Entry.Resource";
163 
164 static constexpr auto certObjPath = "/xyz/openbmc_project/certs/ca/";
165 static constexpr auto certAuthority =
166     "xyz.openbmc_project.PLDM.Provider.Certs.Authority.CSR";
167 class Handler : public CmdHandler
168 {
169   public:
170     Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd,
171             uint8_t hostEid, pldm::InstanceIdDb* instanceIdDb,
172             pldm::requester::Handler<pldm::requester::Request>* handler) :
173         oemPlatformHandler(oemPlatformHandler),
174         hostSockFd(hostSockFd), hostEid(hostEid), instanceIdDb(instanceIdDb),
175         handler(handler)
176     {
177         handlers.emplace(
178             PLDM_READ_FILE_INTO_MEMORY,
179             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
180             return this->readFileIntoMemory(request, payloadLength);
181         });
182         handlers.emplace(
183             PLDM_WRITE_FILE_FROM_MEMORY,
184             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
185             return this->writeFileFromMemory(request, payloadLength);
186         });
187         handlers.emplace(
188             PLDM_WRITE_FILE_BY_TYPE_FROM_MEMORY,
189             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
190             return this->writeFileByTypeFromMemory(request, payloadLength);
191         });
192         handlers.emplace(
193             PLDM_READ_FILE_BY_TYPE_INTO_MEMORY,
194             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
195             return this->readFileByTypeIntoMemory(request, payloadLength);
196         });
197         handlers.emplace(
198             PLDM_READ_FILE_BY_TYPE,
199             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
200             return this->readFileByType(request, payloadLength);
201         });
202         handlers.emplace(
203             PLDM_WRITE_FILE_BY_TYPE,
204             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
205             return this->writeFileByType(request, payloadLength);
206         });
207         handlers.emplace(
208             PLDM_GET_FILE_TABLE,
209             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
210             return this->getFileTable(request, payloadLength);
211         });
212         handlers.emplace(
213             PLDM_READ_FILE,
214             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
215             return this->readFile(request, payloadLength);
216         });
217         handlers.emplace(
218             PLDM_WRITE_FILE,
219             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
220             return this->writeFile(request, payloadLength);
221         });
222         handlers.emplace(
223             PLDM_FILE_ACK,
224             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
225             return this->fileAck(request, payloadLength);
226         });
227         handlers.emplace(
228             PLDM_HOST_GET_ALERT_STATUS,
229             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
230             return this->getAlertStatus(request, payloadLength);
231         });
232         handlers.emplace(
233             PLDM_NEW_FILE_AVAILABLE,
234             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
235             return this->newFileAvailable(request, payloadLength);
236         });
237 
238         resDumpMatcher = std::make_unique<sdbusplus::bus::match_t>(
239             pldm::utils::DBusHandler::getBus(),
240             sdbusplus::bus::match::rules::interfacesAdded() +
241                 sdbusplus::bus::match::rules::argNpath(0, dumpObjPath),
242             [this, hostSockFd, hostEid, instanceIdDb,
243              handler](sdbusplus::message_t& msg) {
244             std::map<std::string,
245                      std::map<std::string, std::variant<std::string, uint32_t>>>
246                 interfaces;
247             sdbusplus::message::object_path path;
248             msg.read(path, interfaces);
249             std::string vspstring;
250             std::string password;
251 
252             for (auto& interface : interfaces)
253             {
254                 if (interface.first == resDumpEntry)
255                 {
256                     for (const auto& property : interface.second)
257                     {
258                         if (property.first == "VSPString")
259                         {
260                             vspstring = std::get<std::string>(property.second);
261                         }
262                         else if (property.first == "Password")
263                         {
264                             password = std::get<std::string>(property.second);
265                         }
266                     }
267                     dbusToFileHandlers
268                         .emplace_back(
269                             std::make_unique<
270                                 pldm::requester::oem_ibm::DbusToFileHandler>(
271                                 hostSockFd, hostEid, instanceIdDb, path,
272                                 handler))
273                         ->processNewResourceDump(vspstring, password);
274                     break;
275                 }
276             }
277         });
278         vmiCertMatcher = std::make_unique<sdbusplus::bus::match_t>(
279             pldm::utils::DBusHandler::getBus(),
280             sdbusplus::bus::match::rules::interfacesAdded() +
281                 sdbusplus::bus::match::rules::argNpath(0, certObjPath),
282             [this, hostSockFd, hostEid, instanceIdDb,
283              handler](sdbusplus::message_t& msg) {
284             std::map<std::string,
285                      std::map<std::string, std::variant<std::string, uint32_t>>>
286                 interfaces;
287             sdbusplus::message::object_path path;
288             msg.read(path, interfaces);
289             std::string csr;
290 
291             for (auto& interface : interfaces)
292             {
293                 if (interface.first == certAuthority)
294                 {
295                     for (const auto& property : interface.second)
296                     {
297                         if (property.first == "CSR")
298                         {
299                             csr = std::get<std::string>(property.second);
300                             auto fileHandle =
301                                 sdbusplus::message::object_path(path)
302                                     .filename();
303 
304                             dbusToFileHandlers
305                                 .emplace_back(
306                                     std::make_unique<pldm::requester::oem_ibm::
307                                                          DbusToFileHandler>(
308                                         hostSockFd, hostEid, instanceIdDb, path,
309                                         handler))
310                                 ->newCsrFileAvailable(csr, fileHandle);
311                             break;
312                         }
313                     }
314                     break;
315                 }
316             }
317         });
318     }
319 
320     /** @brief Handler for readFileIntoMemory command
321      *
322      *  @param[in] request - pointer to PLDM request payload
323      *  @param[in] payloadLength - length of the message
324      *
325      *  @return PLDM response message
326      */
327     Response readFileIntoMemory(const pldm_msg* request, size_t payloadLength);
328 
329     /** @brief Handler for writeFileIntoMemory command
330      *
331      *  @param[in] request - pointer to PLDM request payload
332      *  @param[in] payloadLength - length of the message
333      *
334      *  @return PLDM response message
335      */
336     Response writeFileFromMemory(const pldm_msg* request, size_t payloadLength);
337 
338     /** @brief Handler for writeFileByTypeFromMemory command
339      *
340      *  @param[in] request - pointer to PLDM request payload
341      *  @param[in] payloadLength - length of the message
342      *
343      *  @return PLDM response message
344      */
345 
346     Response writeFileByTypeFromMemory(const pldm_msg* request,
347                                        size_t payloadLength);
348 
349     /** @brief Handler for readFileByTypeIntoMemory command
350      *
351      *  @param[in] request - pointer to PLDM request payload
352      *  @param[in] payloadLength - length of the message
353      *
354      *  @return PLDM response message
355      */
356     Response readFileByTypeIntoMemory(const pldm_msg* request,
357                                       size_t payloadLength);
358 
359     /** @brief Handler for writeFileByType command
360      *
361      *  @param[in] request - pointer to PLDM request payload
362      *  @param[in] payloadLength - length of the message
363      *
364      *  @return PLDM response message
365      */
366     Response readFileByType(const pldm_msg* request, size_t payloadLength);
367 
368     Response writeFileByType(const pldm_msg* request, size_t payloadLength);
369 
370     /** @brief Handler for GetFileTable command
371      *
372      *  @param[in] request - pointer to PLDM request payload
373      *  @param[in] payloadLength - length of the message payload
374      *
375      *  @return PLDM response message
376      */
377     Response getFileTable(const pldm_msg* request, size_t payloadLength);
378 
379     /** @brief Handler for readFile command
380      *
381      *  @param[in] request - PLDM request msg
382      *  @param[in] payloadLength - length of the message payload
383      *
384      *  @return PLDM response message
385      */
386     Response readFile(const pldm_msg* request, size_t payloadLength);
387 
388     /** @brief Handler for writeFile command
389      *
390      *  @param[in] request - PLDM request msg
391      *  @param[in] payloadLength - length of the message payload
392      *
393      *  @return PLDM response message
394      */
395     Response writeFile(const pldm_msg* request, size_t payloadLength);
396 
397     Response fileAck(const pldm_msg* request, size_t payloadLength);
398 
399     /** @brief Handler for getAlertStatus command
400      *
401      *  @param[in] request - PLDM request msg
402      *  @param[in] payloadLength - length of the message payload
403      *
404      *  @return PLDM response message
405      */
406     Response getAlertStatus(const pldm_msg* request, size_t payloadLength);
407 
408     /** @brief Handler for newFileAvailable command
409      *
410      *  @param[in] request - PLDM request msg
411      *  @param[in] payloadLength - length of the message payload
412      *
413      *  @return PLDM response message
414      */
415     Response newFileAvailable(const pldm_msg* request, size_t payloadLength);
416 
417   private:
418     oem_platform::Handler* oemPlatformHandler;
419     int hostSockFd;
420     uint8_t hostEid;
421     pldm::InstanceIdDb* instanceIdDb;
422     using DBusInterfaceAdded = std::vector<std::pair<
423         std::string,
424         std::vector<std::pair<std::string, std::variant<std::string>>>>>;
425     std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>
426         dbusToFileHandler; //!< pointer to send request to Host
427     std::unique_ptr<sdbusplus::bus::match_t>
428         resDumpMatcher;    //!< Pointer to capture the interface added signal
429                            //!< for new resource dump
430     std::unique_ptr<sdbusplus::bus::match_t>
431         vmiCertMatcher;    //!< Pointer to capture the interface added signal
432                            //!< for new csr string
433     /** @brief PLDM request handler */
434     pldm::requester::Handler<pldm::requester::Request>* handler;
435     std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>>
436         dbusToFileHandlers;
437 };
438 
439 } // namespace oem_ibm
440 } // namespace responder
441 } // namespace pldm
442