diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml
index 2a7c5bbc..efef2261 100644
--- a/.github/workflows/unit-test.yml
+++ b/.github/workflows/unit-test.yml
@@ -83,6 +83,11 @@ jobs:
     with:
       config: --enable-nss
 
+  debug:
+    uses: ./.github/workflows/build-workflow.yml
+    with:
+      config: --enable-debug
+
   #TODO: --disable-aes            Enable AES (default: enabled)
   #TODO: --disable-aescbc         Enable AES-CBC (default: enabled)
   #TODO: --disable-sha256         Enable SHA-256 (default: enabled)
diff --git a/src/crypto.c b/src/crypto.c
index faa592f4..25545afd 100644
--- a/src/crypto.c
+++ b/src/crypto.c
@@ -1,6 +1,6 @@
 /* crypto.c
  *
- * Copyright (C) 2006-2023 wolfSSL Inc.
+ * Copyright (C) 2006-2025 wolfSSL Inc.
  *
  * This file is part of wolfPKCS11.
  *
@@ -1008,22 +1008,44 @@ CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate,
     WP11_Session* session;
     WP11_Object* object;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pTemplate == NULL || phObject == NULL)
-        return CKR_ARGUMENTS_BAD;
-    if (!WP11_Session_IsRW(session))
-        return CKR_SESSION_READ_ONLY;
+    WOLFPKCS11_ENTER("C_CreateObject");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_CreateObject", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_CreateObject", rv);
+        return rv;
+    }
+    if (pTemplate == NULL || phObject == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_CreateObject", rv);
+        return rv;
+    }
+    if (!WP11_Session_IsRW(session)) {
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_CreateObject", rv);
+        return rv;
+    }
 
     rv = CreateObject(session, pTemplate, ulCount, &object);
-    if (rv != CKR_OK)
+    if (rv != CKR_OK) {
+        WOLFPKCS11_LEAVE("C_CreateObject", rv);
         return rv;
+    }
     rv = AddObject(session, object, pTemplate, ulCount, phObject);
     if (rv != CKR_OK)
         WP11_Object_Free(object);
 
+    WOLFPKCS11_LEAVE("C_CreateObject", rv);
     return rv;
 }
 
@@ -1063,14 +1085,35 @@ CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
     CK_KEY_TYPE keyType;
     int onToken = 0;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pTemplate == NULL || phNewObject == NULL)
-        return CKR_ARGUMENTS_BAD;
-    if (!WP11_Session_IsRW(session))
-        return CKR_SESSION_READ_ONLY;
+    WOLFPKCS11_ENTER("C_CopyObject");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hObject=%lu, ulCount=%lu", 
+                       (unsigned long)hSession, (unsigned long)hObject, 
+                       (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_CopyObject", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_CopyObject", rv);
+        return rv;
+    }
+    if (pTemplate == NULL || phNewObject == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_CopyObject", rv);
+        return rv;
+    }
+    if (!WP11_Session_IsRW(session)) {
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_CopyObject", rv);
+        return rv;
+    }
 
     /* Need key type and whether object is to be on the token to create a new
      * object. Get the object type from original object and where to store
@@ -1134,24 +1177,46 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession,
                       CK_OBJECT_HANDLE hObject)
 {
     int ret;
+    CK_RV rv;
     WP11_Session* session;
     WP11_Object* obj = NULL;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (!WP11_Session_IsRW(session))
-        return CKR_SESSION_READ_ONLY;
+    WOLFPKCS11_ENTER("C_DestroyObject");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DestroyObject", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DestroyObject", rv);
+        return rv;
+    }
+    if (!WP11_Session_IsRW(session)) {
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_DestroyObject", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hObject, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DestroyObject", rv);
+        return rv;
+    }
 
     WP11_Session_RemoveObject(session, obj);
     WP11_Object_Free(obj);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_DestroyObject", rv);
+    return rv;
 }
 
 /**
@@ -1172,24 +1237,46 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession,
 CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession,
                       CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
 {
+    CK_RV rv;
     int ret;
     WP11_Session* session;
     WP11_Object* obj = NULL;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pulSize == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetObjectSize");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetObjectSize", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetObjectSize", rv);
+        return rv;
+    }
+    if (pulSize == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetObjectSize", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hObject, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetObjectSize", rv);
+        return rv;
+    }
 
     *pulSize = CK_UNAVAILABLE_INFORMATION;
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetObjectSize", rv);
+    return rv;
 }
 
 
@@ -1222,39 +1309,75 @@ CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession,
     CK_ATTRIBUTE* attr;
     int i;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pTemplate == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetAttributeValue");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hObject=%lu, ulCount=%lu", 
+                       (unsigned long)hSession, (unsigned long)hObject, 
+                       (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+        return rv;
+    }
+    if (pTemplate == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hObject, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+        return rv;
+    }
 
     /* Check the value and lengths of attributes based on data type. */
     rv = CheckAttributes(pTemplate, ulCount, 0);
-    if (rv != CKR_OK)
+    if (rv != CKR_OK) {
+        WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
         return rv;
+    }
 
     for (i = 0; i < (int)ulCount; i++) {
         attr = &pTemplate[i];
 
         ret = WP11_Object_GetAttr(obj, attr->type, (byte*)attr->pValue,
                                                              &attr->ulValueLen);
-        if (ret == BAD_FUNC_ARG)
-            return CKR_ATTRIBUTE_TYPE_INVALID;
-        else if (ret == BUFFER_E)
-            return CKR_BUFFER_TOO_SMALL;
-        else if (ret == NOT_AVAILABLE_E)
-            return CK_UNAVAILABLE_INFORMATION;
+        if (ret == BAD_FUNC_ARG) {
+            rv = CKR_ATTRIBUTE_TYPE_INVALID;
+            WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+            return rv;
+        }
+        else if (ret == BUFFER_E) {
+            rv = CKR_BUFFER_TOO_SMALL;
+            WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+            return rv;
+        }
+        else if (ret == NOT_AVAILABLE_E) {
+            rv = CK_UNAVAILABLE_INFORMATION;
+            WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+            return rv;
+        }
         else if (ret == CKR_ATTRIBUTE_SENSITIVE)
             rv = ret;
-        else if (ret != 0)
-            return CKR_FUNCTION_FAILED;
+        else if (ret != 0) {
+            rv = CKR_FUNCTION_FAILED;
+            WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
+            return rv;
+        }
     }
 
+    WOLFPKCS11_LEAVE("C_GetAttributeValue", rv);
     return rv;
 }
 
@@ -1283,24 +1406,51 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession,
                           CK_OBJECT_HANDLE hObject,
                           CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
 {
+    CK_RV rv;
     int ret;
     WP11_Session* session;
     WP11_Object* obj;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pTemplate == NULL)
-        return CKR_ARGUMENTS_BAD;
-    if (!WP11_Session_IsRW(session))
-        return CKR_SESSION_READ_ONLY;
+    WOLFPKCS11_ENTER("C_SetAttributeValue");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hObject=%lu, ulCount=%lu", 
+                       (unsigned long)hSession, (unsigned long)hObject, 
+                       (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+        return rv;
+    }
+    if (pTemplate == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+        return rv;
+    }
+    if (!WP11_Session_IsRW(session)) {
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hObject, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+        return rv;
+    }
 
