xref: /openbmc/bmcweb/redfish-core/lib/pcie.hpp (revision cfe3bc0a) 
1 /*
2 // Copyright (c) 2018 Intel 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 
17 #pragma once
18 
19 #include "app.hpp"
20 #include "dbus_utility.hpp"
21 #include "query.hpp"
22 #include "registries/privilege_registry.hpp"
23 #include "utils/collection.hpp"
24 #include "utils/dbus_utils.hpp"
25 #include "utils/pcie_util.hpp"
26 
27 #include <boost/system/linux_error.hpp>
28 #include <boost/url/format.hpp>
29 #include <sdbusplus/asio/property.hpp>
30 #include <sdbusplus/unpack_properties.hpp>
31 
32 namespace redfish
33 {
34 
35 static constexpr const char* inventoryPath = "/xyz/openbmc_project/inventory";
36 static constexpr std::array<std::string_view, 1> pcieDeviceInterface = {
37     "xyz.openbmc_project.Inventory.Item.PCIeDevice"};
38 
39 static inline void handlePCIeDevicePath(
40     const std::string& pcieDeviceId,
41     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
42     const dbus::utility::MapperGetSubTreePathsResponse& pcieDevicePaths,
43     const std::function<void(const std::string& pcieDevicePath,
44                              const std::string& service)>& callback)
45 
46 {
47     for (const std::string& pcieDevicePath : pcieDevicePaths)
48     {
49         std::string pciecDeviceName =
50             sdbusplus::message::object_path(pcieDevicePath).filename();
51         if (pciecDeviceName.empty() || pciecDeviceName != pcieDeviceId)
52         {
53             continue;
54         }
55 
56         dbus::utility::getDbusObject(
57             pcieDevicePath, {},
58             [pcieDevicePath, asyncResp,
59              callback](const boost::system::error_code& ec,
60                        const dbus::utility::MapperGetObject& object) {
61             if (ec || object.empty())
62             {
63                 BMCWEB_LOG_ERROR << "DBUS response error " << ec;
64                 messages::internalError(asyncResp->res);
65                 return;
66             }
67             callback(pcieDevicePath, object.begin()->first);
68             });
69         return;
70     }
71 
72     BMCWEB_LOG_WARNING << "PCIe Device not found";
73     messages::resourceNotFound(asyncResp->res, "PCIeDevice", pcieDeviceId);
74 }
75 
76 static inline void getValidPCIeDevicePath(
77     const std::string& pcieDeviceId,
78     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
79     const std::function<void(const std::string& pcieDevicePath,
80                              const std::string& service)>& callback)
81 {
82     dbus::utility::getSubTreePaths(
83         inventoryPath, 0, pcieDeviceInterface,
84         [pcieDeviceId, asyncResp,
85          callback](const boost::system::error_code& ec,
86                    const dbus::utility::MapperGetSubTreePathsResponse&
87                        pcieDevicePaths) {
88         if (ec)
89         {
90             BMCWEB_LOG_ERROR << "D-Bus response error on GetSubTree " << ec;
91             messages::internalError(asyncResp->res);
92             return;
93         }
94         handlePCIeDevicePath(pcieDeviceId, asyncResp, pcieDevicePaths,
95                              callback);
96         return;
97         });
98 }
99 
100 static inline void handlePCIeDeviceCollectionGet(
101     crow::App& app, const crow::Request& req,
102     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
103     const std::string& systemName)
104 {
105     if (!redfish::setUpRedfishRoute(app, req, asyncResp))
106     {
107         return;
108     }
109     if constexpr (bmcwebEnableMultiHost)
110     {
111         // Option currently returns no systems.  TBD
112         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
113                                    systemName);
114         return;
115     }
116     if (systemName != "system")
117     {
118         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
119                                    systemName);
120         return;
121     }
122 
123     asyncResp->res.addHeader(boost::beast::http::field::link,
124                              "</redfish/v1/JsonSchemas/PCIeDeviceCollection/"
125                              "PCIeDeviceCollection.json>; rel=describedby");
126     asyncResp->res.jsonValue["@odata.type"] =
127         "#PCIeDeviceCollection.PCIeDeviceCollection";
128     asyncResp->res.jsonValue["@odata.id"] =
129         "/redfish/v1/Systems/system/PCIeDevices";
130     asyncResp->res.jsonValue["Name"] = "PCIe Device Collection";
131     asyncResp->res.jsonValue["Description"] = "Collection of PCIe Devices";
132     asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
133     asyncResp->res.jsonValue["Members@odata.count"] = 0;
134 
135     pcie_util::getPCIeDeviceList(asyncResp, "Members");
136 }
137 
138 inline void requestRoutesSystemPCIeDeviceCollection(App& app)
139 {
140     /**
141      * Functions triggers appropriate requests on DBus
142      */
143     BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/PCIeDevices/")
144         .privileges(redfish::privileges::getPCIeDeviceCollection)
145         .methods(boost::beast::http::verb::get)(
146             std::bind_front(handlePCIeDeviceCollectionGet, std::ref(app)));
147 }
148 
149 inline void
150     getPCIeDeviceHealth(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
151                         const std::string& pcieDevicePath,
152                         const std::string& service)
153 {
154     sdbusplus::asio::getProperty<bool>(
155         *crow::connections::systemBus, service, pcieDevicePath,
156         "xyz.openbmc_project.State.Decorator.OperationalStatus", "Functional",
157         [asyncResp](const boost::system::error_code& ec, const bool value) {
158         if (ec)
159         {
160             if (ec.value() != EBADR)
161             {
162                 BMCWEB_LOG_ERROR << "DBUS response error for Health "
163                                  << ec.value();
164                 messages::internalError(asyncResp->res);
165             }
166             return;
167         }
168 
169         if (!value)
170         {
171             asyncResp->res.jsonValue["Status"]["Health"] = "Critical";
172         }
173         });
174 }
175 
176 inline void
177     getPCIeDeviceState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
178                        const std::string& pcieDevicePath,
179                        const std::string& service)
180 {
181     sdbusplus::asio::getProperty<bool>(
182         *crow::connections::systemBus, service, pcieDevicePath,
183         "xyz.openbmc_project.Inventory.Item", "Present",
184         [asyncResp](const boost::system::error_code& ec, const bool value) {
185         if (ec)
186         {
187             if (ec.value() != EBADR)
188             {
189                 BMCWEB_LOG_ERROR << "DBUS response error for State";
190                 messages::internalError(asyncResp->res);
191             }
192             return;
193         }
194 
195         if (!value)
196         {
197             asyncResp->res.jsonValue["Status"]["State"] = "Absent";
198         }
199         });
200 }
201 
202 inline void
203     getPCIeDeviceAsset(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
204                        const std::string& pcieDevicePath,
205                        const std::string& service)
206 {
207     sdbusplus::asio::getAllProperties(
208         *crow::connections::systemBus, service, pcieDevicePath,
209         "xyz.openbmc_project.Inventory.Decorator.Asset",
210         [pcieDevicePath, asyncResp{asyncResp}](
211             const boost::system::error_code& ec,
212             const dbus::utility::DBusPropertiesMap& assetList) {
213         if (ec)
214         {
215             if (ec.value() != EBADR)
216             {
217                 BMCWEB_LOG_ERROR << "DBUS response error for Properties"
218                                  << ec.value();
219                 messages::internalError(asyncResp->res);
220             }
221             return;
222         }
223 
224         const std::string* manufacturer = nullptr;
225         const std::string* model = nullptr;
226         const std::string* partNumber = nullptr;
227         const std::string* serialNumber = nullptr;
228         const std::string* sparePartNumber = nullptr;
229 
230         const bool success = sdbusplus::unpackPropertiesNoThrow(
231             dbus_utils::UnpackErrorPrinter(), assetList, "Manufacturer",
232             manufacturer, "Model", model, "PartNumber", partNumber,
233             "SerialNumber", serialNumber, "SparePartNumber", sparePartNumber);
234 
235         if (!success)
236         {
237             messages::internalError(asyncResp->res);
238             return;
239         }
240 
241         if (manufacturer != nullptr)
242         {
243             asyncResp->res.jsonValue["Manufacturer"] = *manufacturer;
244         }
245         if (model != nullptr)
246         {
247             asyncResp->res.jsonValue["Model"] = *model;
248         }
249 
250         if (partNumber != nullptr)
251         {
252             asyncResp->res.jsonValue["PartNumber"] = *partNumber;
253         }
254 
255         if (serialNumber != nullptr)
256         {
257             asyncResp->res.jsonValue["SerialNumber"] = *serialNumber;
258         }
259 
260         if (sparePartNumber != nullptr && !sparePartNumber->empty())
261         {
262             asyncResp->res.jsonValue["SparePartNumber"] = *sparePartNumber;
263         }
264         });
265 }
266 
267 inline void addPCIeDeviceProperties(
268     crow::Response& resp, const std::string& pcieDeviceId,
269     const dbus::utility::DBusPropertiesMap& pcieDevProperties)
270 {
271     const std::string* deviceType = nullptr;
272     const std::string* generationInUse = nullptr;
273     const int64_t* lanesInUse = nullptr;
274 
275     const bool success = sdbusplus::unpackPropertiesNoThrow(
276         dbus_utils::UnpackErrorPrinter(), pcieDevProperties, "DeviceType",
277         deviceType, "GenerationInUse", generationInUse, "LanesInUse",
278         lanesInUse);
279 
280     if (!success)
281     {
282         messages::internalError(resp);
283         return;
284     }
285 
286     if (deviceType != nullptr && !deviceType->empty())
287     {
288         resp.jsonValue["PCIeInterface"]["DeviceType"] = *deviceType;
289     }
290 
291     if (generationInUse != nullptr)
292     {
293         std::optional<pcie_device::PCIeTypes> redfishGenerationInUse =
294             pcie_util::redfishPcieGenerationFromDbus(*generationInUse);
295 
296         if (!redfishGenerationInUse)
297         {
298             messages::internalError(resp);
299             return;
300         }
301         if (*redfishGenerationInUse != pcie_device::PCIeTypes::Invalid)
302         {
303             resp.jsonValue["PCIeInterface"]["PCIeType"] =
304                 *redfishGenerationInUse;
305         }
306     }
307 
308     // The default value of LanesInUse is 0, and the field will be
309     // left as off if it is a default value.
310     if (lanesInUse != nullptr && *lanesInUse != 0)
311     {
312         resp.jsonValue["PCIeInterface"]["LanesInUse"] = *lanesInUse;
313     }
314 
315     resp.jsonValue["PCIeFunctions"]["@odata.id"] = boost::urls::format(
316         "/redfish/v1/Systems/system/PCIeDevices/{}/PCIeFunctions",
317         pcieDeviceId);
318 }
319 
320 inline void getPCIeDeviceProperties(
321     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
322     const std::string& pcieDevicePath, const std::string& service,
323     const std::function<void(
324         const dbus::utility::DBusPropertiesMap& pcieDevProperties)>&& callback)
325 {
326     sdbusplus::asio::getAllProperties(
327         *crow::connections::systemBus, service, pcieDevicePath,
328         "xyz.openbmc_project.Inventory.Item.PCIeDevice",
329         [asyncResp,
330          callback](const boost::system::error_code& ec,
331                    const dbus::utility::DBusPropertiesMap& pcieDevProperties) {
332         if (ec)
333         {
334             if (ec.value() != EBADR)
335             {
336                 BMCWEB_LOG_ERROR << "DBUS response error for Properties";
337                 messages::internalError(asyncResp->res);
338             }
339             return;
340         }
341         callback(pcieDevProperties);
342         });
343 }
344 
345 inline void addPCIeDeviceCommonProperties(
346     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
347     const std::string& pcieDeviceId)
348 {
349     asyncResp->res.addHeader(
350         boost::beast::http::field::link,
351         "</redfish/v1/JsonSchemas/PCIeDevice/PCIeDevice.json>; rel=describedby");
352     asyncResp->res.jsonValue["@odata.type"] = "#PCIeDevice.v1_9_0.PCIeDevice";
353     asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
354         "/redfish/v1/Systems/system/PCIeDevices/{}", pcieDeviceId);
355     asyncResp->res.jsonValue["Name"] = "PCIe Device";
356     asyncResp->res.jsonValue["Id"] = pcieDeviceId;
357     asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
358     asyncResp->res.jsonValue["Status"]["Health"] = "OK";
359 }
360 
361 inline void
362     handlePCIeDeviceGet(App& app, const crow::Request& req,
363                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
364                         const std::string& systemName,
365                         const std::string& pcieDeviceId)
366 {
367     if (!redfish::setUpRedfishRoute(app, req, asyncResp))
368     {
369         return;
370     }
371     if constexpr (bmcwebEnableMultiHost)
372     {
373         // Option currently returns no systems.  TBD
374         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
375                                    systemName);
376         return;
377     }
378     if (systemName != "system")
379     {
380         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
381                                    systemName);
382         return;
383     }
384 
385     getValidPCIeDevicePath(
386         pcieDeviceId, asyncResp,
387         [asyncResp, pcieDeviceId](const std::string& pcieDevicePath,
388                                   const std::string& service) {
389         addPCIeDeviceCommonProperties(asyncResp, pcieDeviceId);
390         getPCIeDeviceAsset(asyncResp, pcieDevicePath, service);
391         getPCIeDeviceState(asyncResp, pcieDevicePath, service);
392         getPCIeDeviceHealth(asyncResp, pcieDevicePath, service);
393         getPCIeDeviceProperties(
394             asyncResp, pcieDevicePath, service,
395             [asyncResp, pcieDeviceId](
396                 const dbus::utility::DBusPropertiesMap& pcieDevProperties) {
397             addPCIeDeviceProperties(asyncResp->res, pcieDeviceId,
398                                     pcieDevProperties);
399             });
400         });
401 }
402 
403 inline void requestRoutesSystemPCIeDevice(App& app)
404 {
405     BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/PCIeDevices/<str>/")
406         .privileges(redfish::privileges::getPCIeDevice)
407         .methods(boost::beast::http::verb::get)(
408             std::bind_front(handlePCIeDeviceGet, std::ref(app)));
409 }
410 
411 inline void addPCIeFunctionList(
412     crow::Response& res, const std::string& pcieDeviceId,
413     const dbus::utility::DBusPropertiesMap& pcieDevProperties)
414 {
415     nlohmann::json& pcieFunctionList = res.jsonValue["Members"];
416     pcieFunctionList = nlohmann::json::array();
417     static constexpr const int maxPciFunctionNum = 8;
418 
419     for (int functionNum = 0; functionNum < maxPciFunctionNum; functionNum++)
420     {
421         // Check if this function exists by
422         // looking for a device ID
423         std::string devIDProperty = "Function" + std::to_string(functionNum) +
424                                     "DeviceId";
425         const std::string* property = nullptr;
426         for (const auto& propEntry : pcieDevProperties)
427         {
428             if (propEntry.first == devIDProperty)
429             {
430                 property = std::get_if<std::string>(&propEntry.second);
431                 break;
432             }
433         }
434         if (property == nullptr || property->empty())
435         {
436             continue;
437         }
438 
439         nlohmann::json::object_t pcieFunction;
440         pcieFunction["@odata.id"] = boost::urls::format(
441             "/redfish/v1/Systems/system/PCIeDevices/{}/PCIeFunctions/{}",
442             pcieDeviceId, std::to_string(functionNum));
443         pcieFunctionList.emplace_back(std::move(pcieFunction));
444     }
445     res.jsonValue["PCIeFunctions@odata.count"] = pcieFunctionList.size();
446 }
447 
448 inline void handlePCIeFunctionCollectionGet(
449     App& app, const crow::Request& req,
450     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
451     const std::string& systemName, const std::string& pcieDeviceId)
452 {
453     if (!redfish::setUpRedfishRoute(app, req, asyncResp))
454     {
455         return;
456     }
457     if constexpr (bmcwebEnableMultiHost)
458     {
459         // Option currently returns no systems.  TBD
460         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
461                                    systemName);
462         return;
463     }
464 
465     getValidPCIeDevicePath(
466         pcieDeviceId, asyncResp,
467         [asyncResp, pcieDeviceId](const std::string& pcieDevicePath,
468                                   const std::string& service) {
469         asyncResp->res.addHeader(
470             boost::beast::http::field::link,
471             "</redfish/v1/JsonSchemas/PCIeFunctionCollection/PCIeFunctionCollection.json>; rel=describedby");
472         asyncResp->res.jsonValue["@odata.type"] =
473             "#PCIeFunctionCollection.PCIeFunctionCollection";
474         asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
475             "/redfish/v1/Systems/system/PCIeDevices/{}/PCIeFunctions",
476             pcieDeviceId);
477         asyncResp->res.jsonValue["Name"] = "PCIe Function Collection";
478         asyncResp->res.jsonValue["Description"] =
479             "Collection of PCIe Functions for PCIe Device " + pcieDeviceId;
480         getPCIeDeviceProperties(
481             asyncResp, pcieDevicePath, service,
482             [asyncResp, pcieDeviceId](
483                 const dbus::utility::DBusPropertiesMap& pcieDevProperties) {
484             addPCIeFunctionList(asyncResp->res, pcieDeviceId,
485                                 pcieDevProperties);
486             });
487         });
488 }
489 
490 inline void requestRoutesSystemPCIeFunctionCollection(App& app)
491 {
492     /**
493      * Functions triggers appropriate requests on DBus
494      */
495     BMCWEB_ROUTE(app,
496                  "/redfish/v1/Systems/<str>/PCIeDevices/<str>/PCIeFunctions/")
497         .privileges(redfish::privileges::getPCIeFunctionCollection)
498         .methods(boost::beast::http::verb::get)(
499             std::bind_front(handlePCIeFunctionCollectionGet, std::ref(app)));
500 }
501 
502 inline bool validatePCIeFunctionId(
503     uint64_t pcieFunctionId,
504     const dbus::utility::DBusPropertiesMap& pcieDevProperties)
505 {
506     std::string functionName = "Function" + std::to_string(pcieFunctionId);
507     std::string devIDProperty = functionName + "DeviceId";
508 
509     const std::string* devIdProperty = nullptr;
510     for (const auto& property : pcieDevProperties)
511     {
512         if (property.first == devIDProperty)
513         {
514             devIdProperty = std::get_if<std::string>(&property.second);
515             break;
516         }
517     }
518     return (devIdProperty != nullptr && !devIdProperty->empty());
519 }
520 
521 inline void addPCIeFunctionProperties(
522     crow::Response& resp, uint64_t pcieFunctionId,
523     const dbus::utility::DBusPropertiesMap& pcieDevProperties)
524 {
525     std::string functionName = "Function" + std::to_string(pcieFunctionId);
526     for (const auto& property : pcieDevProperties)
527     {
528         const std::string* strProperty =
529             std::get_if<std::string>(&property.second);
530 
531         if (property.first == functionName + "DeviceId")
532         {
533             resp.jsonValue["DeviceId"] = *strProperty;
534         }
535         if (property.first == functionName + "VendorId")
536         {
537             resp.jsonValue["VendorId"] = *strProperty;
538         }
539         // TODO: FunctionType and DeviceClass are Redfish enums. The D-Bus
540         // property strings should be mapped correctly to ensure these
541         // strings are Redfish enum values. For now just check for empty.
542         if (property.first == functionName + "FunctionType")
543         {
544             if (!strProperty->empty())
545             {
546                 resp.jsonValue["FunctionType"] = *strProperty;
547             }
548         }
549         if (property.first == functionName + "DeviceClass")
550         {
551             if (!strProperty->empty())
552             {
553                 resp.jsonValue["DeviceClass"] = *strProperty;
554             }
555         }
556         if (property.first == functionName + "ClassCode")
557         {
558             resp.jsonValue["ClassCode"] = *strProperty;
559         }
560         if (property.first == functionName + "RevisionId")
561         {
562             resp.jsonValue["RevisionId"] = *strProperty;
563         }
564         if (property.first == functionName + "SubsystemId")
565         {
566             resp.jsonValue["SubsystemId"] = *strProperty;
567         }
568         if (property.first == functionName + "SubsystemVendorId")
569         {
570             resp.jsonValue["SubsystemVendorId"] = *strProperty;
571         }
572     }
573 }
574 
575 inline void addPCIeFunctionCommonProperties(crow::Response& resp,
576                                             const std::string& pcieDeviceId,
577                                             uint64_t pcieFunctionId)
578 {
579     resp.addHeader(
580         boost::beast::http::field::link,
581         "</redfish/v1/JsonSchemas/PCIeFunction/PCIeFunction.json>; rel=describedby");
582     resp.jsonValue["@odata.type"] = "#PCIeFunction.v1_2_3.PCIeFunction";
583     resp.jsonValue["@odata.id"] = boost::urls::format(
584         "/redfish/v1/Systems/system/PCIeDevices/{}/PCIeFunctions/{}",
585         pcieDeviceId, std::to_string(pcieFunctionId));
586     resp.jsonValue["Name"] = "PCIe Function";
587     resp.jsonValue["Id"] = std::to_string(pcieFunctionId);
588     resp.jsonValue["FunctionId"] = pcieFunctionId;
589     resp.jsonValue["Links"]["PCIeDevice"]["@odata.id"] = boost::urls::format(
590         "/redfish/v1/Systems/system/PCIeDevices/{}", pcieDeviceId);
591 }
592 
593 inline void
594     handlePCIeFunctionGet(App& app, const crow::Request& req,
595                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
596                           const std::string& systemName,
597                           const std::string& pcieDeviceId,
598                           const std::string& pcieFunctionIdStr)
599 {
600     if (!redfish::setUpRedfishRoute(app, req, asyncResp))
601     {
602         return;
603     }
604     if constexpr (bmcwebEnableMultiHost)
605     {
606         // Option currently returns no systems.  TBD
607         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
608                                    systemName);
609         return;
610     }
611     if (systemName != "system")
612     {
613         messages::resourceNotFound(asyncResp->res, "ComputerSystem",
614                                    systemName);
615         return;
616     }
617 
618     uint64_t pcieFunctionId = 0;
619     std::from_chars_result result = std::from_chars(
620         &*pcieFunctionIdStr.begin(), &*pcieFunctionIdStr.end(), pcieFunctionId);
621     if (result.ec != std::errc{} || result.ptr != &*pcieFunctionIdStr.end())
622     {
623         messages::resourceNotFound(asyncResp->res, "PCIeFunction",
624                                    pcieFunctionIdStr);
625         return;
626     }
627 
628     getValidPCIeDevicePath(pcieDeviceId, asyncResp,
629                            [asyncResp, pcieDeviceId,
630                             pcieFunctionId](const std::string& pcieDevicePath,
631                                             const std::string& service) {
632         getPCIeDeviceProperties(
633             asyncResp, pcieDevicePath, service,
634             [asyncResp, pcieDeviceId, pcieFunctionId](
635                 const dbus::utility::DBusPropertiesMap& pcieDevProperties) {
636             addPCIeFunctionCommonProperties(asyncResp->res, pcieDeviceId,
637                                             pcieFunctionId);
638             addPCIeFunctionProperties(asyncResp->res, pcieFunctionId,
639                                       pcieDevProperties);
640             });
641     });
642 }
643 
644 inline void requestRoutesSystemPCIeFunction(App& app)
645 {
646     BMCWEB_ROUTE(
647         app, "/redfish/v1/Systems/<str>/PCIeDevices/<str>/PCIeFunctions/<str>/")
648         .privileges(redfish::privileges::getPCIeFunction)
649         .methods(boost::beast::http::verb::get)(
650             std::bind_front(handlePCIeFunctionGet, std::ref(app)));
651 }
652 
653 } // namespace redfish
654