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