-    return SetAttributeValue(session, obj, pTemplate, ulCount, CK_FALSE);
+    rv = SetAttributeValue(session, obj, pTemplate, ulCount, CK_FALSE);
+    WOLFPKCS11_LEAVE("C_SetAttributeValue", rv);
+    return rv;
 }
 
 /**
@@ -1322,32 +1472,60 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession,
 CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession,
                         CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
 {
+    CK_RV rv;
     WP11_Session* session;
     CK_ATTRIBUTE* attr;
     int onToken = 1;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pTemplate == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_FindObjectsInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+        return rv;
+    }
+    if (pTemplate == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+        return rv;
+    }
 
-    if (WP11_Session_FindInit(session) != 0)
-        return CKR_OPERATION_ACTIVE;
+    if (WP11_Session_FindInit(session) != 0) {
+        rv = CKR_OPERATION_ACTIVE;
+        WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+        return rv;
+    }
 
     FindAttributeType(pTemplate, ulCount, CKA_TOKEN, &attr);
     if (attr != NULL) {
-        if (attr->pValue == NULL)
-            return CKR_ATTRIBUTE_VALUE_INVALID;
-        if (attr->ulValueLen != sizeof(CK_BBOOL))
-            return CKR_ATTRIBUTE_VALUE_INVALID;
+        if (attr->pValue == NULL) {
+            rv = CKR_ATTRIBUTE_VALUE_INVALID;
+            WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+            return rv;
+        }
+        if (attr->ulValueLen != sizeof(CK_BBOOL)) {
+            rv = CKR_ATTRIBUTE_VALUE_INVALID;
+            WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+            return rv;
+        }
         onToken = *(CK_BBOOL*)attr->pValue;
     }
 
     WP11_Session_Find(session, onToken, pTemplate, ulCount);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_FindObjectsInit", rv);
+    return rv;
 }
 
 /**
@@ -1369,16 +1547,33 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession,
                     CK_ULONG ulMaxObjectCount,
                     CK_ULONG_PTR pulObjectCount)
 {
+    CK_RV rv;
     int i;
     CK_OBJECT_HANDLE handle;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (phObject == NULL || pulObjectCount == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_FindObjects");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulMaxObjectCount=%lu", (unsigned long)hSession, (unsigned long)ulMaxObjectCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_FindObjects", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_FindObjects", rv);
+        return rv;
+    }
+    if (phObject == NULL || pulObjectCount == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_FindObjects", rv);
+        return rv;
+    }
 
     for (i = 0; i < (int)ulMaxObjectCount; i++) {
         if (WP11_Session_FindGet(session, &handle) == FIND_NO_MORE_E)
@@ -1387,7 +1582,9 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession,
     }
     *pulObjectCount = i;
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_FindObjects", rv);
+    return rv;
 }
 
 /**
@@ -1401,16 +1598,32 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession,
  */
 CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
 {
+    CK_RV rv;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_FindObjectsFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv);
+        return rv;
+    }
 
     WP11_Session_FindFinal(session);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv);
+    return rv;
 }
 
 
@@ -1437,22 +1650,42 @@ CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
 CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession,
                     CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
 {
+    CK_RV rv;
     int ret;
     WP11_Session* session;
     WP11_Object* obj = NULL;
     CK_KEY_TYPE type;
     int init;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_EncryptInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_EncryptInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_EncryptInit", rv);
+        return rv;
+    }
+    if (pMechanism == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_EncryptInit", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hKey, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_EncryptInit", rv);
+        return rv;
+    }
 
     type = WP11_Object_GetType(obj);
     switch (pMechanism->mechanism) {
@@ -1701,18 +1934,35 @@ CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
                 CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData,
                 CK_ULONG_PTR pulEncryptedDataLen)
 {
+    CK_RV rv;
     int ret;
     WP11_Session* session;
     WP11_Object* obj = NULL;
     word32 encDataLen;
     CK_MECHANISM_TYPE mechanism;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pData == NULL || pulEncryptedDataLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_Encrypt");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Encrypt", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_Encrypt", rv);
+        return rv;
+    }
+    if (pData == NULL || pulEncryptedDataLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_Encrypt", rv);
+        return rv;
+    }
 
     /* Key the key for the encryption operation. */
     WP11_Session_GetObject(session, &obj);
@@ -2024,13 +2274,30 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
     WP11_Object* obj = NULL;
     word32 encPartLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPart == NULL || pulEncryptedPartLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_EncryptUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+        return rv;
+    }
+    if (pPart == NULL || pulEncryptedPartLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+        return rv;
+    }
 
     WP11_Session_GetObject(session, &obj);
     if (obj == NULL)
@@ -2041,23 +2308,34 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
 #ifndef NO_AES
     #ifdef HAVE_AES_CBC
         case CKM_AES_CBC:
-            if (!WP11_Session_IsOpInitialized(session, WP11_INIT_AES_CBC_ENC))
-                return CKR_OPERATION_NOT_INITIALIZED;
+            if (!WP11_Session_IsOpInitialized(session, WP11_INIT_AES_CBC_ENC)) {
+                rv = CKR_OPERATION_NOT_INITIALIZED;
+                WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+                return rv;
+            }
 
             encPartLen = (word32)ulPartLen + WP11_AesCbc_PartLen(session);
             encPartLen &= ~0xf;
             if (pEncryptedPart == NULL) {
                 *pulEncryptedPartLen = encPartLen;
-                return CKR_OK;
+                rv = CKR_OK;
+                WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+                return rv;
+            }
+            if (encPartLen > (word32)*pulEncryptedPartLen) {
+                rv = CKR_BUFFER_TOO_SMALL;
+                WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+                return rv;
             }
-            if (encPartLen > (word32)*pulEncryptedPartLen)
-                return CKR_BUFFER_TOO_SMALL;
 
             ret = WP11_AesCbc_EncryptUpdate(pPart, (int)ulPartLen,
                                                     pEncryptedPart, &encPartLen,
                                                     session);
-            if (ret < 0)
-                return CKR_FUNCTION_FAILED;
+            if (ret < 0) {
+                rv = CKR_FUNCTION_FAILED;
+                WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+                return rv;
+            }
             *pulEncryptedPartLen = encPartLen;
             break;
         case CKM_AES_CBC_PAD:
@@ -2149,10 +2427,14 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
             (void)ret;
             (void)ulPartLen;
             (void)pEncryptedPart;
-            return CKR_MECHANISM_INVALID;
+            rv = CKR_MECHANISM_INVALID;
+            WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+            return rv;
     }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_EncryptUpdate", rv);
