diff --git a/include/ibm/locks.hpp b/include/ibm/locks.hpp
index dcd110f..e191959 100644
--- a/include/ibm/locks.hpp
+++ b/include/ibm/locks.hpp
@@ -27,13 +27,13 @@
 using Rc =
     std::pair<bool, std::variant<uint32_t, std::pair<uint32_t, LockRequest>>>;
 using RcRelaseLock = std::pair<bool, std::pair<uint32_t, LockRequest>>;
-using RcGetLocklist = std::pair<
-    bool,
-    std::variant<std::string, std::vector<std::pair<uint32_t, LockRequests>>>>;
+using RcGetLockList =
+    std::variant<std::string, std::vector<std::pair<uint32_t, LockRequests>>>;
 using ListOfTransactionIds = std::vector<uint32_t>;
 using RcAcquireLock = std::pair<bool, std::variant<Rc, std::pair<bool, int>>>;
 using RcReleaseLockApi = std::pair<bool, std::variant<bool, RcRelaseLock>>;
 using SessionFlags = std::pair<SType, SType>;
+using ListOfSessionIds = std::vector<std::string>;
 
 class Lock
 {
@@ -142,6 +142,12 @@
     RcReleaseLockApi releaseLock(const ListOfTransactionIds &,
                                  const SessionFlags &);
 
+    /*
+     * This function implements the logic for getting the list of locks obtained
+     * by a particular management console.
+     */
+    RcGetLockList getLockList(const ListOfSessionIds &);
+
     Lock()
     {
         transactionId = 0;
@@ -149,6 +155,39 @@
 
 } lockObject;
 
+RcGetLockList Lock::getLockList(const ListOfSessionIds &listSessionId)
+{
+
+    std::vector<std::pair<uint32_t, LockRequests>> lockList;
+
+    if (!lockTable.empty())
+    {
+        for (const auto &i : listSessionId)
+        {
+            auto it = lockTable.begin();
+            while (it != lockTable.end())
+            {
+                // Check if session id of this entry matches with session id
+                // given
+                if (std::get<0>(it->second[0]) == i)
+                {
+                    BMCWEB_LOG_DEBUG << "Session id is found in the locktable";
+
+                    // Push the whole lock record into a vector for returning
+                    // the json
+                    lockList.push_back(std::make_pair(it->first, it->second));
+                }
+                // Go to next entry in map
+                it++;
+            }
+        }
+    }
+    // we may have found at least one entry with the given session id
+    // return the json list of lock records pertaining to the given
+    // session id, or send an empty list if lock table is empty
+    return lockList;
+}
+
 RcReleaseLockApi Lock::releaseLock(const ListOfTransactionIds &p,
                                    const SessionFlags &ids)
 {
diff --git a/include/ibm/management_console_rest.hpp b/include/ibm/management_console_rest.hpp
index a4bf31e..2e3f56c 100644
--- a/include/ibm/management_console_rest.hpp
+++ b/include/ibm/management_console_rest.hpp
@@ -19,10 +19,9 @@
 using LockRequest = std::tuple<SType, SType, SType, uint64_t, SegmentFlags>;
 using LockRequests = std::vector<LockRequest>;
 using Rc = std::pair<bool, std::variant<uint32_t, LockRequest>>;
-using RcGetLockList = std::pair<
-    bool,
-    std::variant<std::string, std::vector<std::pair<uint32_t, LockRequests>>>>;
-
+using RcGetLockList =
+    std::variant<std::string, std::vector<std::pair<uint32_t, LockRequests>>>;
+using ListOfSessionIds = std::vector<std::string>;
 namespace crow
 {
 namespace ibm_mc
@@ -474,6 +473,47 @@
     }
 }
 
+void handleGetLockListAPI(const crow::Request &req, crow::Response &res,
+                          const ListOfSessionIds &listSessionIds)
+{
+    BMCWEB_LOG_DEBUG << listSessionIds.size();
+
+    auto status = crow::ibm_mc_lock::lockObject.getLockList(listSessionIds);
+    auto var = std::get<std::vector<std::pair<uint32_t, LockRequests>>>(status);
+
+    nlohmann::json lockRecords = nlohmann::json::array();
+
+    for (const auto &transactionId : var)
+    {
+        for (const auto &lockRecord : transactionId.second)
+        {
+            nlohmann::json returnJson;
+
+            returnJson["TransactionID"] = transactionId.first;
+            returnJson["SessionID"] = std::get<0>(lockRecord);
+            returnJson["HMCID"] = std::get<1>(lockRecord);
+            returnJson["LockType"] = std::get<2>(lockRecord);
+            returnJson["ResourceID"] = std::get<3>(lockRecord);
+
+            nlohmann::json segments;
+            nlohmann::json segmentInfoArray = nlohmann::json::array();
+
+            for (const auto &segment : std::get<4>(lockRecord))
+            {
+                segments["LockFlag"] = segment.first;
+                segments["SegmentLength"] = segment.second;
+                segmentInfoArray.push_back(segments);
+            }
+
+            returnJson["SegmentFlags"] = segmentInfoArray;
+            lockRecords.push_back(returnJson);
+        }
+    }
+    res.result(boost::beast::http::status::ok);
+    res.jsonValue["Records"] = lockRecords;
+    res.end();
+}
+
 template <typename... Middlewares> void requestRoutes(Crow<Middlewares...> &app)
 {
 
@@ -554,6 +594,22 @@
 
                 handleReleaseLockAPI(req, res, listTransactionIds);
             });
+    BMCWEB_ROUTE(app, "/ibm/v1/HMC/LockService/Actions/LockService.GetLockList")
+        .requires({"ConfigureComponents", "ConfigureManager"})
+        .methods("POST"_method)(
+            [](const crow::Request &req, crow::Response &res) {
+                ListOfSessionIds listSessionIds;
+
+                if (!redfish::json_util::readJson(req, res, "SessionIDs",
+                                                  listSessionIds))
+                {
+                    res.result(boost::beast::http::status::bad_request);
+                    res.end();
+                    return;
+                }
+
+                handleGetLockListAPI(req, res, listSessionIds);
+            });
 }
 
 } // namespace ibm_mc