Hck rss bsod work in progress

NetKVM/Common/DebugData.h

@@ -61,7 +61,10 @@ typedef enum class _etagHistoryLogOperation
     hopTxProcess,
     hopPacketReceived, // implementation, when the packet prepared for indication (nbl, length, prio tag, type)
     hopOidRequest,     // implementation, none, OID, on entry(type, 1), on exit (status, 0), on complete (status, 2)
-    hopPnpEvent        // common, none, event, 0, 0
+    hopPnpEvent,       // common, none, event, 0, 0
+    hopNBLDestructor,
+    hopSendCompleteChain,
+    hopSendDone,
 } eHistoryLogOperation;
 
 // {E51FCE18-B3E7-441e-B18C-D9E9B71616F3}

NetKVM/Common/ParaNdis-TX.h

@@ -3,9 +3,14 @@
 #include "ParaNdis-AbstractPath.h"
 #include "ParaNdis_GuestAnnounce.h"
 #include "ParaNdis_LockFreeQueue.h"
+#include "ParaNdis_DebugHistory.h"
 
 /* Must be a power of 2 */
 #define PARANDIS_TX_LOCK_FREE_QUEUE_DEFAULT_SIZE 2048
+#define NBL_MAINTAIN_HISTORY                     0
+#define NBL_CHAINS                               1
+#define SPAWN_TX_PROCESS_FROM_SEND_PATH          1
+#define REPAIR_CHAIN                             (NBL_CHAINS && 1)
 
 /* the maximum number of pages that a single network packet can span.
 refer linux kernel code #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 1), */
@@ -105,6 +110,33 @@ class CNB : public CNdisAllocatableViaHelper<CNB>
     DECLARE_CNDISLIST_ENTRY(CNB);
 };
 
+typedef struct _tChainOfNbls
+{
+    CNdisRefCounter m_NumChained;
+    CNdisRefCounter m_NumCompleted;
+    CNBL *m_FirstInChain;
+} CChainOfNbls;
+
+class NBLHistory : public CNdisAllocatable<NBLHistory, 'NBLH'>
+{
+    DECLARE_CNDISLIST_ENTRY(NBLHistory);
+
+  public:
+    NBLHistory(LPCSTR Func, LPCSTR Title, LPCSTR ParameterMeaning, PVOID Parameter, LPCSTR ValueMeaning, ULONG Value);
+
+  protected:
+    ULONGLONG m_Timestamp;
+    LPCSTR m_Function;
+    LPCSTR m_Title;
+    LPCSTR m_ParameterMeaning;
+    PVOID m_Parameter;
+    LPCSTR m_ValueMeaning;
+    ULONG m_Value;
+    ULONG m_CurrentCPU;
+};
+
+typedef CNdisList<NBLHistory, CLockedAccess, CNonCountingObject> CHistoryList;
+
 class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject, public CAllocationHelper<CNB>
 {
   public:
@@ -129,6 +161,90 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
     {
         return (ParsePriority() && ParseBuffers() && ParseOffloads());
     }
+#if NBL_CHAINS
+    void Die()
+    {
+        // RtlFailFast(FAST_FAIL_RANGE_CHECK_FAILURE);
+        DbgBreakPoint();
+    }
+    void SetInChain(PNET_BUFFER_LIST FirstInChain)
+    {
+        if (FirstInChain != m_NBL)
+        {
+            m_Chain.m_FirstInChain = (CNBL *)FirstInChain->Scratch;
+            LONG serial = m_Chain.m_FirstInChain->m_Chain.m_NumChained.AddRef();
+            m_Chain.m_FirstInChain->AddRef();
+            // set the serial number in chain for information
+            m_Chain.m_NumChained.AddRef(serial);
+        }
+    }
+    void UnsetInChain()
+    {
+        // the NBL was failed mapping, if does not go
+        // to transmit path
+        ParaNdis_DebugHistory(this,
+                              eHistoryLogOperation::hopSendComplete,
+                              m_NBL,
+                              !m_Chain.m_FirstInChain,
+                              m_NBL->Status,
+                              GetCurrentRefCounterUnsafe());
+        if (m_Chain.m_FirstInChain)
+        {
+            m_Chain.m_FirstInChain->m_Chain.m_NumChained.Release();
+            // the head of chain will be released in the destructor
+        }
+    }
+    void CompleteInChain()
+    {
+        auto head = m_Chain.m_FirstInChain;
+        if (head)
+        {
+            if (m_NBL)
+            {
+                // Detach NBL from chained CNBL and chain it the end
+                // of the chain started from m_NBL of the first CNBL
+                // The NBL is fully completed, so STATUS_SUCCESS
+                SetStatus(NDIS_STATUS_SUCCESS);
+                auto rawNbl = DetachInternalObject();
+                // save the serial number in chain
+                rawNbl->Scratch = (PVOID)(LONG)m_Chain.m_NumChained;
+                PNET_BUFFER_LIST *next = &NET_BUFFER_LIST_NEXT_NBL(head->m_NBL);
+
+                // Attach to the tail of NBLs atomically
+                while (InterlockedCompareExchangePointer((PVOID *)next, rawNbl, nullptr))
+                {
+                    next = &NET_BUFFER_LIST_NEXT_NBL(*next);
+                }
+            }
+            LONG completed = head->m_Chain.m_NumCompleted.AddRef();
+            ParaNdis_DebugHistory(this,
+                                  eHistoryLogOperation::hopSendCompleteChain,
+                                  head,
+                                  completed,
+                                  m_Chain.m_NumChained,
+                                  head->GetCurrentRefCounterUnsafe());
+            AddHistory(__FUNCTION__, "", "Head", head, "Completed", completed);
+            if (head->m_Chain.m_NumChained < completed)
+            {
+                // this is a fatal problem, probably caused by
+                // double completion, may cause to list corruption
+                // TODO: assertion??
+                Die();
+            }
+        }
+    }
+#else
+    void SetInChain(PNET_BUFFER_LIST FirstInChain)
+    {
+        UNREFERENCED_PARAMETER(FirstInChain);
+    }
+    void UnsetInChain()
+    {
+    }
+    void CompleteInChain()
+    {
+    }
+#endif
     void StartMapping();
     void RegisterMappedNB(CNB *NB);
     bool MappingSucceeded()
@@ -150,11 +266,6 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
         return !m_Buffers.IsEmpty();
     }
 