+    return rv;
 }
 
 /**
@@ -2183,9 +2465,20 @@ CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession,
     WP11_Object* obj = NULL;
     word32 encPartLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_EncryptFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_EncryptFinal", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pulLastEncryptedPartLen == NULL)
@@ -2331,9 +2624,20 @@ CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession,
     WP11_Object* obj = NULL;
     CK_KEY_TYPE type;
     int init;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_DecryptInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DecryptInit", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pMechanism == NULL)
@@ -2589,9 +2893,20 @@ CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData,
     WP11_Object* obj = NULL;
     word32 decDataLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_Decrypt");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulEncryptedDataLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedDataLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Decrypt", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pEncryptedData == NULL || pulDataLen == NULL)
@@ -2891,9 +3206,20 @@ CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession,
     WP11_Object* obj = NULL;
     word32 decPartLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_DecryptUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DecryptUpdate", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pEncryptedPart == NULL || pulPartLen == NULL)
@@ -3050,9 +3376,20 @@ CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart,
     WP11_Object* obj = NULL;
     word32 decPartLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_DecryptFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DecryptFinal", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pulLastPartLen == NULL)
@@ -3186,21 +3523,39 @@ CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart,
 CK_RV C_DigestInit(CK_SESSION_HANDLE hSession,
                    CK_MECHANISM_PTR pMechanism)
 {
+    CK_RV rv;
     int ret;
     int init;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_DigestInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DigestInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DigestInit", rv);
+        return rv;
+    }
+    if (pMechanism == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DigestInit", rv);
+        return rv;
+    }
 
     if (pMechanism->pParameter != NULL ||
         pMechanism->ulParameterLen != 0) {
-
-        return CKR_MECHANISM_PARAM_INVALID;
+        rv = CKR_MECHANISM_PARAM_INVALID;
+        WOLFPKCS11_LEAVE("C_DigestInit", rv);
+        return rv;
     }
     init = WP11_INIT_DIGEST;
     ret = WP11_Digest_Init(pMechanism->mechanism, session);
@@ -3210,7 +3565,9 @@ CK_RV C_DigestInit(CK_SESSION_HANDLE hSession,
         WP11_Session_SetOpInitialized(session, init);
     }
 
-    return ret;
+    rv = ret;
+    WOLFPKCS11_LEAVE("C_DigestInit", rv);
+    return rv;
 }
 
 /**
@@ -3237,9 +3594,20 @@ CK_RV C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
     word32 hashLen;
     int ret;
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_Digest");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Digest", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pData == NULL || ulDataLen == 0 || pulDigestLen == NULL)
@@ -3271,9 +3639,20 @@ CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
 {
     int ret;
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_DigestUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DigestUpdate", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pPart == NULL || ulPartLen == 0)
@@ -3303,9 +3682,20 @@ CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey)
     int ret;
     WP11_Session* session;
     WP11_Object* obj = NULL;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_DigestKey");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DigestKey", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
 
@@ -3339,9 +3729,20 @@ CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest,
     int ret;
     word32 hashLen;
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_DigestFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DigestFinal", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pulDigestLen == NULL)
@@ -3417,9 +3818,20 @@ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
     WP11_Object* obj = NULL;
     CK_KEY_TYPE type;
     int init = 0;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_SignInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignInit", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pMechanism == NULL)
@@ -3720,9 +4132,20 @@ CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
     WP11_Object* obj = NULL;
     word32 sigLen;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    WOLFPKCS11_ENTER("C_Sign");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Sign", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pData == NULL || pulSignatureLen == NULL)
@@ -4036,9 +4459,20 @@ CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
     WP11_Session* session;
     WP11_Object* obj = NULL;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_SignUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignUpdate", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pPart == NULL)
@@ -4149,9 +4583,20 @@ CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
     WP11_Object* obj = NULL;
     CK_MECHANISM_TYPE mechanism;
     word32 sigLen;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_SignFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignFinal", rv);
+        return rv;
+    }
     if (WP11_Session_Get(hSession, &session) != 0)
         return CKR_SESSION_HANDLE_INVALID;
     if (pulSignatureLen == NULL)
@@ -4281,19 +4726,41 @@ CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession,
     int ret;
     WP11_Session* session;
     WP11_Object* obj;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_SignRecoverInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignRecoverInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SignRecoverInit", rv);
+        return rv;
+    }
+    if (pMechanism == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SignRecoverInit", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hKey, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SignRecoverInit", rv);
+        return rv;
+    }
 
-    return CKR_MECHANISM_INVALID;
+    rv = CKR_MECHANISM_INVALID;
+    WOLFPKCS11_LEAVE("C_SignRecoverInit", rv);
+    return rv;
 }
 
 /**
@@ -4318,17 +4785,36 @@ CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
                     CK_ULONG_PTR pulSignatureLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pData == NULL || ulDataLen == 0 || pulSignatureLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_SignRecover");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignRecover", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SignRecover", rv);
+        return rv;
+    }
+    if (pData == NULL || ulDataLen == 0 || pulSignatureLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SignRecover", rv);
+        return rv;
+    }
 
     (void)pSignature;
 
-    return CKR_OPERATION_NOT_INITIALIZED;
+    rv = CKR_OPERATION_NOT_INITIALIZED;
+    WOLFPKCS11_LEAVE("C_SignRecover", rv);
+    return rv;
 }
 
 /**
@@ -4358,17 +4844,37 @@ CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession,
     WP11_Object* obj = NULL;
     CK_KEY_TYPE type;
     int init = 0;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_VerifyInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_VerifyInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyInit", rv);
+        return rv;
+    }
+    if (pMechanism == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_VerifyInit", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hKey, &obj);
-    if (ret != 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    if (ret != 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyInit", rv);
+        return rv;
+    }
 
     type = WP11_Object_GetType(obj);
     switch (pMechanism->mechanism) {
@@ -4642,13 +5148,30 @@ CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
     WP11_Session* session = NULL;
     WP11_Object* obj = NULL;
     CK_MECHANISM_TYPE mechanism = 0;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pData == NULL || pSignature == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_Verify");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulDataLen=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen, (unsigned long)ulSignatureLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Verify", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_Verify", rv);
+        return rv;
+    }
+    if (pData == NULL || pSignature == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_Verify", rv);
+        return rv;
+    }
 
     WP11_Session_GetObject(session, &obj);
     if (obj == NULL)
@@ -4900,13 +5423,30 @@ CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
     WP11_Session* session;
     WP11_Object* obj = NULL;
     CK_MECHANISM_TYPE mechanism;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPart == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_VerifyUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_VerifyUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyUpdate", rv);
+        return rv;
+    }
+    if (pPart == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_VerifyUpdate", rv);
+        return rv;
+    }
 
     WP11_Session_GetObject(session, &obj);
     if (obj == NULL)
@@ -5001,13 +5541,30 @@ CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession,
     WP11_Session* session = NULL;
     WP11_Object* obj = NULL;
     CK_MECHANISM_TYPE mechanism = 0;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pSignature == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_VerifyFinal");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulSignatureLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_VerifyFinal", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyFinal", rv);
+        return rv;
+    }
+    if (pSignature == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_VerifyFinal", rv);
+        return rv;
+    }
 
     WP11_Session_GetObject(session, &obj);
     if (obj == NULL)
@@ -5105,15 +5662,35 @@ CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,
     WP11_Object* obj;
     CK_BBOOL getVar;
     CK_ULONG getVarLen = sizeof(CK_BBOOL);
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL)
-        return CKR_ARGUMENTS_BAD;
-    if (hKey == 0)
-        return CKR_OBJECT_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_VerifyRecoverInit");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv);
+        return rv;
+    }
+    if (pMechanism == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv);
+        return rv;
+    }
+    if (hKey == 0) {
+        rv = CKR_OBJECT_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv);
+        return rv;
+    }
 
     switch(pMechanism->mechanism) {
         case CKM_RSA_PKCS:
@@ -5185,13 +5762,30 @@ CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession,
     word32 decDataLen;
     CK_MECHANISM_TYPE mechanism;
 #endif
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pSignature == NULL || ulSignatureLen == 0 || pulDataLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_VerifyRecover");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulSignatureLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_VerifyRecover", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_VerifyRecover", rv);
+        return rv;
+    }
+    if (pSignature == NULL || ulSignatureLen == 0 || pulDataLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_VerifyRecover", rv);
+        return rv;
+    }
 
 #ifdef NO_RSA
     (void) pData;
@@ -5263,17 +5857,36 @@ CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,
                             CK_ULONG_PTR pulEncryptedPartLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_DigestEncryptUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv);
+        return rv;
+    }
+    if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv);
+        return rv;
+    }
 
     (void)pEncryptedPart;
 
-    return CKR_OPERATION_NOT_INITIALIZED;
+    rv = CKR_OPERATION_NOT_INITIALIZED;
+    WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv);
+    return rv;
 }
 
 /**
@@ -5299,19 +5912,37 @@ CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,
                             CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_DecryptDigestUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv);
+        return rv;
+    }
     if (pEncryptedPart == NULL || ulEncryptedPartLen == 0 ||
                                                            pulPartLen == NULL) {
-        return CKR_ARGUMENTS_BAD;
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv);
+        return rv;
     }
 
     (void)pPart;
 
-    return CKR_OPERATION_NOT_INITIALIZED;
+    rv = CKR_OPERATION_NOT_INITIALIZED;
+    WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv);
+    return rv;
 }
 
 /**
@@ -5338,17 +5969,36 @@ CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession,
                           CK_ULONG_PTR pulEncryptedPartLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_SignEncryptUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv);
+        return rv;
+    }
+    if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv);
+        return rv;
+    }
 
     (void)pEncryptedPart;
 
-    return CKR_OPERATION_NOT_INITIALIZED;
+    rv = CKR_OPERATION_NOT_INITIALIZED;
+    WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv);
+    return rv;
 }
 
 /**
@@ -5374,19 +6024,37 @@ CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,
                             CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_DecryptVerifyUpdate");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv);
+        return rv;
+    }
     if (pEncryptedPart == NULL || ulEncryptedPartLen == 0 ||
                                                            pulPartLen == NULL) {
-        return CKR_ARGUMENTS_BAD;
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv);
+        return rv;
     }
 
     (void)pPart;
 
-    return CKR_OPERATION_NOT_INITIALIZED;
+    rv = CKR_OPERATION_NOT_INITIALIZED;
+    WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv);
+    return rv;
 }
 
 /**
@@ -5423,12 +6091,28 @@ CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession,
     CK_ULONG getVarLen = sizeof(CK_BBOOL);
     CK_KEY_TYPE keyType;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL || pTemplate == NULL || phKey == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GenerateKey");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GenerateKey", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GenerateKey", rv);
+        return rv;
+    }
+    if (pMechanism == NULL || pTemplate == NULL || phKey == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GenerateKey", rv);
+        return rv;
+    }
 
     switch (pMechanism->mechanism) {
 #ifndef NO_AES
@@ -5549,14 +6233,29 @@ CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession,
     WP11_Object* pub = NULL;
     WP11_Object* priv = NULL;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_GenerateKeyPair");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPublicKeyAttributeCount=%lu, ulPrivateKeyAttributeCount=%lu", (unsigned long)hSession, (unsigned long)ulPublicKeyAttributeCount, (unsigned long)ulPrivateKeyAttributeCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv);
+        return rv;
+    }
     if (pMechanism == NULL || pPublicKeyTemplate == NULL ||
                            pPrivateKeyTemplate == NULL || phPublicKey == NULL ||
                            phPrivateKey == NULL) {
-        return CKR_ARGUMENTS_BAD;
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv);
+        return rv;
     }
 
     switch (pMechanism->mechanism) {
@@ -5716,12 +6415,28 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession,
     word32 serialSize = 0;
     byte* serialBuff = NULL;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL || pulWrappedKeyLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_WrapKey");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hWrappingKey=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hWrappingKey, (unsigned long)hKey);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_WrapKey", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_WrapKey", rv);
+        return rv;
+    }
+    if (pMechanism == NULL || pulWrappedKeyLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_WrapKey", rv);
+        return rv;
+    }
 
     if (! WP11_Session_IsRW(session))
         return CKR_SESSION_READ_ONLY;
@@ -5870,17 +6585,35 @@ CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession,
     byte* workBuffer = NULL;
     CK_ULONG ulUnwrappedLen = ulWrappedKeyLen;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_UnwrapKey");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hUnwrappingKey=%lu, ulWrappedKeyLen=%lu, ulAttributeCount=%lu", (unsigned long)hSession, (unsigned long)hUnwrappingKey, (unsigned long)ulWrappedKeyLen, (unsigned long)ulAttributeCount);
+    }
+    #endif
 
-    if (!WP11_Session_IsRW(session))
-        return CKR_SESSION_READ_ONLY;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_UnwrapKey", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_UnwrapKey", rv);
+        return rv;
+    }
+
+    if (!WP11_Session_IsRW(session)) {
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_UnwrapKey", rv);
+        return rv;
+    }
 
     if (pMechanism == NULL || pWrappedKey == NULL || ulWrappedKeyLen == 0 ||
                                            pTemplate == NULL || phKey == NULL) {
-        return CKR_ARGUMENTS_BAD;
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_UnwrapKey", rv);
+        return rv;
     }
 
     *phKey = CK_INVALID_HANDLE;
@@ -6219,16 +6952,35 @@ CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession,
     CK_ULONG secretKeyLen[2] = { 0, 0 };
 #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pMechanism == NULL || pTemplate == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_DeriveKey");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, hBaseKey=%lu, ulAttributeCount=%lu", (unsigned long)hSession, (unsigned long)hBaseKey, (unsigned long)ulAttributeCount);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_DeriveKey", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_DeriveKey", rv);
+        return rv;
+    }
+    if (pMechanism == NULL || pTemplate == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DeriveKey", rv);
+        return rv;
+    }
     /* phKey can be NULL for CKM_TLS12_KEY_AND_MAC_DERIVE as it is ignored */
     if ((phKey == NULL) &&
-        (pMechanism->mechanism != CKM_TLS12_KEY_AND_MAC_DERIVE))
-        return CKR_ARGUMENTS_BAD;
+        (pMechanism->mechanism != CKM_TLS12_KEY_AND_MAC_DERIVE)) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_DeriveKey", rv);
+        return rv;
+    }
 
     ret = WP11_Object_Find(session, hBaseKey, &obj);
     if (ret != 0)
