diff --git a/apphandler.cpp b/apphandler.cpp
index 6cdd78f..0577c07 100644
--- a/apphandler.cpp
+++ b/apphandler.cpp
@@ -578,10 +578,10 @@
               uint16_t, // Product ID
               uint32_t  // AUX info
               >
-    ipmiAppGetDeviceId(ipmi::Context::ptr ctx)
+    ipmiAppGetDeviceId([[maybe_unused]] ipmi::Context::ptr ctx)
 {
     int r = -1;
-    Revision rev = {0};
+    Revision rev = {0, 0, 0, 0};
     static struct
     {
         uint8_t id;
@@ -1630,8 +1630,9 @@
  *   - readData - i2c response data
  */
 ipmi::RspType<std::vector<uint8_t>>
-    ipmiMasterWriteRead(bool isPrivateBus, uint3_t busId, uint4_t channelNum,
-                        bool reserved, uint7_t slaveAddr, uint8_t readCount,
+    ipmiMasterWriteRead([[maybe_unused]] bool isPrivateBus, uint3_t busId,
+                        [[maybe_unused]] uint4_t channelNum, bool reserved,
+                        uint7_t slaveAddr, uint8_t readCount,
                         std::vector<uint8_t> writeData)
 {
     if (reserved)
diff --git a/chassishandler.cpp b/chassishandler.cpp
index 737d3d2..9b2eb2a 100644
--- a/chassishandler.cpp
+++ b/chassishandler.cpp
@@ -1833,8 +1833,8 @@
 ipmi::RspType<ipmi::message::Payload>
     ipmiChassisGetSysBootOptions(ipmi::Context::ptr ctx,
                                  uint7_t bootOptionParameter, bool reserved1,
-
-                                 uint8_t setSelector, uint8_t blockSelector)
+                                 [[maybe_unused]] uint8_t setSelector,
+                                 [[maybe_unused]] uint8_t blockSelector)
 {
     ipmi::Cc rc;
     if (reserved1)
@@ -1994,8 +1994,7 @@
 }
 
 ipmi::RspType<> ipmiChassisSetSysBootOptions(ipmi::Context::ptr ctx,
-                                             uint7_t parameterSelector,
-                                             bool parameterIsValid,
+                                             uint7_t parameterSelector, bool,
                                              ipmi::message::Payload& data)
 {
     using namespace boot_options;
@@ -2322,9 +2321,10 @@
     return ipmi::responseSuccess(power_policy::allSupport, reserved);
 }
 
-ipmi::RspType<> ipmiSetFrontPanelButtonEnables(
-    ipmi::Context::ptr ctx, bool disablePowerButton, bool disableResetButton,
-    bool disableDiagButton, bool disableSleepButton, uint4_t reserved)
+ipmi::RspType<> ipmiSetFrontPanelButtonEnables(ipmi::Context::ptr ctx,
+                                               bool disablePowerButton,
+                                               bool disableResetButton, bool,
+                                               bool, uint4_t)
 {
     using namespace chassis::internal;
 
diff --git a/dbus-sdr/sdrutils.cpp b/dbus-sdr/sdrutils.cpp
index 3df0dc1..7de48a8 100644
--- a/dbus-sdr/sdrutils.cpp
+++ b/dbus-sdr/sdrutils.cpp
@@ -40,13 +40,13 @@
         *dbus,
         "type='signal',member='InterfacesAdded',arg0path='/xyz/openbmc_project/"
         "sensors/'",
-        [](sdbusplus::message::message& m) { sensorTreePtr.reset(); });
+        [](sdbusplus::message::message&) { sensorTreePtr.reset(); });
 
     static sdbusplus::bus::match::match sensorRemoved(
         *dbus,
         "type='signal',member='InterfacesRemoved',arg0path='/xyz/"
         "openbmc_project/sensors/'",
-        [](sdbusplus::message::message& m) { sensorTreePtr.reset(); });
+        [](sdbusplus::message::message&) { sensorTreePtr.reset(); });
 
     if (sensorTreePtr)
     {
diff --git a/dbus-sdr/sensorcommands.cpp b/dbus-sdr/sensorcommands.cpp
index 8f177e6..4d35009 100644
--- a/dbus-sdr/sensorcommands.cpp
+++ b/dbus-sdr/sensorcommands.cpp
@@ -115,7 +115,7 @@
     *getSdBus(),
     "type='signal',member='InterfacesAdded',arg0path='/xyz/openbmc_project/"
     "sensors/'",
-    [](sdbusplus::message::message& m) {
+    [](sdbusplus::message::message&) {
         getSensorTree().clear();
         sdrLastAdd = std::chrono::duration_cast<std::chrono::seconds>(
                          std::chrono::system_clock::now().time_since_epoch())
@@ -126,7 +126,7 @@
     *getSdBus(),
     "type='signal',member='InterfacesRemoved',arg0path='/xyz/openbmc_project/"
     "sensors/'",
-    [](sdbusplus::message::message& m) {
+    [](sdbusplus::message::message&) {
         getSensorTree().clear();
         sdrLastRemove = std::chrono::duration_cast<std::chrono::seconds>(
                             std::chrono::system_clock::now().time_since_epoch())
@@ -593,11 +593,10 @@
 }
 
 ipmi::RspType<> ipmiSetSensorReading(ipmi::Context::ptr ctx,
-                                     uint8_t sensorNumber, uint8_t operation,
+                                     uint8_t sensorNumber, uint8_t,
                                      uint8_t reading, uint15_t assertOffset,
-                                     bool resvd1, uint15_t deassertOffset,
-                                     bool resvd2, uint8_t eventData1,
-                                     uint8_t eventData2, uint8_t eventData3)
+                                     bool, uint15_t, bool, uint8_t, uint8_t,
+                                     uint8_t)
 {
     std::string connection;
     std::string path;
@@ -946,9 +945,9 @@
     bool lowerCriticalThreshMask, bool lowerNonRecovThreshMask,
     bool upperNonCriticalThreshMask, bool upperCriticalThreshMask,
     bool upperNonRecovThreshMask, uint2_t reserved, uint8_t lowerNonCritical,
-    uint8_t lowerCritical, uint8_t lowerNonRecoverable,
+    uint8_t lowerCritical, [[maybe_unused]] uint8_t lowerNonRecoverable,
     uint8_t upperNonCritical, uint8_t upperCritical,
-    uint8_t upperNonRecoverable)
+    [[maybe_unused]] uint8_t upperNonRecoverable)
 {
     if (sensorNum == reservedSensorNumber || reserved)
     {
@@ -1800,7 +1799,7 @@
 
 #ifdef FEATURE_HYBRID_SENSORS
 // Construct a type 1 SDR for discrete Sensor typed sensor.
-void constructStaticSensorSdr(ipmi::Context::ptr ctx, uint16_t sensorNum,
+void constructStaticSensorSdr(ipmi::Context::ptr, uint16_t sensorNum,
                               uint16_t recordID,
                               ipmi::sensor::IdInfoMap::const_iterator sensor,
                               get_sdr::SensorDataFullRecord& record)
@@ -2049,7 +2048,7 @@
     if (std::find(interfaces.begin(), interfaces.end(),
                   sensor::sensorInterface) != interfaces.end())
     {
-        get_sdr::SensorDataFullRecord record = {0};
+        get_sdr::SensorDataFullRecord record = {};
 
         // If the request doesn't read SDR body, construct only header and key
         // part to avoid additional DBus transaction.
@@ -2075,7 +2074,7 @@
         getSensorEventTypeFromPath(path) !=
             static_cast<uint8_t>(SensorEventTypeCodes::threshold))
     {
-        get_sdr::SensorDataFullRecord record = {0};
+        get_sdr::SensorDataFullRecord record = {};
 
         // If the request doesn't read SDR body, construct only header and key
         // part to avoid additional DBus transaction.
@@ -2099,7 +2098,7 @@
     if (std::find(interfaces.begin(), interfaces.end(), sensor::vrInterface) !=
         interfaces.end())
     {
-        get_sdr::SensorDataEventRecord record = {0};
+        get_sdr::SensorDataEventRecord record = {};
 
         // If the request doesn't read SDR body, construct only header and key
         // part to avoid additional DBus transaction.
diff --git a/dbus-sdr/storagecommands.cpp b/dbus-sdr/storagecommands.cpp
index 35e1bab..6d55211 100644
--- a/dbus-sdr/storagecommands.cpp
+++ b/dbus-sdr/storagecommands.cpp
@@ -230,9 +230,10 @@
     }
 }
 
-void replaceCacheFru(const std::shared_ptr<sdbusplus::asio::connection>& bus,
-                     boost::asio::yield_context& yield,
-                     const std::optional<std::string>& path = std::nullopt)
+void replaceCacheFru(
+    const std::shared_ptr<sdbusplus::asio::connection>& bus,
+    boost::asio::yield_context& yield,
+    [[maybe_unused]] const std::optional<std::string>& path = std::nullopt)
 {
     boost::system::error_code ec;
 
@@ -554,7 +555,7 @@
     return ipmi::responseSuccess(fruCache.size(), accessType);
 }
 
-ipmi_ret_t getFruSdrCount(ipmi::Context::ptr ctx, size_t& count)
+ipmi_ret_t getFruSdrCount(ipmi::Context::ptr, size_t& count)
 {
     count = deviceHashes.size();
     return IPMI_CC_OK;
@@ -1084,11 +1085,17 @@
     return ipmi::responseUnspecifiedError();
 }
 
-ipmi::RspType<uint16_t> ipmiStorageAddSELEntry(
-    uint16_t recordID, uint8_t recordType, uint32_t timestamp,
-    uint16_t generatorID, uint8_t evmRev, uint8_t sensorType, uint8_t sensorNum,
-    uint8_t eventType, uint8_t eventData1, uint8_t eventData2,
-    uint8_t eventData3)
+/*
+Unused arguments
+  uint16_t recordID, uint8_t recordType, uint32_t timestamp,
+  uint16_t generatorID, uint8_t evmRev, uint8_t sensorType, uint8_t sensorNum,
+  uint8_t eventType, uint8_t eventData1, uint8_t eventData2,
+  uint8_t eventData3
+*/
+ipmi::RspType<uint16_t> ipmiStorageAddSELEntry(uint16_t, uint8_t, uint32_t,
+                                               uint16_t, uint8_t, uint8_t,
+                                               uint8_t, uint8_t, uint8_t,
+                                               uint8_t, uint8_t)
 {
     // Per the IPMI spec, need to cancel any reservation when a SEL entry is
     // added
@@ -1098,7 +1105,7 @@
     return ipmi::responseSuccess(responseID);
 }
 
-ipmi::RspType<uint8_t> ipmiStorageClearSEL(ipmi::Context::ptr ctx,
+ipmi::RspType<uint8_t> ipmiStorageClearSEL(ipmi::Context::ptr,
                                            uint16_t reservationID,
                                            const std::array<uint8_t, 3>& clr,
                                            uint8_t eraseOperation)
@@ -1189,7 +1196,7 @@
     return ipmi::responseSuccess(selTime.tv_sec);
 }
 
-ipmi::RspType<> ipmiStorageSetSELTime(uint32_t selTime)
+ipmi::RspType<> ipmiStorageSetSELTime(uint32_t)
 {
     // Set SEL Time is not supported
     return ipmi::responseInvalidCommand();
diff --git a/dcmihandler.cpp b/dcmihandler.cpp
index a7a3bf1..e476cfb 100644
--- a/dcmihandler.cpp
+++ b/dcmihandler.cpp
@@ -298,9 +298,9 @@
 
 } // namespace dcmi
 
-ipmi_ret_t getPowerLimit(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                         ipmi_request_t request, ipmi_response_t response,
-                         ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getPowerLimit(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t,
+                         ipmi_response_t response, ipmi_data_len_t data_len,
+                         ipmi_context_t)
 {
     if (!dcmi::isDCMIPowerMgmtSupported())
     {
@@ -356,9 +356,9 @@
     }
 }
 
-ipmi_ret_t setPowerLimit(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                         ipmi_request_t request, ipmi_response_t response,
-                         ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t setPowerLimit(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                         ipmi_response_t, ipmi_data_len_t data_len,
+                         ipmi_context_t)
 {
     if (!dcmi::isDCMIPowerMgmtSupported())
     {
@@ -390,9 +390,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t applyPowerLimit(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                           ipmi_request_t request, ipmi_response_t response,
-                           ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t applyPowerLimit(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                           ipmi_response_t, ipmi_data_len_t data_len,
+                           ipmi_context_t)
 {
     if (!dcmi::isDCMIPowerMgmtSupported())
     {
@@ -424,9 +424,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t getAssetTag(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                       ipmi_request_t request, ipmi_response_t response,
-                       ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getAssetTag(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                       ipmi_response_t response, ipmi_data_len_t data_len,
+                       ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::GetAssetTagRequest*>(request);
@@ -491,9 +491,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t setAssetTag(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                       ipmi_request_t request, ipmi_response_t response,
-                       ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t setAssetTag(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                       ipmi_response_t response, ipmi_data_len_t data_len,
+                       ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::SetAssetTagRequest*>(request);
@@ -544,9 +544,9 @@
     }
 }
 
-ipmi_ret_t getMgmntCtrlIdStr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                             ipmi_request_t request, ipmi_response_t response,
-                             ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getMgmntCtrlIdStr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                             ipmi_response_t response, ipmi_data_len_t data_len,
+                             ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::GetMgmntCtrlIdStrRequest*>(request);
@@ -585,9 +585,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t setMgmntCtrlIdStr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                             ipmi_request_t request, ipmi_response_t response,
-                             ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t setMgmntCtrlIdStr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                             ipmi_response_t response, ipmi_data_len_t data_len,
+                             ipmi_context_t)
 {
     static std::array<char, dcmi::maxCtrlIdStrLen + 1> newCtrlIdStr;
 
@@ -682,9 +682,9 @@
        {"OptionalSecondaryLanOOBSupport", 2, 0, 8},
        {"OptionalSerialOOBMTMODECapability", 3, 0, 8}}}}};
 
-ipmi_ret_t getDCMICapabilities(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                               ipmi_request_t request, ipmi_response_t response,
-                               ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getDCMICapabilities(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                               ipmi_response_t response,
+                               ipmi_data_len_t data_len, ipmi_context_t)
 {
 
     std::ifstream dcmiCapFile(dcmi::gDCMICapabilitiesConfig);
@@ -909,9 +909,9 @@
 } // namespace temp_readings
 } // namespace dcmi
 
-ipmi_ret_t getTempReadings(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                           ipmi_request_t request, ipmi_response_t response,
-                           ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getTempReadings(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                           ipmi_response_t response, ipmi_data_len_t data_len,
+                           ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::GetTempReadingsRequest*>(request);
@@ -1024,9 +1024,9 @@
     return power;
 }
 
-ipmi_ret_t setDCMIConfParams(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                             ipmi_request_t request, ipmi_response_t response,
-                             ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t setDCMIConfParams(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                             ipmi_response_t, ipmi_data_len_t data_len,
+                             ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::SetConfParamsRequest*>(request);
@@ -1093,9 +1093,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t getDCMIConfParams(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                             ipmi_request_t request, ipmi_response_t response,
-                             ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getDCMIConfParams(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                             ipmi_response_t response, ipmi_data_len_t data_len,
+                             ipmi_context_t)
 {
 
     auto requestData =
@@ -1164,9 +1164,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t getPowerReading(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                           ipmi_request_t request, ipmi_response_t response,
-                           ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getPowerReading(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t,
+                           ipmi_response_t response, ipmi_data_len_t data_len,
+                           ipmi_context_t)
 {
     *data_len = 0;
     if (!dcmi::isDCMIPowerMgmtSupported())
@@ -1307,9 +1307,9 @@
 } // namespace sensor_info
 } // namespace dcmi
 
-ipmi_ret_t getSensorInfo(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                         ipmi_request_t request, ipmi_response_t response,
-                         ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getSensorInfo(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                         ipmi_response_t response, ipmi_data_len_t data_len,
+                         ipmi_context_t)
 {
     auto requestData =
         reinterpret_cast<const dcmi::GetSensorInfoRequest*>(request);
diff --git a/dcmihandler.hpp b/dcmihandler.hpp
index 4f35bc6..b006ee0 100644
--- a/dcmihandler.hpp
+++ b/dcmihandler.hpp
@@ -577,7 +577,6 @@
     uint8_t minor;         //!< DCMI Spec Conformance - minor ver = 05h.
     uint8_t paramRevision; //!< Parameter Revision = 01h.
     uint8_t data[];        //!< Parameter data.
-
 } __attribute__((packed));
 
 } // namespace dcmi
diff --git a/groupext.cpp b/groupext.cpp
index 5b71dde..483e064 100644
--- a/groupext.cpp
+++ b/groupext.cpp
@@ -4,9 +4,9 @@
 #define GRPEXT_GET_GROUP_CMD 0
 void register_netfn_groupext_functions() __attribute__((constructor));
 
-ipmi_ret_t ipmi_groupext(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                         ipmi_request_t request, ipmi_response_t response,
-                         ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t ipmi_groupext(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t,
+                         ipmi_response_t response, ipmi_data_len_t data_len,
+                         ipmi_context_t)
 {
     // Generic return from IPMI commands.
     ipmi_ret_t rc = IPMI_CC_OK;
diff --git a/host-interface.cpp b/host-interface.cpp
index ffd1aaf..e413fb7 100644
--- a/host-interface.cpp
+++ b/host-interface.cpp
@@ -78,7 +78,7 @@
         std::make_shared<std::optional<Host::FirmwareCondition>>();
 
     // callback for command to host
-    auto hostAckCallback = [hostCondition](IpmiCmdData cmd, bool status) {
+    auto hostAckCallback = [hostCondition](IpmiCmdData, bool status) {
         auto value = status ? Host::FirmwareCondition::Running
                             : Host::FirmwareCondition::Off;
 
diff --git a/include/ipmid/sessionhelper.hpp b/include/ipmid/sessionhelper.hpp
index a96f037..3a72d19 100644
--- a/include/ipmid/sessionhelper.hpp
+++ b/include/ipmid/sessionhelper.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <sstream>
 #include <string>
 
diff --git a/include/ipmid/utils.hpp b/include/ipmid/utils.hpp
index b8b59bf..5e049c5 100644
--- a/include/ipmid/utils.hpp
+++ b/include/ipmid/utils.hpp
@@ -418,7 +418,7 @@
 
     template <typename T>
     std::enable_if_t<!std::is_arithmetic<T>::value, double>
-        operator()(const T& t) const
+        operator()(const T&) const
     {
         throw std::invalid_argument("Cannot translate type to double");
     }
diff --git a/ipmisensor.cpp b/ipmisensor.cpp
index 3db1d1b..593f8a8 100644
--- a/ipmisensor.cpp
+++ b/ipmisensor.cpp
@@ -113,7 +113,7 @@
 //  The fw progress sensor contains some additional information that needs to be
 //  processed prior to calling the dbus code.
 int set_sensor_dbus_state_fwprogress(const sensorRES_t* pRec,
-                                     const lookup_t* pTable, const char* value)
+                                     const lookup_t* pTable, const char*)
 {
 
     char valuestring[128];
@@ -152,16 +152,15 @@
 // Handling this special OEM sensor by coping what is in byte 4.  I also think
 // that is odd considering byte 3 is for sensor reading.  This seems like a
 // misuse of the IPMI spec
-int set_sensor_dbus_state_osbootcount(const sensorRES_t* pRec,
-                                      const lookup_t* pTable, const char* value)
+int set_sensor_dbus_state_osbootcount(const sensorRES_t* pRec, const lookup_t*,
+                                      const char*)
 {
     return set_sensor_dbus_state_y(pRec->sensor_number, "setValue",
                                    pRec->assert_state7_0);
 }
 
 int set_sensor_dbus_state_system_event(const sensorRES_t* pRec,
-                                       const lookup_t* pTable,
-                                       const char* value)
+                                       const lookup_t* pTable, const char*)
 {
     char valuestring[128];
     char* p = valuestring;
diff --git a/libipmid/utils.cpp b/libipmid/utils.cpp
index 0f6d0dd..5aebd17 100644
--- a/libipmid/utils.cpp
+++ b/libipmid/utils.cpp
@@ -635,7 +635,7 @@
     const size_t writeCount = writeData.size();
     const size_t readCount = readBuf.size();
     int msgCount = 0;
-    i2c_msg i2cmsg[2] = {0};
+    i2c_msg i2cmsg[2] = {};
     if (writeCount)
     {
         // Data will be writtern to the slave address
@@ -655,7 +655,7 @@
         msgCount++;
     }
 
-    i2c_rdwr_ioctl_data msgReadWrite = {0};
+    i2c_rdwr_ioctl_data msgReadWrite = {};
     msgReadWrite.msgs = i2cmsg;
     msgReadWrite.nmsgs = msgCount;
 
diff --git a/scripts/sensor-example.yaml b/scripts/sensor-example.yaml
index bddd2e6..869702e 100644
--- a/scripts/sensor-example.yaml
+++ b/scripts/sensor-example.yaml
@@ -172,7 +172,6 @@
         Offsets:
           7:
             assert: true
-            deassert: true
             type: bool
     xyz.openbmc_project.Inventory.Item:
       Present:
@@ -188,10 +187,8 @@
         Offsets:
           8:
             assert: false
-            deassert: true
             type: bool
         Prereqs:
           7:
             assert: true
-            deassert: false
             type: bool
diff --git a/scripts/writesensor.mako.cpp b/scripts/writesensor.mako.cpp
index 813f940..2c8c0e4 100644
--- a/scripts/writesensor.mako.cpp
+++ b/scripts/writesensor.mako.cpp
@@ -99,7 +99,9 @@
         .mutability = Mutability(${mutability}),
     % if sensorName:
         .sensorName = "${sensorName}",
+        .sensorNameFunc = nullptr,
     % else:
+        .sensorName = "",
         .sensorNameFunc = ${sensorNameFunc},
     % endif
         .propertyInterfaces = {
diff --git a/selutility.cpp b/selutility.cpp
index e02027f..344201e 100644
--- a/selutility.cpp
+++ b/selutility.cpp
@@ -127,7 +127,7 @@
 }
 
 void constructSEL(uint8_t recordType, std::chrono::milliseconds timestamp,
-                  const additionalDataMap& m, const entryDataMap& entryData,
+                  const additionalDataMap& m, const entryDataMap&,
                   GetSELEntryResponse& record)
 {
     if (recordType != systemEventRecord)
diff --git a/sensordatahandler.cpp b/sensordatahandler.cpp
index 949b732..f22f403 100644
--- a/sensordatahandler.cpp
+++ b/sensordatahandler.cpp
@@ -256,7 +256,7 @@
                                updateInterface.c_str(), command.c_str());
 }
 
-ipmi_ret_t eventdata(const SetSensorReadingReq& cmdData, const Info& sensorInfo,
+ipmi_ret_t eventdata(const SetSensorReadingReq&, const Info& sensorInfo,
                      uint8_t data)
 {
     auto msg =
@@ -336,9 +336,8 @@
 {
 
 IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
-                           const std::string& sensorPath,
-                           const std::string& command,
-                           const std::string& sensorInterface)
+                           const std::string&, const std::string& command,
+                           const std::string&)
 {
     sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
     using namespace std::string_literals;
diff --git a/sensorhandler.cpp b/sensorhandler.cpp
index fcfd428..3217412 100644
--- a/sensorhandler.cpp
+++ b/sensorhandler.cpp
@@ -109,7 +109,7 @@
 using sensorServiceToIdMap = std::unordered_map<std::string, std::set<uint8_t>>;
 sensorServiceToIdMap serviceToIdMap __attribute__((init_priority(101)));
 
-static void fillSensorIdServiceMap(const std::string& obj,
+static void fillSensorIdServiceMap(const std::string&,
                                    const std::string& /*intf*/, uint8_t id,
                                    const std::string& service)
 {
@@ -560,7 +560,8 @@
               uint8_t, // threshold levels states
               uint8_t  // discrete reading sensor states
               >
-    ipmiSensorGetSensorReading(ipmi::Context::ptr& ctx, uint8_t sensorNum)
+    ipmiSensorGetSensorReading([[maybe_unused]] ipmi::Context::ptr& ctx,
+                               uint8_t sensorNum)
 {
     if (sensorNum == 0xFF)
     {
@@ -825,9 +826,8 @@
     bool lowerCriticalThreshMask, bool lowerNonRecovThreshMask,
     bool upperNonCriticalThreshMask, bool upperCriticalThreshMask,
     bool upperNonRecovThreshMask, uint2_t reserved, uint8_t lowerNonCritical,
-    uint8_t lowerCritical, uint8_t lowerNonRecoverable,
-    uint8_t upperNonCritical, uint8_t upperCritical,
-    uint8_t upperNonRecoverable)
+    uint8_t lowerCritical, uint8_t, uint8_t upperNonCritical,
+    uint8_t upperCritical, uint8_t)
 {
     if (reserved)
     {
@@ -1062,7 +1062,7 @@
 
 ipmi_ret_t populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
                                      const ipmi::sensor::Info* info,
-                                     ipmi_data_len_t data_len)
+                                     ipmi_data_len_t)
 {
     /* Functional sensor case */
     if (isAnalogSensor(info->propertyInterfaces.begin()->first))
@@ -1266,9 +1266,9 @@
     return IPMI_CC_OK;
 }
 
-ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                            ipmi_request_t request, ipmi_response_t response,
-                            ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                            ipmi_response_t response, ipmi_data_len_t data_len,
+                            ipmi_context_t)
 {
     ipmi_ret_t ret = IPMI_CC_OK;
     get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
@@ -1312,7 +1312,7 @@
     if (it == sdrCacheMap.end())
     {
         /* Header */
-        get_sdr::SensorDataFullRecord record = {0};
+        get_sdr::SensorDataFullRecord record = {};
         get_sdr::header::set_record_id(sensor_id, &(record.header));
         record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
         record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
@@ -1384,10 +1384,9 @@
     return true;
 }
 
-ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                                ipmi_request_t request,
-                                ipmi_response_t response,
-                                ipmi_data_len_t dataLen, ipmi_context_t context)
+ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t, ipmi_cmd_t,
+                                ipmi_request_t request, ipmi_response_t,
+                                ipmi_data_len_t dataLen, ipmi_context_t)
 {
     uint16_t generatorID;
     size_t count;
diff --git a/softoff/mainapp.cpp b/softoff/mainapp.cpp
index 70defb7..563ccd1 100644
--- a/softoff/mainapp.cpp
+++ b/softoff/mainapp.cpp
@@ -25,7 +25,7 @@
 
 // Return -1 on any errors to ensure we follow the calling targets OnFailure=
 // path
-int main(int argc, char** argv)
+int main(int, char**)
 {
     using namespace phosphor::logging;
 
diff --git a/storagehandler.cpp b/storagehandler.cpp
index 0b1a4e4..47a18d6 100644
--- a/storagehandler.cpp
+++ b/storagehandler.cpp
@@ -288,9 +288,9 @@
         ipmi::sel::operationSupport::overflow);
 }
 
-ipmi_ret_t getSELEntry(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                       ipmi_request_t request, ipmi_response_t response,
-                       ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t getSELEntry(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
+                       ipmi_response_t response, ipmi_data_len_t data_len,
+                       ipmi_context_t)
 {
     if (*data_len != sizeof(ipmi::sel::GetSELEntryRequest))
     {
@@ -670,8 +670,9 @@
  */
 ipmi::RspType<uint16_t // recordID of the Added SEL entry
               >
-    ipmiStorageAddSEL(uint16_t recordID, uint8_t recordType, uint32_t timeStamp,
-                      uint16_t generatorID, uint8_t evmRev, uint8_t sensorType,
+    ipmiStorageAddSEL(uint16_t recordID, uint8_t recordType,
+                      [[maybe_unused]] uint32_t timeStamp, uint16_t generatorID,
+                      [[maybe_unused]] uint8_t evmRev, uint8_t sensorType,
                       uint8_t sensorNumber, uint8_t eventDir,
                       std::array<uint8_t, eventDataSize> eventData)
 {
diff --git a/systemintfcmds.cpp b/systemintfcmds.cpp
index fe671a2..7596ab9 100644
--- a/systemintfcmds.cpp
+++ b/systemintfcmds.cpp
@@ -20,13 +20,13 @@
 //-------------------------------------------------------------------
 // Called by Host post response from Get_Message_Flags
 //-------------------------------------------------------------------
-ipmi_ret_t ipmi_app_read_event(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
-                               ipmi_request_t request, ipmi_response_t response,
-                               ipmi_data_len_t data_len, ipmi_context_t context)
+ipmi_ret_t ipmi_app_read_event(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t,
+                               ipmi_response_t response,
+                               ipmi_data_len_t data_len, ipmi_context_t)
 {
     ipmi_ret_t rc = IPMI_CC_OK;
 
-    struct oem_sel_timestamped oem_sel = {0};
+    struct oem_sel_timestamped oem_sel = {};
     *data_len = sizeof(struct oem_sel_timestamped);
 
     // either id[0] -or- id[1] can be filled in. We will use id[0]
diff --git a/test/dbus-sdr/sensorcommands_unittest.cpp b/test/dbus-sdr/sensorcommands_unittest.cpp
index 83918c5..bcd2f44 100644
--- a/test/dbus-sdr/sensorcommands_unittest.cpp
+++ b/test/dbus-sdr/sensorcommands_unittest.cpp
@@ -39,6 +39,7 @@
             if (val & 0x80)
                 val++;
             /* Deliberately fall through to case 2. */
+            [[fallthrough]];
         case 2:
             result =
                 (double)(((m * (int8_t)val) + (b * pow(10, k1))) * pow(10, k2));
diff --git a/test/message/payload.cpp b/test/message/payload.cpp
index 7c55e7e..59947c6 100644
--- a/test/message/payload.cpp
+++ b/test/message/payload.cpp
@@ -321,8 +321,8 @@
     return 0;
 }
 
-int sd_journal_send_with_location(const char* file, const char* line,
-                                  const char* func, const char* format, ...)
+int sd_journal_send_with_location(const char* /*file*/, const char* /*line*/,
+                                  const char* /*func*/, const char* format, ...)
 {
     logs.push_back(format);
     return 0;
diff --git a/transporthandler.cpp b/transporthandler.cpp
index 0f9f8a3..b29e4bf 100644
--- a/transporthandler.cpp
+++ b/transporthandler.cpp
@@ -125,7 +125,7 @@
 
     params.id = channel;
     params.ifname = std::move(ifname);
-    return std::move(params);
+    return params;
 }
 
 ChannelParams getChannelParams(sdbusplus::bus::bus& bus, uint8_t channel)
@@ -802,14 +802,13 @@
                                     uint8_t set, uint8_t block)
     __attribute__((weak));
 
-RspType<> setLanOem(uint8_t channel, uint8_t parameter, message::Payload& req)
+RspType<> setLanOem(uint8_t, uint8_t, message::Payload& req)
 {
     req.trailingOk = true;
     return response(ccParamNotSupported);
 }
 
-RspType<message::Payload> getLanOem(uint8_t channel, uint8_t parameter,
-                                    uint8_t set, uint8_t block)
+RspType<message::Payload> getLanOem(uint8_t, uint8_t, uint8_t, uint8_t)
 {
     return response(ccParamNotSupported);
 }
@@ -1543,7 +1542,7 @@
 constexpr const uint16_t solDefaultPort = 623;
 
 RspType<> setSolConfParams(Context::ptr ctx, uint4_t channelBits,
-                           uint4_t reserved, uint8_t parameter,
+                           uint4_t /*reserved*/, uint8_t parameter,
                            message::Payload& req)
 {
     const uint8_t channel = convertCurrentChannelNum(
@@ -1713,9 +1712,9 @@
 
 RspType<message::Payload> getSolConfParams(Context::ptr ctx,
                                            uint4_t channelBits,
-                                           uint3_t reserved, bool revOnly,
-                                           uint8_t parameter, uint8_t set,
-                                           uint8_t block)
+                                           uint3_t /*reserved*/, bool revOnly,
+                                           uint8_t parameter, uint8_t /*set*/,
+                                           uint8_t /*block*/)
 {
     message::Payload ret;
     constexpr uint8_t current_revision = 0x11;
diff --git a/transporthandler.hpp b/transporthandler.hpp
index c2940b4..961aae9 100644
--- a/transporthandler.hpp
+++ b/transporthandler.hpp
@@ -475,7 +475,8 @@
  */
 template <int family>
 std::optional<IfAddr<family>> findIfAddr(
-    sdbusplus::bus::bus& bus, const ChannelParams& params, uint8_t idx,
+    [[maybe_unused]] sdbusplus::bus::bus& bus,
+    [[maybe_unused]] const ChannelParams& params, uint8_t idx,
     const std::unordered_set<
         sdbusplus::xyz::openbmc_project::Network::server::IP::AddressOrigin>&
         origins,
@@ -510,7 +511,7 @@
         ifaddr.address = *addr;
         ifaddr.prefix = std::get<uint8_t>(properties.at("PrefixLength"));
         ifaddr.origin = origin;
-        return std::move(ifaddr);
+        return ifaddr;
     }
 
     return std::nullopt;
@@ -593,7 +594,7 @@
 
 template <int family>
 std::optional<IfNeigh<family>>
-    findStaticNeighbor(sdbusplus::bus::bus& bus, const ChannelParams& params,
+    findStaticNeighbor(sdbusplus::bus::bus&, const ChannelParams&,
                        const typename AddrFamily<family>::addr& ip,
                        ObjectLookupCache& neighbors)
 {
@@ -623,7 +624,7 @@
         ret.ip = ip;
         const auto& macStr = std::get<std::string>(neighbor.at("MACAddress"));
         ret.mac = stringToMAC(macStr.c_str());
-        return std::move(ret);
+        return ret;
     }
 
     return std::nullopt;
diff --git a/user_channel/channel_layer.cpp b/user_channel/channel_layer.cpp
index 03b1729..fb70f1e 100644
--- a/user_channel/channel_layer.cpp
+++ b/user_channel/channel_layer.cpp
@@ -29,7 +29,7 @@
     // TODO: This is not the reliable way to find the device
     // associated with ethernet interface as the channel number to
     // eth association is not done. Need to revisit later
-    struct stat fileStat = {0};
+    struct stat fileStat = {};
     std::string devName("/sys/class/net/" + getChannelName(chNum));
 
     if (stat(devName.data(), &fileStat) != 0)
diff --git a/user_channel/channel_mgmt.cpp b/user_channel/channel_mgmt.cpp
index aa746fd..afdf062 100644
--- a/user_channel/channel_mgmt.cpp
+++ b/user_channel/channel_mgmt.cpp
@@ -364,9 +364,7 @@
                 sdbusplus::bus::match::rules::member(interfaceAddedSignal) +
                 sdbusplus::bus::match::rules::argNpath(
                     0, std::string(networkIntfObjectBasePath) + "/"),
-            [&](sdbusplus::message::message& msg) {
-                initChannelPersistData();
-            });
+            [&](sdbusplus::message::message&) { initChannelPersistData(); });
 
         chInterfaceRemovedSignal = std::make_unique<sdbusplus::bus::match_t>(
             bus,
@@ -374,9 +372,7 @@
                 sdbusplus::bus::match::rules::member(interfaceRemovedSignal) +
                 sdbusplus::bus::match::rules::argNpath(
                     0, std::string(networkIntfObjectBasePath) + "/"),
-            [&](sdbusplus::message::message& msg) {
-                initChannelPersistData();
-            });
+            [&](sdbusplus::message::message&) { initChannelPersistData(); });
     }
 }
 
diff --git a/user_channel/cipher_mgmt.cpp b/user_channel/cipher_mgmt.cpp
index 8355865..5f50c86 100644
--- a/user_channel/cipher_mgmt.cpp
+++ b/user_channel/cipher_mgmt.cpp
@@ -120,10 +120,10 @@
     std::string tmpFile =
         static_cast<std::string>(cipherSuitePrivFileName) + "_tmpXXXXXX";
 
-    char tmpRandomFile[tmpFile.length() + 1];
-    strncpy(tmpRandomFile, tmpFile.c_str(), tmpFile.length() + 1);
+    std::vector<char> tmpRandomFile(tmpFile.length() + 1);
+    strncpy(tmpRandomFile.data(), tmpFile.c_str(), tmpFile.length() + 1);
 
-    int fd = mkstemp(tmpRandomFile);
+    int fd = mkstemp(tmpRandomFile.data());
     fchmod(fd, 0644);
 
     if (fd < 0)
@@ -139,16 +139,16 @@
         close(fd);
         log<level::ERR>("Error writing CS privilege level config file",
                         entry("FILE_NAME=%s", tmpFile.c_str()));
-        unlink(tmpRandomFile);
+        unlink(tmpRandomFile.data());
         return -EIO;
     }
     close(fd);
 
-    if (std::rename(tmpRandomFile, cipherSuitePrivFileName.c_str()))
+    if (std::rename(tmpRandomFile.data(), cipherSuitePrivFileName.c_str()))
     {
         log<level::ERR>("Error renaming CS privilege level config file",
                         entry("FILE_NAME=%s", tmpFile.c_str()));
-        unlink(tmpRandomFile);
+        unlink(tmpRandomFile.data());
         return -EIO;
     }
 
diff --git a/user_channel/user_mgmt.cpp b/user_channel/user_mgmt.cpp
index 1644154..c205fea 100644
--- a/user_channel/user_mgmt.cpp
+++ b/user_channel/user_mgmt.cpp
@@ -1204,8 +1204,7 @@
 void UserAccess::updatePayloadAccessInUserInfo(
     const std::array<std::array<bool, ipmiMaxChannels>, payloadsPerByte>&
         stdPayload,
-    const std::array<std::array<bool, ipmiMaxChannels>, payloadsPerByte>&
-        oemPayload,
+    const std::array<std::array<bool, ipmiMaxChannels>, payloadsPerByte>&,
     UserInfo& userInfo)
 {
     for (size_t chIndex = 0; chIndex < ipmiMaxChannels; ++chIndex)
diff --git a/user_channel/usercommands.cpp b/user_channel/usercommands.cpp
index 7af38b9..901e4a6 100644
--- a/user_channel/usercommands.cpp
+++ b/user_channel/usercommands.cpp
@@ -85,7 +85,7 @@
         return ipmi::responseParmOutOfRange();
     }
 
-    PrivAccess privAccess = {0};
+    PrivAccess privAccess = {};
     if (bitsUpdate)
     {
         privAccess.ipmiEnabled = static_cast<uint8_t>(ipmiEnabled);
@@ -207,7 +207,8 @@
  *  @returns ipmi response
  */
 ipmi::RspType<>
-    ipmiSetUserName(ipmi::Context::ptr ctx, uint6_t id, uint2_t reserved,
+    ipmiSetUserName([[maybe_unused]] ipmi::Context::ptr ctx, uint6_t id,
+                    uint2_t reserved,
                     const std::array<uint8_t, ipmi::ipmiMaxUserName>& name)
 {
     if (reserved)
@@ -238,7 +239,8 @@
  *  @returns ipmi response with 16-byte username
  */
 ipmi::RspType<std::array<uint8_t, ipmi::ipmiMaxUserName>> // user name
-    ipmiGetUserName(ipmi::Context::ptr ctx, uint6_t id, uint2_t reserved)
+    ipmiGetUserName([[maybe_unused]] ipmi::Context::ptr ctx, uint6_t id,
+                    uint2_t reserved)
 {
     if (reserved)
     {
@@ -271,9 +273,9 @@
  *  @returns ipmi response with 16-byte username
  */
 ipmi::RspType<> // user name
-    ipmiSetUserPassword(ipmi::Context::ptr ctx, uint6_t id, bool reserved1,
-                        bool pwLen20, uint2_t operation, uint6_t reserved2,
-                        SecureBuffer& userPassword)
+    ipmiSetUserPassword([[maybe_unused]] ipmi::Context::ptr ctx, uint6_t id,
+                        bool reserved1, bool pwLen20, uint2_t operation,
+                        uint6_t reserved2, SecureBuffer& userPassword)
 {
     if (reserved1 || reserved2)
     {
@@ -404,7 +406,8 @@
               >
     ipmiGetChannelAuthenticationCapabilities(ipmi::Context::ptr ctx,
                                              uint4_t chNum, uint3_t reserved1,
-                                             bool extData, uint4_t privLevel,
+                                             [[maybe_unused]] bool extData,
+                                             uint4_t privLevel,
                                              uint4_t reserved2)
 {
     uint8_t channel =
@@ -522,7 +525,7 @@
         return ipmi::responseParmOutOfRange();
     }
 
-    PayloadAccess payloadAccess = {0};
+    PayloadAccess payloadAccess = {};
     payloadAccess.stdPayloadEnables1[1] = stdPayload1SOL;
 
     return ipmi::response(ipmiUserSetUserPayloadAccess(