xref: /openbmc/pldm/oem/ibm/libpldmresponder/file_io.hpp (revision dde014625c1aac2b423cc7dbcf3a189ff58dc233)
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 <sys/stat.h>
14 #include <sys/types.h>
15 #include <unistd.h>
16 
17 #include <phosphor-logging/lg2.hpp>
18 
19 #include <cstdint>
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>
transferAll(DMAInterface * intf,uint8_t command,fs::path & path,uint32_t offset,uint32_t length,uint64_t address,bool upstream,uint8_t instanceId)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 at path '{PATH}' does not exist", "PATH", path);
121         encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
122                                    responsePtr);
123         return response;
124     }
125     pldm::utils::CustomFD fd(file);
126 
127     while (length > dma::maxSize)
128     {
129         auto rc = intf->transferDataHost(fd(), offset, dma::maxSize, address,
130                                          upstream);
131         if (rc < 0)
132         {
133             encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
134                                        responsePtr);
135             return response;
136         }
137 
138         offset += dma::maxSize;
139         length -= dma::maxSize;
140         address += dma::maxSize;
141     }
142 
143     auto rc = intf->transferDataHost(fd(), offset, length, address, upstream);
144     if (rc < 0)
145     {
146         encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
147                                    responsePtr);
148         return response;
149     }
150 
151     encode_rw_file_memory_resp(instanceId, command, PLDM_SUCCESS, origLength,
152                                responsePtr);
153     return response;
154 }
155 
156 } // namespace dma
157 
158 namespace oem_ibm
159 {
160 static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump/resource/entry/";
161 static constexpr auto resDumpEntry = "com.ibm.Dump.Entry.Resource";
162 
163 static constexpr auto certObjPath = "/xyz/openbmc_project/certs/ca/";
164 static constexpr auto certAuthority =
165     "xyz.openbmc_project.PLDM.Provider.Certs.Authority.CSR";
166 class Handler : public CmdHandler
167 {
168   public:
Handler(oem_platform::Handler * oemPlatformHandler,int hostSockFd,uint8_t hostEid,pldm::InstanceIdDb * instanceIdDb,pldm::requester::Handler<pldm::requester::Request> * handler)169     Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd,
170             uint8_t hostEid, pldm::InstanceIdDb* instanceIdDb,
171             pldm::requester::Handler<pldm::requester::Request>* handler) :
172         oemPlatformHandler(oemPlatformHandler)
173     {
174         handlers.emplace(
175             PLDM_READ_FILE_INTO_MEMORY,
176             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
177                 return this->readFileIntoMemory(request, payloadLength);
178             });
179         handlers.emplace(
180             PLDM_WRITE_FILE_FROM_MEMORY,
181             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
182                 return this->writeFileFromMemory(request, payloadLength);
183             });
184         handlers.emplace(
185             PLDM_WRITE_FILE_BY_TYPE_FROM_MEMORY,
186             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
187                 return this->writeFileByTypeFromMemory(request, payloadLength);
188             });
189         handlers.emplace(
190             PLDM_READ_FILE_BY_TYPE_INTO_MEMORY,
191             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
192                 return this->readFileByTypeIntoMemory(request, payloadLength);
193             });
194         handlers.emplace(
195             PLDM_READ_FILE_BY_TYPE,
196             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
197                 return this->readFileByType(request, payloadLength);
198             });
199         handlers.emplace(
200             PLDM_WRITE_FILE_BY_TYPE,
201             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
202                 return this->writeFileByType(request, payloadLength);
203             });
204         handlers.emplace(
205             PLDM_GET_FILE_TABLE,
206             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
207                 return this->getFileTable(request, payloadLength);
208             });
209         handlers.emplace(
210             PLDM_READ_FILE,
211             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
212                 return this->readFile(request, payloadLength);
213             });
214         handlers.emplace(
215             PLDM_WRITE_FILE,
216             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
217                 return this->writeFile(request, payloadLength);
218             });
219         handlers.emplace(
220             PLDM_FILE_ACK,
221             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
222                 return this->fileAck(request, payloadLength);
223             });
224         handlers.emplace(
225             PLDM_HOST_GET_ALERT_STATUS,
226             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
227                 return this->getAlertStatus(request, payloadLength);
228             });
229         handlers.emplace(
230             PLDM_NEW_FILE_AVAILABLE,
231             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
232                 return this->newFileAvailable(request, payloadLength);
233             });
234         handlers.emplace(
235             PLDM_FILE_ACK_WITH_META_DATA,
236             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
237                 return this->fileAckWithMetaData(request, payloadLength);
238             });
239         handlers.emplace(
240             PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA,
241             [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) {
242                 return this->newFileAvailableWithMetaData(request,
243                                                           payloadLength);
244             });
245 
246         resDumpMatcher = std::make_unique<sdbusplus::bus::match_t>(
247             pldm::utils::DBusHandler::getBus(),
248             sdbusplus::bus::match::rules::interfacesAdded() +
249                 sdbusplus::bus::match::rules::argNpath(0, dumpObjPath),
250             [this, hostSockFd, hostEid, instanceIdDb,
251              handler](sdbusplus::message_t& msg) {
252                 std::map<
253                     std::string,
254                     std::map<std::string, std::variant<std::string, uint32_t>>>
255                     interfaces;
256                 sdbusplus::message::object_path path;
257                 msg.read(path, interfaces);
258                 std::string vspstring;
259                 std::string password;
260 
261                 for (const auto& interface : interfaces)
262                 {
263                     if (interface.first == resDumpEntry)
264                     {
265                         for (const auto& property : interface.second)
266                         {
267                             if (property.first == "VSPString")
268                             {
269                                 vspstring =
270                                     std::get<std::string>(property.second);
271                             }
272                             else if (property.first == "Password")
273                             {
274                                 password =
275                                     std::get<std::string>(property.second);
276                             }
277                         }
278                         dbusToFileHandlers
279                             .emplace_back(
280                                 std::make_unique<pldm::requester::oem_ibm::
281                                                      DbusToFileHandler>(
282                                     hostSockFd, hostEid, instanceIdDb, path,
283                                     handler))
284                             ->processNewResourceDump(vspstring, password);
285                         break;
286                     }
287                 }
288             });
289         vmiCertMatcher = std::make_unique<sdbusplus::bus::match_t>(
290             pldm::utils::DBusHandler::getBus(),
291             sdbusplus::bus::match::rules::interfacesAdded() +
292                 sdbusplus::bus::match::rules::argNpath(0, certObjPath),
293             [this, hostSockFd, hostEid, instanceIdDb,
294              handler](sdbusplus::message_t& msg) {
295                 std::map<
296                     std::string,
297                     std::map<std::string, std::variant<std::string, uint32_t>>>
298                     interfaces;
299                 sdbusplus::message::object_path path;
300                 msg.read(path, interfaces);
301                 std::string csr;
302 
303                 for (const auto& interface : interfaces)
304                 {
305                     if (interface.first == certAuthority)
306                     {
307                         for (const auto& property : interface.second)
308                         {
309                             if (property.first == "CSR")
310                             {
311                                 csr = std::get<std::string>(property.second);
312                                 auto fileHandle =
313                                     sdbusplus::message::object_path(path)
314                                         .filename();
315 
316                                 dbusToFileHandlers
317                                     .emplace_back(std::make_unique<
318                                                   pldm::requester::oem_ibm::
319                                                       DbusToFileHandler>(
320                                         hostSockFd, hostEid, instanceIdDb, path,
321                                         handler))
322                                     ->newCsrFileAvailable(csr, fileHandle);
323                                 break;
324                             }
325                         }
326                         break;
327                     }
328                 }
329             });
330     }
331 
332     /** @brief Handler for readFileIntoMemory command
333      *
334      *  @param[in] request - pointer to PLDM request payload
335      *  @param[in] payloadLength - length of the message
336      *
337      *  @return PLDM response message
338      */
339     Response readFileIntoMemory(const pldm_msg* request, size_t payloadLength);
340 
341     /** @brief Handler for writeFileIntoMemory command
342      *
343      *  @param[in] request - pointer to PLDM request payload
344      *  @param[in] payloadLength - length of the message
345      *
346      *  @return PLDM response message
347      */
348     Response writeFileFromMemory(const pldm_msg* request, size_t payloadLength);
349 
350     /** @brief Handler for writeFileByTypeFromMemory command
351      *
352      *  @param[in] request - pointer to PLDM request payload
353      *  @param[in] payloadLength - length of the message
354      *
355      *  @return PLDM response message
356      */
357 
358     Response writeFileByTypeFromMemory(const pldm_msg* request,
359                                        size_t payloadLength);
360 
361     /** @brief Handler for readFileByTypeIntoMemory command
362      *
363      *  @param[in] request - pointer to PLDM request payload
364      *  @param[in] payloadLength - length of the message
365      *
366      *  @return PLDM response message
367      */
368     Response readFileByTypeIntoMemory(const pldm_msg* request,
369                                       size_t payloadLength);
370 
371     /** @brief Handler for writeFileByType command
372      *
373      *  @param[in] request - pointer to PLDM request payload
374      *  @param[in] payloadLength - length of the message
375      *
376      *  @return PLDM response message
377      */
378     Response readFileByType(const pldm_msg* request, size_t payloadLength);
379 
380     Response writeFileByType(const pldm_msg* request, size_t payloadLength);
381 
382     /** @brief Handler for GetFileTable command
383      *
384      *  @param[in] request - pointer to PLDM request payload
385      *  @param[in] payloadLength - length of the message payload
386      *
387      *  @return PLDM response message
388      */
389     Response getFileTable(const pldm_msg* request, size_t payloadLength);
390 
391     /** @brief Handler for readFile command
392      *
393      *  @param[in] request - PLDM request msg
394      *  @param[in] payloadLength - length of the message payload
395      *
396      *  @return PLDM response message
397      */
398     Response readFile(const pldm_msg* request, size_t payloadLength);
399 
400     /** @brief Handler for writeFile command
401      *
402      *  @param[in] request - PLDM request msg
403      *  @param[in] payloadLength - length of the message payload
404      *
405      *  @return PLDM response message
406      */
407     Response writeFile(const pldm_msg* request, size_t payloadLength);
408 
409     Response fileAck(const pldm_msg* request, size_t payloadLength);
410 
411     /** @brief Handler for getAlertStatus command
412      *
413      *  @param[in] request - PLDM request msg
414      *  @param[in] payloadLength - length of the message payload
415      *
416      *  @return PLDM response message
417      */
418     Response getAlertStatus(const pldm_msg* request, size_t payloadLength);
419 
420     /** @brief Handler for newFileAvailable command
421      *
422      *  @param[in] request - PLDM request msg
423      *  @param[in] payloadLength - length of the message payload
424      *
425      *  @return PLDM response message
426      */
427     Response newFileAvailable(const pldm_msg* request, size_t payloadLength);
428 
429     /** @brief Handler for fileAckWithMetaData command
430      *
431      *  @param[in] request - PLDM request msg
432      *  @param[in] payloadLength - length of the message payload
433      *
434      *  @return PLDM response message
435      */
436     Response fileAckWithMetaData(const pldm_msg* request, size_t payloadLength);
437 
438     /** @brief Handler for newFileAvailableWithMetaData command
439      *
440      *  @param[in] request - PLDM request msg
441      *  @param[in] payloadLength - length of the message payload
442      *
443      *  @return PLDM response messsage
444      */
445     Response newFileAvailableWithMetaData(const pldm_msg* request,
446                                           size_t payloadLength);
447 
448   private:
449     oem_platform::Handler* oemPlatformHandler;
450     using DBusInterfaceAdded = std::vector<std::pair<
451         std::string,
452         std::vector<std::pair<std::string, std::variant<std::string>>>>>;
453     std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>
454         dbusToFileHandler; //!< pointer to send request to Host
455     std::unique_ptr<sdbusplus::bus::match_t>
456         resDumpMatcher;    //!< Pointer to capture the interface added signal
457                            //!< for new resource dump
458     std::unique_ptr<sdbusplus::bus::match_t>
459         vmiCertMatcher;    //!< Pointer to capture the interface added signal
460                            //!< for new csr string
461     /** @brief PLDM request handler */
462     std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>>
463         dbusToFileHandlers;
464 };
465 
466 } // namespace oem_ibm
467 } // namespace responder
468 } // namespace pldm
469