@@ -6520,22 +7272,47 @@ CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed,
     int ret;
     WP11_Session* session;
     WP11_Slot* slot;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pSeed == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_SeedRandom");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulSeedLen=%lu", (unsigned long)hSession, (unsigned long)ulSeedLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+        return rv;
+    }
+    if (pSeed == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     ret = WP11_Slot_SeedRandom(slot, pSeed, (int)ulSeedLen);
-    if (ret == MEMORY_E)
-        return CKR_DEVICE_MEMORY;
-    if (ret != 0)
-        return CKR_FUNCTION_FAILED;
+    if (ret == MEMORY_E) {
+        rv = CKR_DEVICE_MEMORY;
+        WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+        return rv;
+    }
+    if (ret != 0) {
+        rv = CKR_FUNCTION_FAILED;
+        WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_SeedRandom", rv);
+    return rv;
 }
 
 /**
@@ -6557,20 +7334,45 @@ CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession,
     int ret;
     WP11_Session* session;
     WP11_Slot* slot;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pRandomData == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GenerateRandom");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulRandomLen=%lu", (unsigned long)hSession, (unsigned long)ulRandomLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+        return rv;
+    }
+    if (pRandomData == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     ret = WP11_Slot_GenerateRandom(slot, pRandomData, (int)ulRandomLen);
-    if (ret == MEMORY_E)
-        return CKR_DEVICE_MEMORY;
-    if (ret != 0)
-        return CKR_FUNCTION_FAILED;
+    if (ret == MEMORY_E) {
+        rv = CKR_DEVICE_MEMORY;
+        WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+        return rv;
+    }
+    if (ret != 0) {
+        rv = CKR_FUNCTION_FAILED;
+        WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GenerateRandom", rv);
+    return rv;
 }
diff --git a/src/internal.c b/src/internal.c
index a5897fc0..e836a592 100644
--- a/src/internal.c
+++ b/src/internal.c
@@ -164,6 +164,30 @@ typedef struct WP11_Lock {
 } WP11_Lock;
 #endif
 
+#ifdef DEBUG_WOLFPKCS11
+int wolfpkcs11_debugging = 0;
+
+void wolfPKCS11_Debugging_On(void)
+{
+    wolfpkcs11_debugging = 1;
+    WOLFPKCS11_MSG("debug logging enabled");
+}
+
+void wolfPKCS11_Debugging_Off(void)
+{
+    WOLFPKCS11_MSG("debug logging disabled");
+    wolfpkcs11_debugging = 0;
+}
+#else
+void wolfPKCS11_Debugging_On(void)
+{
+}
+
+void wolfPKCS11_Debugging_Off(void)
+{
+}
+#endif
+
 
 /* Symmetric key data. */
 typedef struct WP11_Data {
diff --git a/src/slot.c b/src/slot.c
index 1c8ef420..35bd748c 100644
--- a/src/slot.c
+++ b/src/slot.c
@@ -46,19 +46,41 @@ CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList,
                     CK_ULONG_PTR pulCount)
 {
     int ret;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (tokenPresent != CK_FALSE && tokenPresent != CK_TRUE)
-        return CKR_ARGUMENTS_BAD;
-    if (pulCount == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetSlotList");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  tokenPresent=%s", tokenPresent ? "TRUE" : "FALSE");
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetSlotList", rv);
+        return rv;
+    }
+    if (tokenPresent != CK_FALSE && tokenPresent != CK_TRUE) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetSlotList", rv);
+        return rv;
+    }
+    if (pulCount == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetSlotList", rv);
+        return rv;
+    }
 
     ret = WP11_GetSlotList(tokenPresent, pSlotList, pulCount);
