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