-    bool HaveDetachedBuffers()
-    {
-        return m_MappedBuffersDetached != 0;
-    }
-
     PNET_BUFFER_LIST DetachInternalObject();
     // TODO: Needs review
     void NBComplete();
@@ -230,6 +341,10 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
             m_TransferSize += ChunkSize;
         }
     }
+    bool HasNBL() const
+    {
+        return m_NBL != nullptr;
+    }
     ULONG NumberOfBuffers() const
     {
         return m_BuffersNumber;
@@ -238,7 +353,18 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
     {
         return m_ParentTXPath;
     }
-
+#if NBL_MAINTAIN_HISTORY
+    void AddHistory(LPCSTR Func,
+                    LPCSTR Title,
+                    LPCSTR ParameterMeaning = NULL,
+                    PVOID Parameter = NULL,
+                    LPCSTR ValueMeaning = NULL,
+                    ULONG Value = NULL);
+#else
+    void AddHistory(...)
+    {
+    }
+#endif
   private:
     virtual void OnLastReferenceGone() override;
 
@@ -276,6 +402,7 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
     // align storage for CNB on pointer size boundary and provide enough room for it
     ULONG_PTR m_CNB_Storage[(sizeof(CNB) + sizeof(ULONG_PTR) - 1) / sizeof(ULONG_PTR)];
     bool m_HaveFailedMappings = false;
+    bool m_AllNBCompleted = false;
 
     CNdisList<CNB, CRawAccess, CNonCountingObject> m_Buffers;
 
@@ -297,6 +424,9 @@ class CNBL : public CNdisAllocatableViaHelper<CNBL>, public CRefCountingObject,
 #endif
     CAllocationHelper<CNB> *m_NBAllocator;
 
+    CChainOfNbls m_Chain = {};
+    CHistoryList m_History;
+
     CNBL(const CNBL &) = delete;
     CNBL &operator=(const CNBL &) = delete;
 
@@ -363,6 +493,8 @@ class CParaNdisTX : public CParaNdisTemplatePath<CTXVirtQueue>, public CNdisAllo
 
     bool SendMapped(bool IsInterrupt, CRawCNBLList &toWaitingList);
 
+    void DropAllNBls(CRawCNBLList &Completed, NDIS_STATUS Status);
+
     bool FillQueue();
 
     void PostProcessPendingTask(CRawCNBList &toFree, CRawCNBLList &completed);

NetKVM/Common/ParaNdis-Util.h

@@ -335,6 +335,13 @@ class CRefCountingObject
         }
     }
 