-    if (ret == BUFFER_E)
-        return CKR_BUFFER_TOO_SMALL;
+    if (ret == BUFFER_E) {
+        rv = CKR_BUFFER_TOO_SMALL;
+        WOLFPKCS11_LEAVE("C_GetSlotList", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetSlotList", rv);
+    return rv;
 }
 
 /* Index into slot id string to place number. */
@@ -86,19 +108,39 @@ static CK_SLOT_INFO slotInfoTemplate = {
  */
 CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
 {
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (!WP11_SlotIdValid(slotID))
-        return CKR_SLOT_ID_INVALID;
-    if (pInfo == NULL)
-        return CKR_ARGUMENTS_BAD;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_GetSlotInfo");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu", (unsigned long)slotID);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetSlotInfo", rv);
+        return rv;
+    }
+    if (!WP11_SlotIdValid(slotID)) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_GetSlotInfo", rv);
+        return rv;
+    }
+    if (pInfo == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetSlotInfo", rv);
+        return rv;
+    }
 
     XMEMCPY(pInfo, &slotInfoTemplate, sizeof(slotInfoTemplate));
     /* Put in the slot id value as two decimal digits. */
     pInfo->slotDescription[SLOT_ID_IDX + 0] = ((slotID / 10) % 10) + '0';
     pInfo->slotDescription[SLOT_ID_IDX + 1] = ((slotID     ) % 10) + '0';
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetSlotInfo", rv);
+    return rv;
 }
 
 static CK_RV checkPinLen(CK_ULONG pinLen)
@@ -152,6 +194,7 @@ static CK_TOKEN_INFO tokenInfoTemplate = {
  */
 CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
 {
+    CK_RV rv;
 #ifndef WOLFPKCS11_NO_TIME
     time_t now, expire;
     struct tm nowTM;
@@ -159,12 +202,28 @@ CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
     WP11_Slot* slot;
     int cnt;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Slot_Get(slotID, &slot) != 0)
-        return CKR_SLOT_ID_INVALID;
-    if (pInfo == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetTokenInfo");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu", (unsigned long)slotID);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetTokenInfo", rv);
+        return rv;
+    }
+    if (WP11_Slot_Get(slotID, &slot) != 0) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_GetTokenInfo", rv);
+        return rv;
+    }
+    if (pInfo == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetTokenInfo", rv);
+        return rv;
+    }
 
     XMEMCPY(pInfo, &tokenInfoTemplate, sizeof(tokenInfoTemplate));
     WP11_Slot_GetTokenLabel(slot, (char*)pInfo->label);
@@ -422,26 +481,52 @@ CK_RV C_GetMechanismList(CK_SLOT_ID slotID,
                          CK_MECHANISM_TYPE_PTR pMechanismList,
                          CK_ULONG_PTR pulCount)
 {
+    CK_RV rv;
     int i;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (!WP11_SlotIdValid(slotID))
-        return CKR_SLOT_ID_INVALID;
-    if (pulCount == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetMechanismList");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu", (unsigned long)slotID);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+        return rv;
+    }
+    if (!WP11_SlotIdValid(slotID)) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+        return rv;
+    }
+    if (pulCount == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+        return rv;
+    }
 
-    if (pMechanismList == NULL)
+    if (pMechanismList == NULL) {
         *pulCount = mechanismCnt;
-    else if (*pulCount < (CK_ULONG)mechanismCnt)
-        return CKR_BUFFER_TOO_SMALL;
+        rv = CKR_OK;
+        WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+        return rv;
+    }
+    else if (*pulCount < (CK_ULONG)mechanismCnt) {
+        rv = CKR_BUFFER_TOO_SMALL;
+        WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+        return rv;
+    }
     else {
         for (i = 0; i < mechanismCnt; i++)
             pMechanismList[i] = mechanismList[i];
         *pulCount = mechanismCnt;
     }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetMechanismList", rv);
+    return rv;
 }
 
 #ifndef NO_RSA
@@ -715,12 +800,30 @@ static CK_MECHANISM_INFO genSecKeyGenMechInfo = {
 CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
                          CK_MECHANISM_INFO_PTR pInfo)
 {
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (!WP11_SlotIdValid(slotID))
-        return CKR_SLOT_ID_INVALID;
-    if (pInfo == NULL)
-        return CKR_ARGUMENTS_BAD;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_GetMechanismInfo");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu, type=%lu", (unsigned long)slotID, (unsigned long)type);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv);
+        return rv;
+    }
+    if (!WP11_SlotIdValid(slotID)) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv);
+        return rv;
+    }
+    if (pInfo == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv);
+        return rv;
+    }
 
     switch (type) {
 #ifndef NO_RSA
@@ -1031,34 +1134,65 @@ CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
 CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin,
                   CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pLabel)
 {
+    CK_RV rv;
     int ret;
     WP11_Slot* slot;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Slot_Get(slotID, &slot) != 0)
-        return CKR_SLOT_ID_INVALID;
-    if (pPin == NULL || pLabel == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_InitToken");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu, ulPinLen=%lu", (unsigned long)slotID, (unsigned long)ulPinLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_InitToken", rv);
+        return rv;
+    }
+    if (WP11_Slot_Get(slotID, &slot) != 0) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_InitToken", rv);
+        return rv;
+    }
+    if (pPin == NULL || pLabel == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_InitToken", rv);
+        return rv;
+    }
 
-    if (checkPinLen(ulPinLen) != CKR_OK)
-        return CKR_PIN_INCORRECT;
+    if (checkPinLen(ulPinLen) != CKR_OK) {
+        rv = CKR_PIN_INCORRECT;
+        WOLFPKCS11_LEAVE("C_InitToken", rv);
+        return rv;
+    }
 
     if (WP11_Slot_IsTokenInitialized(slot)) {
-        if (WP11_Slot_HasSession(slot))
-            return CKR_SESSION_EXISTS;
+        if (WP11_Slot_HasSession(slot)) {
+            rv = CKR_SESSION_EXISTS;
+            WOLFPKCS11_LEAVE("C_InitToken", rv);
+            return rv;
+        }
         if (WP11_Slot_SOPin_IsSet(slot)) {
             ret = WP11_Slot_CheckSOPin(slot, (char*)pPin, (int)ulPinLen);
-            if (ret != 0)
-                return CKR_PIN_INCORRECT;
+            if (ret != 0) {
+                rv = CKR_PIN_INCORRECT;
+                WOLFPKCS11_LEAVE("C_InitToken", rv);
+                return rv;
+            }
         }
     }
 
     ret = WP11_Slot_TokenReset(slot, (char*)pPin, (int)ulPinLen, (char*)pLabel);
