Guard changes

README.md

@@ -34,14 +34,15 @@ GUARD Tool
 Usage: guard [OPTIONS]
 
 Options:
-  -h,--help              Use the below listed functions.
-                         Warning: Don't try guard on non guardable units
-                         (sys, perv)
-  -c,--create TEXT       Create GUARD record, expects physical path as input.
-  -d,--delete TEXT       Delete GUARD record, expects physical path as input.
-  -l,--list              Listing of GUARDed resources.
-  -r,--clearall          Clears GUARD states for all resources.
-  -v,--version           Version of GUARD tool.
+  -h,--help                Guard CLI tool options
+  -c,--create TEXT         Create Guard record, expects physical path as input
+  -i,--invalidate TEXT     Invalidate a single Guard record, expects physical
+                           path as input
+  -I,--invalidate-all      Invalidates all the Guard records
+  -l,--list                List all the GUARD'ed resources
+  -r,--reset               Erase all the Guard records
+  -v,--version             Version of GUARD tool
+
 ```
 **Note:** Physical path can be fetched from device tree, using ATTR_PHYS_DEV_PATH
 attribute of the corresponding target.
@@ -64,11 +65,15 @@ guard -l
 ID       | ERROR    |  Type  | Path 
 00000001 | 00000000 | manual | physical:sys-0/node-0/proc-0/mc-0/mi-0/mcc-0
 ```
-* To clear all the guard records
+* To erase all the guard records
 ```
 guard -r
 ```
-* To clear a particular guard record
+* To invalidate a single guard record
+```
+guard -i sys-0/node-0/proc-0/mc-0/mi-0/mcc-0
+```
+* To invalidate all the guard records
 ```
-guard -d sys-0/node-0/proc-0/mc-0/mi-0/mcc-0
+guard -I
 ```

guard.cpp

@@ -2,47 +2,83 @@
 #include "libguard/guard_interface.hpp"
 #include "libguard/include/guard_record.hpp"
 
+#include <config.h>
+
 #include <CLI/CLI.hpp>
 
 using namespace std;
 using namespace openpower::guard;
 
-void guardList()
+void guardList(bool displayResolved)
 {
     auto records = getAll();
     if (!records.size())
     {
         std::cout << "No Records to display" << std::endl;
         return;
     }
-    std::cout << "ID       | ERROR    |  Type  | Path " << std::endl;
+
+    bool isHeaderPrinted = false;
     for (const auto& elem : records)
     {
-        if (elem.errType != GARD_Reconfig)
+        // Not to print guard records with errorlog type set as GARD_Reconfig
+        // As guard below type records are for internal usage only.
+        if (elem.errType == GARD_Reconfig)
+        {
+            continue;
+        }
+        // To list resolved records as user wants to list resolved records
+        else if (displayResolved && (elem.recordId != GUARD_RESOLVED))
+        {
+            continue;
+        }
+        // To list unresolved records as user wants to list unresolved records
+        else if (!displayResolved && (elem.recordId == GUARD_RESOLVED))
+        {
+            continue;
+        }
+
+        // Don't print the header if already printed header since
+        // records mixed of resolved and unresolved records so if have
+        // only either one in retrieved records and user tried to see opposite
+        // one then we should not print header else user will get confused.
+        if (!isHeaderPrinted)
+        {
+            std::cout << "ID       | ERROR    |  Type  | Path " << std::endl;
+            isHeaderPrinted = true;
+        }
+
+        std::cout << std::hex << std::setw(8) << std::setfill('0')
+                  << elem.recordId;
+
+        std::cout << " | ";
+        std::cout << std::hex << std::setw(8) << std::setfill('0')
+                  << elem.elogId;
+
+        std::cout << " | ";
+        std::optional<std::string> gReasonToStr =
+            guardReasonToStr(elem.errType);
+        std::cout << *gReasonToStr;
+
+        std::cout << " | ";
+        std::optional<std::string> physicalPath =
+            getPhysicalPath(elem.targetId);
+        if (!physicalPath)
+        {
+            std::cout << "Unknown ";
+        }
+        else
         {
-            std::cout << std::hex << std::setw(8) << std::setfill('0')
-                      << elem.recordId;
-            std::cout << " | ";
-            std::cout << std::hex << std::setw(8) << std::setfill('0')
-                      << elem.elogId;
-
-            std::cout << " | ";
-            std::optional<std::string> gReasonToStr =
-                guardReasonToStr(elem.errType);
-            std::cout << *gReasonToStr;
-            std::cout << " | ";
-            std::optional<std::string> physicalPath =
-                getPhysicalPath(elem.targetId);
-            if (!physicalPath)
-            {
-                std::cout << "Unknown ";
-            }
-            else
-            {
-                std::cout << *physicalPath;
-            }
-            std::cout << std::endl;
+            std::cout << *physicalPath;
         }
+        std::cout << std::endl;
+    }
+
+    if (!isHeaderPrinted)
+    {
+        std::cout << "No "
+                  << (displayResolved == true ? "resolved" : "unresolved")
+                  << " records to display" << std::endl;
     }
 }
 