+    // this is provided only for tracking / reference
+    // and can't be used for any decision
+    ULONG GetCurrentRefCounterUnsafe()
+    {
+        return (LONG)m_RefCounter;
+    }
+
   protected:
     virtual void OnLastReferenceGone() = 0;
 
@@ -945,8 +952,7 @@ static inline void ParaNdis_CompleteNBLChainWithStatus(NDIS_HANDLE MiniportHandl
 
 static FORCEINLINE void UpdateTimestamp(ULONGLONG &Variable)
 {
-    LARGE_INTEGER li;
-    NdisGetCurrentSystemTime(&li);
+    LARGE_INTEGER li = KeQueryPerformanceCounter(NULL);
     Variable = li.QuadPart;
 }
 

NetKVM/Common/ParaNdis-VirtQueue.h

@@ -378,6 +378,7 @@ class CTXVirtQueue : public CVirtQueue
 
     CNdisList<CTXDescriptor, CRawAccess, CCountingObject> m_Descriptors;
     CNdisList<CTXDescriptor, CRawAccess, CNonCountingObject> m_DescriptorsInUse;
+    ULONGLONG m_LastTxCompletionTimestamp = 0;
     ULONG m_TotalDescriptors = 0;
     ULONG m_FreeHWBuffers = 0;
     // TODO: Temporary

NetKVM/Common/ParaNdis_Debug.cpp

@@ -355,27 +355,27 @@ VOID ParaNdis_OnBugCheck(IN KBUGCHECK_CALLBACK_REASON Reason,
 #endif
 
 #if defined(ENABLE_HISTORY_LOG)
-void ParaNdis_DebugHistory(PARANDIS_ADAPTER *pContext,
+static LONG CurrentHistoryIndex = 0;
+
+void ParaNdis_DebugHistory(PVOID pContext,
                            eHistoryLogOperation op,
                            PVOID pParam1,
                            ULONG lParam2,
                            ULONG lParam3,
                            ULONG lParam4)
 {
     tBugCheckHistoryDataEntry *phe;
-    ULONG index = InterlockedIncrement(&BugCheckData.StaticData.Data.CurrentHistoryIndex);
+    ULONG index = InterlockedIncrement(&CurrentHistoryIndex);
     index = (index - 1) % MAX_HISTORY;
     phe = &BugCheckData.StaticData.History[index];
     phe->Context = (UINT_PTR)pContext;
-    phe->operation = op;
+    phe->operation = (ULONG)op;
     phe->pParam1 = (UINT_PTR)pParam1;
     phe->lParam2 = lParam2;
     phe->lParam3 = lParam3;
     phe->lParam4 = lParam4;
-#if (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 1)
     phe->uIRQL = KeGetCurrentIrql();
     phe->uProcessor = KeGetCurrentProcessorNumber();
-#endif
     NdisGetCurrentSystemTime(&phe->TimeStamp);
 }
 

NetKVM/Common/ParaNdis_DebugHistory.h

@@ -1,6 +1,6 @@
 #pragma once
 
-// #define ENABLE_HISTORY_LOG
+#define ENABLE_HISTORY_LOG
 // #define KEEP_PENDING_NBL
 
 #if !defined(KEEP_PENDING_NBL)
@@ -26,7 +26,7 @@ void ParaNdis_DebugNBLOut(ULONG index, PNET_BUFFER_LIST nbl);
 
 #if !defined(ENABLE_HISTORY_LOG)
 
-void FORCEINLINE ParaNdis_DebugHistory(PARANDIS_ADAPTER *pContext,
+void FORCEINLINE ParaNdis_DebugHistory(PVOID pContext,
                                        eHistoryLogOperation op,
                                        PVOID pParam1,
                                        ULONG lParam2,
@@ -43,7 +43,7 @@ void FORCEINLINE ParaNdis_DebugHistory(PARANDIS_ADAPTER *pContext,
 
 #else
 
-void ParaNdis_DebugHistory(PARANDIS_ADAPTER *pContext,
+void ParaNdis_DebugHistory(PVOID pContext,
                            eHistoryLogOperation op,
                            PVOID pParam1,
                            ULONG lParam2,