-    if (ret != 0)
-        return CKR_FUNCTION_FAILED;
+    if (ret != 0) {
+        rv = CKR_FUNCTION_FAILED;
+        WOLFPKCS11_LEAVE("C_InitToken", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_InitToken", rv);
+    return rv;
 }
 
 /**
@@ -1078,28 +1212,56 @@ CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin,
 CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin,
                 CK_ULONG ulPinLen)
 {
+    CK_RV rv;
     int ret;
     WP11_Slot* slot;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPin == NULL && ulPinLen > 0)
-        return CKR_ARGUMENTS_BAD;
-    if (WP11_Session_GetState(session) != WP11_APP_STATE_RW_SO)
-        return CKR_USER_NOT_LOGGED_IN;
+    WOLFPKCS11_ENTER("C_InitPIN");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulPinLen=%lu", (unsigned long)hSession, (unsigned long)ulPinLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
+    if (pPin == NULL && ulPinLen > 0) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
+    if (WP11_Session_GetState(session) != WP11_APP_STATE_RW_SO) {
+        rv = CKR_USER_NOT_LOGGED_IN;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
 
-    if (checkPinLen(ulPinLen) != CKR_OK)
-        return CKR_PIN_INCORRECT;
+    if (checkPinLen(ulPinLen) != CKR_OK) {
+        rv = CKR_PIN_INCORRECT;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     ret = WP11_Slot_SetUserPin(slot, (char*)pPin, (int)ulPinLen);
-    if (ret != 0)
-        return CKR_FUNCTION_FAILED;
+    if (ret != 0) {
+        rv = CKR_FUNCTION_FAILED;
+        WOLFPKCS11_LEAVE("C_InitPIN", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_InitPIN", rv);
+    return rv;
 }
 
 /**
@@ -1128,49 +1290,95 @@ CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin,
     int state;
     WP11_Slot* slot;
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pOldPin == NULL || pNewPin == NULL)
-        return CKR_ARGUMENTS_BAD;
-    if (checkPinLen(ulOldLen) != CKR_OK)
-        return CKR_PIN_INCORRECT;
-    if (checkPinLen(ulNewLen) != CKR_OK)
-        return CKR_PIN_INCORRECT;
+    WOLFPKCS11_ENTER("C_SetPIN");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulOldLen=%lu, ulNewLen=%lu", 
+                       (unsigned long)hSession, (unsigned long)ulOldLen, (unsigned long)ulNewLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
+    }
+    if (pOldPin == NULL || pNewPin == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
+    }
+    if (checkPinLen(ulOldLen) != CKR_OK) {
+        rv = CKR_PIN_INCORRECT;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
+    }
+    if (checkPinLen(ulNewLen) != CKR_OK) {
+        rv = CKR_PIN_INCORRECT;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
+    }
 
     state = WP11_Session_GetState(session);
     if (state != WP11_APP_STATE_RW_SO && state != WP11_APP_STATE_RW_USER &&
                                             state != WP11_APP_STATE_RW_PUBLIC) {
-        return CKR_SESSION_READ_ONLY;
+        rv = CKR_SESSION_READ_ONLY;
+        WOLFPKCS11_LEAVE("C_SetPIN", rv);
+        return rv;
     }
 
     slot = WP11_Session_GetSlot(session);
     if (state == WP11_APP_STATE_RW_SO) {
         ret = WP11_Slot_CheckSOPin(slot, (char*)pOldPin, (int)ulOldLen);
-        if (ret == PIN_NOT_SET_E)
-            return CKR_USER_PIN_NOT_INITIALIZED;
-        if (ret != 0)
-            return CKR_PIN_INCORRECT;
+        if (ret == PIN_NOT_SET_E) {
+            rv = CKR_USER_PIN_NOT_INITIALIZED;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
+        if (ret != 0) {
+            rv = CKR_PIN_INCORRECT;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
 
         ret = WP11_Slot_SetSOPin(slot, (char*)pNewPin, (int)ulNewLen);
-        if (ret != 0)
-            return CKR_FUNCTION_FAILED;
+        if (ret != 0) {
+            rv = CKR_FUNCTION_FAILED;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
     }
     else {
         ret = WP11_Slot_CheckUserPin(slot, (char*)pOldPin, (int)ulOldLen);
-        if (ret == PIN_NOT_SET_E)
-            return CKR_USER_PIN_NOT_INITIALIZED;
-        if (ret != 0)
-            return CKR_PIN_INCORRECT;
+        if (ret == PIN_NOT_SET_E) {
+            rv = CKR_USER_PIN_NOT_INITIALIZED;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
+        if (ret != 0) {
+            rv = CKR_PIN_INCORRECT;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
 
         ret = WP11_Slot_SetUserPin(slot, (char*)pNewPin, (int)ulNewLen);
-        if (ret != 0)
-            return CKR_FUNCTION_FAILED;
+        if (ret != 0) {
+            rv = CKR_FUNCTION_FAILED;
+            WOLFPKCS11_LEAVE("C_SetPIN", rv);
+            return rv;
+        }
     }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_SetPIN", rv);
+    return rv;
 }
 
 /**
@@ -1198,25 +1406,53 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags,
                     CK_VOID_PTR pApplication, CK_NOTIFY Notify,
                     CK_SESSION_HANDLE_PTR phSession)
 {
+    CK_RV rv;
     WP11_Slot* slot;
     int ret;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Slot_Get(slotID, &slot) != 0)
-        return CKR_SLOT_ID_INVALID;
-    if ((flags & CKF_SERIAL_SESSION) == 0)
-        return CKR_SESSION_PARALLEL_NOT_SUPPORTED;
-    if (phSession == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_OpenSession");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu, flags=%lu", (unsigned long)slotID, (unsigned long)flags);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
+    if (WP11_Slot_Get(slotID, &slot) != 0) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
+    if ((flags & CKF_SERIAL_SESSION) == 0) {
+        rv = CKR_SESSION_PARALLEL_NOT_SUPPORTED;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
+    if (phSession == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
 
     ret = WP11_Slot_OpenSession(slot, flags, pApplication, Notify, phSession);
-    if (ret == SESSION_EXISTS_E)
-        return CKR_SESSION_READ_WRITE_SO_EXISTS;
-    if (ret == SESSION_COUNT_E)
-        return CKR_SESSION_COUNT;
+    if (ret == SESSION_EXISTS_E) {
+        rv = CKR_SESSION_READ_WRITE_SO_EXISTS;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
+    if (ret == SESSION_COUNT_E) {
+        rv = CKR_SESSION_COUNT;
+        WOLFPKCS11_LEAVE("C_OpenSession", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_OpenSession", rv);
+    return rv;
 }
 
 /**
@@ -1229,18 +1465,34 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags,
  */
 CK_RV C_CloseSession(CK_SESSION_HANDLE hSession)
 {
+    CK_RV rv;
     WP11_Slot* slot;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_CloseSession");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_CloseSession", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_CloseSession", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     WP11_Slot_CloseSession(slot, session);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_CloseSession", rv);
+    return rv;
 }
 
 /**
@@ -1253,15 +1505,31 @@ CK_RV C_CloseSession(CK_SESSION_HANDLE hSession)
  */
 CK_RV C_CloseAllSessions(CK_SLOT_ID slotID)
 {
+    CK_RV rv;
     WP11_Slot* slot;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Slot_Get(slotID, &slot) != 0)
-        return CKR_SLOT_ID_INVALID;
+    WOLFPKCS11_ENTER("C_CloseAllSessions");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  slotID=%lu", (unsigned long)slotID);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_CloseAllSessions", rv);
+        return rv;
+    }
+    if (WP11_Slot_Get(slotID, &slot) != 0) {
+        rv = CKR_SLOT_ID_INVALID;
+        WOLFPKCS11_LEAVE("C_CloseAllSessions", rv);
+        return rv;
+    }
     WP11_Slot_CloseSessions(slot);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_CloseAllSessions", rv);