@@ -62,6 +98,11 @@ void guardClear()
     clearAll();
 }
 
+void guardInvalidateAll()
+{
+    invalidateAll();
+}
+
 void guardCreate(const std::string& physicalPath)
 {
     std::optional<EntityPath> entityPath = getEntityPath(physicalPath);
@@ -84,25 +125,29 @@ int main(int argc, char** argv)
 {
     try
     {
-        CLI::App app{"GUARD Tool"};
+        CLI::App app{"Guard Tool"};
         std::optional<std::string> createGuardStr;
         std::optional<std::string> deleteGuardStr;
         bool listGuardRecords = false;
         bool clearAll = false;
+        bool listResolvedGuardRecords = false;
+        bool invalidateAll = false;
         bool gversion = false;
 
-        app.set_help_flag("-h, --help",
-                          "Use the below listed functions.\n"
-                          "Warning: Don't try guard on non guardable units "
-                          "(sys, perv)");
+        app.set_help_flag("-h, --help", "Guard CLI tool options");
         app.add_option("-c, --create", createGuardStr,
-                       "Create GUARD record, expects physical path as input");
-        app.add_option("-d, --delete", deleteGuardStr,
-                       "Delete GUARD record, expects physical path as input");
+                       "Create Guard record, expects physical path as input");
+        app.add_option(
+            "-i, --invalidate", deleteGuardStr,
+            "Invalidate a single Guard record, expects physical path as input");
+        app.add_flag("-I, --invalidate-all", invalidateAll,
+                     "Invalidates all the Guard records");
         app.add_flag("-l, --list", listGuardRecords,
-                     "Listing of GUARDed resources.");
-        app.add_flag("-r, --clearall", clearAll,
-                     "Clears GUARD states for all resources");
+                     "List all the Guard'ed resources");
+        app.add_flag("-r, --reset", clearAll, "Erase all the Guard records");
+        app.add_flag("-a, --listresolvedrecords", listResolvedGuardRecords,
+                     "List all the resolved Guard'ed resources")
+            ->group("");
         app.add_flag("-v, --version", gversion, "Version of GUARD tool");
 
         CLI11_PARSE(app, argc, argv);
@@ -123,11 +168,19 @@ int main(int argc, char** argv)
         }
         else if (listGuardRecords)
         {
-            guardList();
+            guardList(false);
+        }
+        else if (listResolvedGuardRecords)
+        {
+            guardList(true);
+        }
+        else if (invalidateAll)
+        {
+            guardInvalidateAll();
         }
         else if (gversion)
         {
-            std::cout << "GUARD Tool version is " << GUARD_VERSION << std::endl;
+            std::cout << "Guard tool " << GUARD_VERSION << std::endl;
         }
         else
         {

libguard/guard_common.hpp

@@ -1,17 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 #pragma once
 
+#include "guard_exception.hpp"
 #include "guard_log.hpp"
 
 #include <array>
 #include <cstdint>
-#include <stdexcept>
 #include <optional>
 
 namespace openpower
 {
 namespace guard
 {
+
+using namespace openpower::guard::exception;
+
 /* From hostboot: src/include/usr/targeting/common/entitypath.H */
 struct EntityPath
 {
@@ -75,15 +78,15 @@ struct EntityPath
                 GUARD_ERROR,
                 "Size mismatch. Given buf size[%d] EntityPath sizeof[%d]",
                 rawData.size(), sizeof(EntityPath));
-            throw std::runtime_error(
+            throw InvalidEntityPath(
                 "EntityPath initializer_list constructor failed");
         }
 
         if (rawData.size() == 0)
         {
             openpower::guard::log::guard_log(GUARD_ERROR,
                                              "Given raw data is empty");
-            throw std::runtime_error(
+            throw InvalidEntityPath(
                 "EntityPath initializer_list constructor failed");
         }
 
@@ -93,7 +96,7 @@ struct EntityPath
         {
             openpower::guard::log::guard_log(
                 GUARD_ERROR, "PathElement size mismatch in given raw data");
-            throw std::runtime_error(
+            throw InvalidEntityPath(
                 "EntityPath initializer_list constructor failed");
         }
 
@@ -107,7 +110,7 @@ struct EntityPath
                 openpower::guard::log::guard_log(
                     GUARD_ERROR,
                     "Insufficient data for PathElement in given raw data");
-                throw std::runtime_error(
+                throw InvalidEntityPath(
                     "EntityPath initializer_list constructor failed");
             }
 
@@ -122,8 +125,7 @@ struct EntityPath
         {
             openpower::guard::log::guard_log(GUARD_ERROR,
                                              "Given raw data is empty");
-            throw std::runtime_error(
-                "EntityPath conversion constructor failed");
+            throw InvalidEntityPath("EntityPath conversion constructor failed");
         }
 
         type_size = rawData[0];
@@ -135,8 +137,7 @@ struct EntityPath
                 GUARD_ERROR,
                 "Size mismatch. Given path elements size[%d] max[%d]",
                 pathElementsSize, maxPathElements);
-            throw std::runtime_error(
-                "EntityPath conversion constructor failed");
+            throw InvalidEntityPath("EntityPath conversion constructor failed");
         }
 
         for (int i = 0, j = 1; i < pathElementsSize;
@@ -147,7 +148,7 @@ struct EntityPath
                 openpower::guard::log::guard_log(
                     GUARD_ERROR,
                     "Insufficient data for PathElement in given raw data");
-                throw std::runtime_error(
+                throw InvalidEntityPath(
                     "EntityPath conversion constructor failed");
             }
 

libguard/guard_exception.hpp

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <exception>
+#include <sstream>
+#include <string>
+
+namespace openpower
+{
+namespace guard
+{
+namespace exception
+{
+// TODO:Issue #3, to avoid multiple exception classes
+class GuardException : public std::exception
+{
+  public:
+    explicit GuardException(const std::string& message) : message(message){};
+
+    const char* what() const noexcept override
+    {
+        return message.c_str();
+    }
+
+  private:
+    std::string message;
+};
+
+class GuardFileOpenFailed : public GuardException
+{
+  public:
+    explicit GuardFileOpenFailed(const std::string& msg) :
+        GuardException(msg){};
+};
+
+class GuardFileReadFailed : public GuardException
+{
+  public:
+    explicit GuardFileReadFailed(const std::string& msg) :
+        GuardException(msg){};
+};
+
+class GuardFileWriteFailed : public GuardException
+{
+  public:
+    explicit GuardFileWriteFailed(const std::string& msg) :
+        GuardException(msg){};
+};
+
+class GuardFileSeekFailed : public GuardException
+{
+  public:
+    explicit GuardFileSeekFailed(const std::string& msg) :
+        GuardException(msg){};
+};
+
+class InvalidEntry : public GuardException
+{
+  public:
+    explicit InvalidEntry(const std::string& msg) : GuardException(msg){};
+};
+
+class AlreadyGuarded : public GuardException
+{
+  public:
+    explicit AlreadyGuarded(const std::string& msg) : GuardException(msg){};
+};
+
+class InvalidEntityPath : public GuardException
+{
+  public:
+    explicit InvalidEntityPath(const std::string& msg) : GuardException(msg){};
+};
+
+class GuardFileOverFlowed : public GuardException
+{
+  public:
+    explicit GuardFileOverFlowed(const std::string& msg) :
+        GuardException(msg){};
+};
+
+} // namespace exception
+} // namespace guard
+} // namespace openpower