+    return rv;
 }
 
 /**
@@ -1277,14 +1545,31 @@ CK_RV C_CloseAllSessions(CK_SLOT_ID slotID)
 CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession,
                        CK_SESSION_INFO_PTR pInfo)
 {
+    CK_RV rv;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pInfo == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetSessionInfo");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetSessionInfo", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetSessionInfo", rv);
+        return rv;
+    }
+    if (pInfo == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetSessionInfo", rv);
+        return rv;
+    }
 
     pInfo->state = WP11_Session_GetState(session);
     pInfo->flags = CKF_SERIAL_SESSION;
@@ -1292,7 +1577,9 @@ CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession,
         pInfo->flags |= CKF_RW_SESSION;
     pInfo->ulDeviceError = 0;
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetSessionInfo", rv);
+    return rv;
 }
 
 /**
@@ -1315,16 +1602,34 @@ CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession,
                           CK_ULONG_PTR pulOperationStateLen)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pulOperationStateLen == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_GetOperationState");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetOperationState", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetOperationState", rv);
+        return rv;
+    }
+    if (pulOperationStateLen == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetOperationState", rv);
+        return rv;
+    }
 
-    return WP11_GetOperationState(session, pOperationState,
-        pulOperationStateLen);
+    rv = WP11_GetOperationState(session, pOperationState, pulOperationStateLen);
+    WOLFPKCS11_LEAVE("C_GetOperationState", rv);
+    return rv;
 }
 
 /**
@@ -1348,19 +1653,38 @@ CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession,
                           CK_OBJECT_HANDLE hAuthenticationKey)
 {
     WP11_Session* session;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_SetOperationState");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, ulOperationStateLen=%lu", 
+                       (unsigned long)hSession, (unsigned long)ulOperationStateLen);
+    }
+    #endif
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pOperationState == NULL)
-        return CKR_ARGUMENTS_BAD;
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_SetOperationState", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_SetOperationState", rv);
+        return rv;
+    }
+    if (pOperationState == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_SetOperationState", rv);
+        return rv;
+    }
 
     (void)hEncryptionKey;
     (void)hAuthenticationKey;
 
-    return WP11_SetOperationState(session, pOperationState,
-        ulOperationStateLen);
+    rv = WP11_SetOperationState(session, pOperationState, ulOperationStateLen);
+    WOLFPKCS11_LEAVE("C_SetOperationState", rv);
+    return rv;
 }
 
 /**
@@ -1388,47 +1712,96 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
               CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
 {
     int ret;
+    CK_RV rv;
     WP11_Slot* slot;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    if (pPin == NULL)
-        return CKR_ARGUMENTS_BAD;
+    WOLFPKCS11_ENTER("C_Login");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu, userType=%lu, ulPinLen=%lu", 
+                       (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
+    if (pPin == NULL) {
+        rv = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
 
-    if (checkPinLen(ulPinLen) != CKR_OK)
-        return CKR_PIN_INCORRECT;
+    if (checkPinLen(ulPinLen) != CKR_OK) {
+        rv = CKR_PIN_INCORRECT;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     if (userType == CKU_SO) {
         ret = WP11_Slot_SOLogin(slot, (char*)pPin, (int)ulPinLen);
-        if (ret == LOGGED_IN_E)
-            return CKR_USER_ALREADY_LOGGED_IN;
-        if (ret == READ_ONLY_E)
-            return CKR_SESSION_READ_ONLY_EXISTS;
-        if (ret == PIN_NOT_SET_E)
-            return CKR_USER_PIN_NOT_INITIALIZED;
-        if (ret != 0)
-            return CKR_PIN_INCORRECT;
-
+        if (ret == LOGGED_IN_E) {
+            rv = CKR_USER_ALREADY_LOGGED_IN;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+        if (ret == READ_ONLY_E) {
+            rv = CKR_SESSION_READ_ONLY_EXISTS;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+        if (ret == PIN_NOT_SET_E) {
+            rv = CKR_USER_PIN_NOT_INITIALIZED;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+        if (ret != 0) {
+            rv = CKR_PIN_INCORRECT;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
     }
     else if (userType == CKU_USER) {
         ret = WP11_Slot_UserLogin(slot, (char*)pPin, (int)ulPinLen);
-        if (ret == LOGGED_IN_E)
-            return CKR_USER_ALREADY_LOGGED_IN;
-        if (ret == PIN_NOT_SET_E)
-            return CKR_USER_PIN_NOT_INITIALIZED;
-        if (ret != 0)
-            return CKR_PIN_INCORRECT;
-    }
-    else if (userType == CKU_CONTEXT_SPECIFIC)
-        return CKR_OPERATION_NOT_INITIALIZED;
-    else
-        return CKR_USER_TYPE_INVALID;
+        if (ret == LOGGED_IN_E) {
+            rv = CKR_USER_ALREADY_LOGGED_IN;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+        if (ret == PIN_NOT_SET_E) {
+            rv = CKR_USER_PIN_NOT_INITIALIZED;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+        if (ret != 0) {
+            rv = CKR_PIN_INCORRECT;
+            WOLFPKCS11_LEAVE("C_Login", rv);
+            return rv;
+        }
+    }
+    else if (userType == CKU_CONTEXT_SPECIFIC) {
+        rv = CKR_OPERATION_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
+    else {
+        rv = CKR_USER_TYPE_INVALID;
+        WOLFPKCS11_LEAVE("C_Login", rv);
+        return rv;
+    }
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_Login", rv);
+    return rv;
 }
 
 /**
@@ -1441,18 +1814,34 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
  */
 CK_RV C_Logout(CK_SESSION_HANDLE hSession)
 {
+    CK_RV rv;
     WP11_Slot* slot;
     WP11_Session* session;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
+    WOLFPKCS11_ENTER("C_Logout");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_Logout", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_Logout", rv);
+        return rv;
+    }
 
     slot = WP11_Session_GetSlot(session);
     WP11_Slot_Logout(slot);
 
-    return CKR_OK;
+    rv = CKR_OK;
+    WOLFPKCS11_LEAVE("C_Logout", rv);
+    return rv;
 }
 
 /**
@@ -1466,12 +1855,28 @@ CK_RV C_Logout(CK_SESSION_HANDLE hSession)
 CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    return CKR_FUNCTION_NOT_PARALLEL;
+    WOLFPKCS11_ENTER("C_GetFunctionStatus");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv);
+        return rv;
+    }
+    rv = CKR_FUNCTION_NOT_PARALLEL;
+    WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv);
+    return rv;
 }
 
 /**
@@ -1485,12 +1890,28 @@ CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
 CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession)
 {
     WP11_Session* session;
+    CK_RV rv;
 
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (WP11_Session_Get(hSession, &session) != 0)
-        return CKR_SESSION_HANDLE_INVALID;
-    return CKR_FUNCTION_NOT_PARALLEL;
+    WOLFPKCS11_ENTER("C_CancelFunction");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  hSession=%lu", (unsigned long)hSession);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_CancelFunction", rv);
+        return rv;
+    }
+    if (WP11_Session_Get(hSession, &session) != 0) {
+        rv = CKR_SESSION_HANDLE_INVALID;
+        WOLFPKCS11_LEAVE("C_CancelFunction", rv);
+        return rv;
+    }
+    rv = CKR_FUNCTION_NOT_PARALLEL;
+    WOLFPKCS11_LEAVE("C_CancelFunction", rv);
+    return rv;
 }
 
 /**
@@ -1505,12 +1926,26 @@ CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession)
 CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot,
                          CK_VOID_PTR pReserved)
 {
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
+    CK_RV rv;
+
+    WOLFPKCS11_ENTER("C_WaitForSlotEvent");
+    #ifdef DEBUG_WOLFPKCS11
+    if (wolfpkcs11_debugging) {
+        WOLFPKCS11_MSG("  flags=%lu", (unsigned long)flags);
+    }
+    #endif
+
+    if (!WP11_Library_IsInitialized()) {
+        rv = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_WaitForSlotEvent", rv);
+        return rv;
+    }
 
     (void)pSlot;
     (void)flags;
     (void)pReserved;
 
-    return CKR_FUNCTION_NOT_SUPPORTED;
+    rv = CKR_FUNCTION_NOT_SUPPORTED;
+    WOLFPKCS11_LEAVE("C_WaitForSlotEvent", rv);
+    return rv;
 }
diff --git a/src/wolfpkcs11.c b/src/wolfpkcs11.c
index 4b510b43..d9823da9 100644
--- a/src/wolfpkcs11.c
+++ b/src/wolfpkcs11.c
@@ -109,12 +109,19 @@ static CK_FUNCTION_LIST wolfpkcs11FunctionList = {
  */
 CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
 {
-    if (ppFunctionList == NULL)
-        return CKR_ARGUMENTS_BAD;
+    CK_RV ret;
+    WOLFPKCS11_ENTER("C_GetFunctionList");
+    
+    if (ppFunctionList == NULL) {
+        ret = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetFunctionList", ret);
+        return ret;
+    }
 
     *ppFunctionList = &wolfpkcs11FunctionList;
-
-    return CKR_OK;
+    ret = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetFunctionList", ret);
+    return ret;
 }
 
 /**
@@ -126,12 +133,19 @@ CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
  */
 CK_RV C_Initialize(CK_VOID_PTR pInitArgs)
 {
-    if (WP11_Library_Init() != 0)
-        return CKR_FUNCTION_FAILED;
+    CK_RV ret;
+    WOLFPKCS11_ENTER("C_Initialize");
+    
+    if (WP11_Library_Init() != 0) {
+        ret = CKR_FUNCTION_FAILED;
+        WOLFPKCS11_LEAVE("C_Initialize", ret);
+        return ret;
+    }
 
     (void)pInitArgs;
-
-    return CKR_OK;
+    ret = CKR_OK;
+    WOLFPKCS11_LEAVE("C_Initialize", ret);
+    return ret;
 }
 
 /**
@@ -142,11 +156,15 @@ CK_RV C_Initialize(CK_VOID_PTR pInitArgs)
  */
 CK_RV C_Finalize(CK_VOID_PTR pReserved)
 {
+    CK_RV ret;
+    WOLFPKCS11_ENTER("C_Finalize");
+    
     WP11_Library_Final();
 
     (void)pReserved;
-
-    return CKR_OK;
+    ret = CKR_OK;
+    WOLFPKCS11_LEAVE("C_Finalize", ret);
+    return ret;
 }
 
 /* Information about the Crypto-Ki library. */
@@ -168,13 +186,23 @@ static CK_INFO wolfpkcs11Info = {
  */
 CK_RV C_GetInfo(CK_INFO_PTR pInfo)
 {
-    if (!WP11_Library_IsInitialized())
-        return CKR_CRYPTOKI_NOT_INITIALIZED;
-    if (pInfo == NULL)
-        return CKR_ARGUMENTS_BAD;
+    CK_RV ret;
+    WOLFPKCS11_ENTER("C_GetInfo");
+    
+    if (!WP11_Library_IsInitialized()) {
+        ret = CKR_CRYPTOKI_NOT_INITIALIZED;
+        WOLFPKCS11_LEAVE("C_GetInfo", ret);
+        return ret;
+    }
+    if (pInfo == NULL) {
+        ret = CKR_ARGUMENTS_BAD;
+        WOLFPKCS11_LEAVE("C_GetInfo", ret);
+        return ret;
+    }
 
     XMEMCPY(pInfo, &wolfpkcs11Info, sizeof(wolfpkcs11Info));
-
-    return CKR_OK;
+    ret = CKR_OK;
+    WOLFPKCS11_LEAVE("C_GetInfo", ret);
+    return ret;
 }
 
diff --git a/tests/README.md b/tests/README.md
index 3c868cce..32fbe0be 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -4,3 +4,4 @@ The test files have the following purposes:
 * `pkcs11test.c`: is the standard tests
 * `pkcs11mtt.c`: is the multithreaded tests
 * `pkcs11str.c`: is a storage test
+* `debug_test.c`: is a debug functionality demonstration test
diff --git a/tests/debug_test.c b/tests/debug_test.c
new file mode 100644
index 00000000..578c3ec1
--- /dev/null
+++ b/tests/debug_test.c
@@ -0,0 +1,125 @@
+/* debug_test.c
+ *
+ * Copyright (C) 2006-2025 wolfSSL Inc.
+ *
+ * This file is part of wolfPKCS11.
+ *
+ * wolfPKCS11 is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfPKCS11 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "wolfpkcs11/pkcs11.h"
+
+#ifdef DEBUG_WOLFPKCS11
+static FILE* original_stdout = NULL;
+static FILE* capture_file = NULL;
+
+static void setup_output_capture(void)
+{
+    original_stdout = stdout;
+    capture_file = tmpfile();
+    if (capture_file) {
+        stdout = capture_file;
+    }
+}
+
+static int check_debug_output(void)
+{
+    char buffer[1024];
+    int found_debug = 0;
+    
+    if (!capture_file) {
+        return 0;
+    }
+    
+    stdout = original_stdout;
+    rewind(capture_file);
+    
+    while (fgets(buffer, sizeof(buffer), capture_file)) {
+        if (strstr(buffer, "WOLFPKCS11 ENTER:") || 
+            strstr(buffer, "WOLFPKCS11 LEAVE:") ||
+            strstr(buffer, "WOLFPKCS11:")) {
+            found_debug = 1;
+            break;
+        }
+    }
+    
+    fclose(capture_file);
+    return found_debug;
+}
+#endif
+
+int main(void)
+{
+#ifndef DEBUG_WOLFPKCS11
+    printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n");
+    printf("Skipping debug test - returning code 77\n");
+    return 77;
+#else
+    CK_RV rv;
+    CK_FUNCTION_LIST_PTR pFunctionList;
+    int debug_found;
+    
+    printf("=== wolfPKCS11 Debug Test Program ===\n");
+    printf("Debug mode is ENABLED (DEBUG_WOLFPKCS11 defined)\n");
+    
+    printf("\nTesting debug control functions:\n");
+    wolfPKCS11_Debugging_On();
+    printf("Debug enabled\n");
+    
+    wolfPKCS11_Debugging_Off();
+    printf("Debug disabled\n");
+    
+    wolfPKCS11_Debugging_On();
+    printf("Debug re-enabled\n");
+    
+    printf("\nTesting PKCS#11 functions with debug output capture:\n");
+    
+    setup_output_capture();
+    
+    rv = C_GetFunctionList(&pFunctionList);
+    
+    if (rv == CKR_OK && pFunctionList != NULL) {
+        rv = pFunctionList->C_Initialize(NULL);
+        
+        if (rv == CKR_OK) {
+            CK_INFO info;
+            rv = pFunctionList->C_GetInfo(&info);
+            pFunctionList->C_Finalize(NULL);
+        }
+    }
+    
+    debug_found = check_debug_output();
+    
+    printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv);
+    printf("Debug output detection: %s\n", debug_found ? "PASS" : "FAIL");
+    
+    wolfPKCS11_Debugging_Off();
+    printf("Debug disabled at end\n");
+    
+    printf("\n=== Test Complete ===\n");
+    
+    if (!debug_found) {
+        printf("ERROR: No debug output was detected during PKCS#11 function calls\n");
+        return 1;
+    }
+    
+    printf("SUCCESS: Debug output was properly generated\n");
+    return 0;
+#endif
+}
diff --git a/tests/include.am b/tests/include.am
index 8bfcfedd..6bcfe422 100644
--- a/tests/include.am
+++ b/tests/include.am
@@ -26,12 +26,20 @@ noinst_PROGRAMS += tests/rsa_session_persistence_test
 tests_rsa_session_persistence_test_SOURCES = tests/rsa_session_persistence_test.c
 tests_rsa_session_persistence_test_LDADD =
 
+check_PROGRAMS += tests/debug_test
+noinst_PROGRAMS += tests/debug_test
+tests_debug_test_SOURCES = tests/debug_test.c
+tests_debug_test_LDADD =
+
 if BUILD_STATIC
 tests_pkcs11test_LDADD += src/libwolfpkcs11.la
 tests_pkcs11mtt_LDADD  += src/libwolfpkcs11.la
 tests_pkcs11str_LDADD  += src/libwolfpkcs11.la
 tests_token_path_test_LDADD += src/libwolfpkcs11.la
 tests_rsa_session_persistence_test_LDADD += src/libwolfpkcs11.la
+tests_debug_test_LDADD += src/libwolfpkcs11.la
+else
+tests_debug_test_LDADD += src/libwolfpkcs11.la
 endif
 
 EXTRA_DIST += tests/unit.h \
diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h
index d34cedcc..d1c84fb7 100644
--- a/wolfpkcs11/internal.h
+++ b/wolfpkcs11/internal.h
@@ -613,6 +613,30 @@ int WP11_GetOperationState(WP11_Session* session, unsigned char* stateData,
 int WP11_SetOperationState(WP11_Session* session, unsigned char* stateData,
                            unsigned long stateDataLen);
 
+void wolfPKCS11_Debugging_On(void);
+void wolfPKCS11_Debugging_Off(void);
+
+#ifdef DEBUG_WOLFPKCS11
+extern int wolfpkcs11_debugging;
+
+#ifndef WOLFPKCS11_ENTER
+#define WOLFPKCS11_ENTER(funcName) \
+    do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 ENTER: %s\n", funcName); } while(0)
+#endif
+#ifndef WOLFPKCS11_LEAVE
+#define WOLFPKCS11_LEAVE(funcName, ret) \
+    do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 LEAVE: %s, returning %lu\n", funcName, (unsigned long)ret); } while(0)
+#endif
+#ifndef WOLFPKCS11_MSG
+#define WOLFPKCS11_MSG(fmt, ...) \
+    do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", ##__VA_ARGS__); } while(0)
+#endif
+#else
+#define WOLFPKCS11_ENTER(funcName)
+#define WOLFPKCS11_LEAVE(funcName, ret)
+#define WOLFPKCS11_MSG(fmt, ...)
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/wolfpkcs11/pkcs11.h b/wolfpkcs11/pkcs11.h
index 90de21b9..95a1c1e8 100644
--- a/wolfpkcs11/pkcs11.h
+++ b/wolfpkcs11/pkcs11.h
@@ -1095,6 +1095,12 @@ struct CK_FUNCTION_LIST {
 
 };
 
+#ifdef DEBUG_WOLFPKCS11
+/* Debug control functions */
+WP11_API void wolfPKCS11_Debugging_On(void);
+WP11_API void wolfPKCS11_Debugging_Off(void);
+#endif
+
 #ifdef __cplusplus
 }
 #endif